implémentation simple strcat avec des pointeurs

Question

donc je pratiquais l'écriture de code c avec des pointeurs en utilisant le K & R. Pour un problème avec strcat fonction, je ne pouvais pas savoir ce qui ne va pas avec mon code qui, selon Visual Studio , retourné la chaîne de destination inchangée après la fonction strcat. Toute suggestion est appréciée!

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
int strcat(char* s, char* t); 
int main(void) 
{ 
char *s="hello ", *t="world"; 
strcat(s,t); 
printf("%s",s); 
return 0; 
} 

int strcat(char* s,char* t) 
{ 
int i; 
i=strlen(s)+strlen(t); 
s=(char*) malloc(i); 
while(*s!='\0') 
    s++; 
while('\0'!=(*s++=*t++)) 
    ; 
return 0; 
} 

Answer 1

1) définir la chaîne de cette manière

char *s="hello " 

signifie que vous défini une chaîne littérale. une chaîne de caractères est enregistrée dans la mémoire morte de sorte que vous ne pouvez pas modifier

vous devez définir votre chaîne comme un tableau de caractères afin de pouvoir le modifier

char s[100] = "hello "; 

2) lorsque vous définissez votre fonction de cette manière

int strcat(char* s,char* t) 

vous ne pouvez pas changer l'adresse de s dans la fonction strcat(). Ainsi, l'affectation mémoire avec malloc() dans la fonction ne changera pas l'adresse s au moment de quitter la fonction

3) changer votre fonction strcat à

int strcat(char** s,char* t) 
{ 
    int i; 
    char *u, *v; 
    i=strlen(*s)+strlen(t); 
    v = *s; 
    u=(char*) malloc(i+1); 
    while(*v!='\0') 
     *u++ = *v++; 
    while('\0'!=(*u++=*t++)); 
    *s = u; 
    return 0; 
} 

et que vous appelez dans la principale avec:

char *s="hello ", *t="world"; 
strcat(&s,t); 

Answer 2

Dans

strcat(char* s, char* t) 

le 's' est s fin par valeur. La valeur de 's' au moment de l'appel est copiée dans la pile, puis strcat() est appel. Au retour de strcat, la version modifiée est supprimée de la pile. Donc la valeur d'appel de 's' n'est jamais changée (et vous créez une fuite de mémoire). Beward, en C chaque cellule de mémoire peut être modifiée, même les sections de paramètres ou d'instructions; certains changements peuvent être très difficiles à comprendre.

Answer 3

1. Je suis assez sûr que strcat retourne un char* dans la mise en œuvre réelle (tenant la valeur initiale de la première chaîne).
2. strcat n'est pas censé modifier l'adresse du premier paramètre, donc vous ne devriez pas appeler malloc.
3. point # 2 signifie que vous devez déclarer char *s comme char s[20] dans main (où 20 est un nombre arbitraire assez grand pour contenir la chaîne entière).

Si vous voulez vraiment modifier la valeur du paramètre d'entrée, vous devrez passer l'adresse de la valeur - il devrait être strcat(char **s, ...) dans la déclaration de fonction/définition, et a appelé à strcat(&s, ...) dans main .

Answer 4

Puisque vous essayez de faire comme le vrai strcat il est dit que le premier paramètre

The string s1 must have sufficient space to hold the result. 

de sorte que vous n'avez pas besoin d'utiliser malloc

char *strcat(char* s, const char* t); 
int main(void) 
{ 
    char s[15] = {0}; // 
    char *t = "world"; //const char * so you can't change it 

    strcpy(s, "Hello "); 
    strcat(s,t); 
    printf("%s\n",s); 
    return (0); 
} 

char *strcat(char* s, const char* t) 
{ 
    int i = 0; 

    while (s[i] != '\0') 
    i++; 
    while (*t != '\0') 
    s[i++] = *t++; 
    s[i] = '\0'; //useless because already initialized with 0 
    return (s); 
} 

Answer 5

#include<stdio.h> 
#include<string.h> 
#define LIMIT 100 
void strcatt(char*,char*); 
main() 
{ 
int i=0; 
char s[LIMIT]; 
char t[LIMIT]; 
strcpy(s,"hello"); 
strcpy(t,"world"); 
strcatt(s,t); 
printf("%s",s); 
getch(); 
} 
void strcatt(char *s,char *t) 
{ 

while(*s!='\0') 
{  
s++; 
} 
*s=' '; 
++s; 
while(*t!='\0') 
{ 
    *s=*t; 
    s++; 
    t++; 
} 
*s=*t; 
} 

Answer 6

Cher utilisateur,

vous n'avez pas à compliquer les choses. Le code pour strcat plus simple, en utilisant des pointeurs:

void strcat(char *s, char *t) { 
    while(*s++); /*This will point after the '\0' */ 
    --s; /*So we decrement the pointer to point to '\0' */ 
    while(*s++ = *t++); /*This will copy the '\0' from *t also */ 
} 

Bien, cela vous ne donnera pas rapport au sujet de la réussite de la concaténation.

Regardez cette partie main() pour le reste de la réponse:

int main() { 
    char s[60] = "Hello "; 
    char *t = "world!"; 

    strcat(s, t); 
    printf("%s\n", s); 

    return 0; 
} 

La partie s[60] est très important, parce que vous ne pouvez pas concaténer une autre corde à sa fin si elle ne dispose pas d'assez d'espace pour ça.