Een deel van een string (substring) kopiëren in C

Ik heb een string:

char * someString;

Als ik de eerste vijf letters van deze tekenreeks wil en deze wil instellen op otherString, hoe moet ik dat dan doen?

Antwoord 1, autoriteit 100%

#include <string.h>
...
char otherString[6]; // note 6, not 5, there's one there for the null terminator
...
strncpy(otherString, someString, 5);
otherString[5] = '\0'; // place the null terminator

Antwoord 2, autoriteit 17%

Gegeneraliseerd:

char* subString (const char* input, int offset, int len, char* dest)
{
  int input_len = strlen (input);
  if (offset + len > input_len)
  {
     return NULL;
  }
  strncpy (dest, input + offset, len);
  return dest;
}
char dest[80];
const char* source = "hello world";
if (subString (source, 0, 5, dest))
{
  printf ("%s\n", dest);
}

Antwoord 3, autoriteit 12%

char* someString = "abcdedgh";
char* otherString = 0;
otherString = (char*)malloc(5+1);
memcpy(otherString,someString,5);
otherString[5] = 0;

UPDATE:
Tip:een goede manier om definities te begrijpen is de rechts-linksregel (enkele links aan het einde):

Begin met lezen vanaf de identifier en zeg hardop => “someStringis…”
Ga nu naar rechts van een string (instructie is geëindigd met een puntkomma, niets te zeggen).
Ga nu links van identifier (*wordt aangetroffen) => dus zeg “…een verwijzing naar…”.
Ga nu naar links van “*” (het trefwoord charis gevonden) => zeg “..char”.
Klaar!

Dus char* someString;=> “someString is een pointer naar char”.

Omdat een aanwijzer eenvoudigweg naar een bepaald geheugenadres wijst, kan deze ook worden gebruikt als het “startpunt” voor een “array” van tekens.

Dat werkt met alles.. probeer het eens:

char* s[2]; //=> s is an array of two pointers to char
char** someThing; //=> someThing is a pointer to a pointer to char.
//Note: We look in the brackets first, and then move outward
char (* s)[2]; //=> s is a pointer to an array of two char

Enkele links:
Complexe C/C++-declaraties interpreterenen
C-verklaringen lezen

Antwoord 4, autoriteit 8%

Je moet geheugen toewijzen voor de nieuwe string otherString. Over het algemeen kan voor een substring met lengte n iets als dit voor u werken (vergeet niet om de grenzen te controleren…)

char *subString(char *someString, int n) 
{
   char *new = malloc(sizeof(char)*n+1);
   strncpy(new, someString, n);
   new[n] = '\0';
   return new;
}

Dit retourneert een substring van de eerste n karakters van een string. Zorg ervoor dat u het geheugen vrijmaakt wanneer u klaar bent met free().

Antwoord 5, autoriteit 6%

Je kunt snprintf gebruiken om nauwkeurig een substring van een char-array te krijgen. Hier is een bestandsvoorbeeld genaamd “substring.c”:

#include <stdio.h>
int main()
{
    const char source[] = "This is a string array";
    char dest[17];
    // get first 16 characters using precision
    snprintf(dest, sizeof(dest), "%.16s", source);
    // print substring
    puts(dest);
} // end main

Uitvoer:

Dit is een string

Opmerking:

Zie voor meer informatie de printf man-pagina.

Antwoord 6, autoriteit 3%

Je kunt C-strings als pointers behandelen. Dus wanneer u declareert:

char str[10];

strkan als aanwijzer worden gebruikt. Dus als u slechts een deel van de tekenreeks wilt kopiëren, kunt u het volgende gebruiken:

char str1[24] = "This is a simple string.";
char str2[6];
strncpy(str1 + 10, str2,6);

Dit kopieert 6 tekens uit de str1array naar str2vanaf het 11e element.

Antwoord 7, autoriteit 2%

Ik denk dat het een gemakkelijke manier is… maar ik weet niet hoe ik de resultaatvariabele direct kan doorgeven, dan maak ik een lokale char-array als temp en retourneer deze.

char* substr(char *buff, uint8_t start,uint8_t len, char* substr)
{
    strncpy(substr, buff+start, len);
    substr[len] = 0;
    return substr;
}

Antwoord 8, autoriteit 2%

Deze code is substrfunctie die de functie van dezelfde naam in andere talen nabootst, ontleden gewoon: string, start en aantal tekens zoals:

#include <stdio.h>
printf( "SUBSTR: %s", substr("HELLO WORLD!",2,5) );

Het bovenstaande zal HELLO afdrukken. Als u een waarde over de lengte van de tekenreeks doorgeeft, wordt deze stilzwijgend genegeerd, omdat de lus alleen de lengte van de tekenreeks herhaalt.

#include <stdlib.h>
char *substr(char *s, int a, int b) {
    char *r = (char*)malloc(b);
    strcpy(r, "");
    int m=0, n=0;
    while(s[n]!='\0')
    {
        if ( n>=a && m<b ){
            r[m] = s[n];
            m++;
        }   
        n++;
    }
    r[m]='\0';
    return r;
}

Antwoord 9

strncpy(otherString, someString, 5);

Vergeet niet om geheugen toe te wijzen aan otherString.

Antwoord 10

#include <stdio.h>
#include <string.h>
int main ()
{
        char someString[]="abcdedgh";
        char otherString[]="00000";
        memcpy (otherString, someString, 5);
        printf ("someString: %s\notherString: %s\n", someString, otherString);
        return 0;
}

Je hebt stdio.h niet nodig als je de instructie printf niet gebruikt en constanten in alle programma’s behalve de kleinste programma’s plaatst, is een slechte vorm en moet worden vermeden.

Antwoord 11

Alles in twee keer doen:

char *otherString = strncpy((char*)malloc(6), someString);
otherString[5] = 0;

Antwoord 12

char largeSrt[] = "123456789-123";  // original string
char * substr;
substr = strchr(largeSrt, '-');     // we save the new string "-123"
int substringLength = strlen(largeSrt) - strlen(substr); // 13-4=9 (bigger string size) - (new string size) 
char *newStr = malloc(sizeof(char) * substringLength + 1);// keep memory free to new string
strcpy(newStr, largeSrt, substringLength);  // copy only 9 characters 
newStr[substringLength] = '\0'; // close the new string with final character
printf("newStr=%s\n", newStr);
free(newStr);   // you free the memory