La concaténation de chaîne sans strcat en C

 char a1[] = "Vivek";

Va créer un tableau de char a1 de taille 6. Vous essayez de le farcir avec plus de caractères qu'il peut contenir.

Si vous voulez être en mesure d'accueillir de concaténation "Vivek" et "Ratnavel" vous avez besoin d'avoir un char tableau de taille au moins 14 (5 + 8 + 1).

Dans votre modifié programme, vous êtes en train de faire:

char *a1=(char*)malloc(100);  //1
a1 = "Vivek";                 //2

1: Va allouer de la mémoire d'une partie de la taille de 100 octets, fait a1 point.

2: Va faire a1 point de la chaîne de caractères littérale "Vivek". Cette chaîne de caractères littérale ne peut pas être modifié.

Pour résoudre ce utiliser strcpy à la copie de la chaîne dans la mémoire allouée:

char *a1=(char*)malloc(100);  
strcpy(a1,"Vivek");

Également la for condition de boucle i<strlen(b1)-1 de ne pas copier le dernier caractère de la chaîne, changer de i<strlen(b1)

Et

a1[i]='
a1[i]='\0';
';

devrait être

a1[i + len]='
a1[i + len]='\0';
';

que la nouvelle longueur de a1 est i+len et vous avez besoin d'avoir le caractère NUL à l'index.

Et n'oubliez pas de free votre mémoire allouée dynamiquement une fois que vous avez terminé de l'utiliser.

OriginalL'auteur codaddict

Problèmes:

1. length n'est pas une fonction. strlen est, mais vous ne devriez probablement pas l'appeler dans une boucle - b1's longueur ne change pas sur nous, il sera? Aussi, il renvoie une size_t, qui peut être de la même taille que int sur votre plate-forme, mais sera signé. Cela peut (mais n'est pas souvent) provoquer des erreurs, mais vous devrait le faire de toute façon.
2. a1 a seulement assez d'espace pour la première chaîne, parce que le compilateur ne sait pas à allouer plus d'espace de pile pour le reste de la chaîne depuis. Si vous fournissez une taille explicite, comme [100], qui devrait être suffisant pour vos besoins. Si vous avez besoin d'robuste code qui n'est pas de faire des hypothèses sur ce qui est "assez", vous devriez regarder dans malloc et les amis, mais cela peut être une leçon pour un autre jour.
3. Votre boucle s'arrête trop tôt. i < b1_len (en supposant que vous avez une variable, b1_len, qui a été mis à la longueur de b1 avant la boucle a commencé) serait suffisant - strlen ne compte pas les '\0' à la fin.
4. Mais en parlant de comptage de la '\0' à la fin, un peu plus efficace la mise en œuvre pourrait utiliser sizeof a1 - 1 au lieu de strlen(a1) dans ce cas, puisque a1 (et b1) sont déclarées sous la forme de tableaux, pas de pointeurs. C'est votre choix, mais n'oubliez pas que sizeof ne fonctionne pas pour les pointeurs, afin de ne pas les confondre.
   
   EDIT: de Nouveaux problèmes:
5. char *p = malloc(/*some*/); p = /* something */ est un problème. = avec les pointeurs ne pas copier le contenu de la copie de la valeur, de sorte que vous avez à jeter les vieux pointeur de la valeur que vous avez obtenu d' malloc. Pour copier le contenu d'une chaîne de caractères dans un char * (ou un char [] d'ailleurs), vous devrez utiliser strcpy, strncpy, ou (ma préférence) memcpy. (Ou juste une boucle, mais c'est plutôt ridicule. Puis de nouveau, il peut être une bonne pratique si vous êtes en train de rédiger votre propre strcat.)
6. Sauf si vous êtes à l'aide de C++, je ne jette pas la valeur de retour de malloc, mais c'est une guerre de religion et nous n'avons pas besoin l'un de ceux.

7. Si vous avez strdup, l'utiliser. Si vous ne le faites pas, voici un travail de mise en œuvre:

   char *strdup(const char *c)
   {
       size_t l = strlen(c);
       char *d = malloc(l + 1);
       if(d) memcpy(d, c, l + 1);
       return d;
   }

   C'est l'une des fonctions les plus utiles pas dans la bibliothèque C standard.

OriginalL'auteur Chris Lutz

je pense que c'est une question facile.

#include<stdio.h>
int xstrlen(char *);
void xstrcat(char *,char *,int);
void main()
{
    char source[]="Sarker";
    char target[30]="Maruf";
    int j=xstrlen(target);
    xstrcat(target,source,j);
    printf("Source String: %s\nTarget String: %s",source,target);
}
int xstrlen(char *s)
{
    int len=0;
    while(*s!='
#include<stdio.h>
int xstrlen(char *);
void xstrcat(char *,char *,int);
void main()
{
char source[]="Sarker";
char target[30]="Maruf";
int j=xstrlen(target);
xstrcat(target,source,j);
printf("Source String: %s\nTarget String: %s",source,target);
}
int xstrlen(char *s)
{
int len=0;
while(*s!='\0')
{
len++;
s++;
}
return len;
}
void xstrcat(char *t,char *s,int j)
{
while(*t!='\0')
{
*t=*t;
t++;
}
while(*s!='\0')
{
*t=*s;
s++;
t++;
}
}
')
    {
        len++;
        s++;
    }
    return len;
}
void xstrcat(char *t,char *s,int j)
{
    while(*t!='
#include<stdio.h>
int xstrlen(char *);
void xstrcat(char *,char *,int);
void main()
{
char source[]="Sarker";
char target[30]="Maruf";
int j=xstrlen(target);
xstrcat(target,source,j);
printf("Source String: %s\nTarget String: %s",source,target);
}
int xstrlen(char *s)
{
int len=0;
while(*s!='\0')
{
len++;
s++;
}
return len;
}
void xstrcat(char *t,char *s,int j)
{
while(*t!='\0')
{
*t=*t;
t++;
}
while(*s!='\0')
{
*t=*s;
s++;
t++;
}
}
')
    {
        *t=*t;
        t++;
    }
    while(*s!='
#include<stdio.h>
int xstrlen(char *);
void xstrcat(char *,char *,int);
void main()
{
char source[]="Sarker";
char target[30]="Maruf";
int j=xstrlen(target);
xstrcat(target,source,j);
printf("Source String: %s\nTarget String: %s",source,target);
}
int xstrlen(char *s)
{
int len=0;
while(*s!='\0')
{
len++;
s++;
}
return len;
}
void xstrcat(char *t,char *s,int j)
{
while(*t!='\0')
{
*t=*t;
t++;
}
while(*s!='\0')
{
*t=*s;
s++;
t++;
}
}
')
    {
        *t=*s;
        s++;
        t++;
    }
}

OriginalL'auteur MARUF