Comment concaténer des chaînes de 2 C sans écraser les caractères Null de terminaison?

Question

J'essaye de mettre en place une liste de noms de fichiers pour un paramètre à SHFileOperation. Je veux être en mesure de concaténer un nom de fichier sur le tableau char, mais je ne veux pas me débarrasser du caractère de fin. par exemple, je veux ceci:
C: \ ... \ 0E: \ ... \ 0F: \ ... \ 0 \ 0


quand j'utilise strcat(), il écrase le null, donc il ressemble à
C: \ ... E: \ ... F: \ ... 0 \

Y at-il un moyen facile de le faire? ou vais-je devoir coder un nouveau strcat pour moi-même?

Answer 1

Le code est assez simple. Utilisez un pointeur d'aide pour suivre où la chaîne suivante devrait commencer. Pour mettre à jour le pointeur du suivi, incrémentez la longueur de la chaîne +1:

const char *data[] = { "a", "b", "c" }; 
size_t data_count = sizeof(data)/sizeof(*data); 
size_t d; 
size_t buffer_size; 
char *buffer; 
char *next; 

// calculate the size of the buffer 
for (d = 0; d < data_count; ++d) 
    buffer_size += (strlen(data[d] + 1); 
buffer_size += 1; 

buffer = malloc(buffer_size); 

// Next will track where we write the next string 
next = buffer; 

for (d = 0; d < data_count; ++d) 
{ 
    strcpy(next, data[d]); 

    // Update next to point to the first character after the terminating NUL 
    next += strlen(data[d]) + 1; 
} 
*next = '\0'; 

Answer 2

Utilisez memcpy.

memcpy(dest, src1, strlen(src1)+1); 
memcpy(&dest[strlen(src1)+1], src2, strlen(src2)+1); 

Answer 3

Utilisation de la GNU stpcpy() peut être un peu plus élégant, si vous savoir à l'avance la « longueur » maximale du tableau de caractères résultant.

char *src[] = {"C:\\foo", "E:\\bar", "F:\\foobar", 0}; 
char dst[MY_MAX_LEN], *p = dst; 
int i; 

for (i = 0; src[i]; i++) 
    p = stpcpy(p, src) + 1; 
*p = 0; 
assert(p < dst + sizeof dst); 

Si nécessaire, stpcpy() peut être définie comme:

char *stpcpy(char * restrict dst, const char * restrict src) 
{ 
    return strcpy(dst, src) + strlen(src); 
} 

Answer 4

il suffit d'utiliser strcat pour ajouter à la chaîne d'origine, mais ajouter un au décalage de sorte que vous êtes sans passer par 0 de la chaîne précédente terminateur.

// an example 

    char testString [256]; 

    strcpy (testString, "Test1"); 

    strcat (testString + strlen(testString)+1, "Test2"); 
    strcat (testString + strlen(testString)+1, "Test3"); 

testString va maintenant contenir "Test1 \ 0Test2 \ 0Test3 \ 0"