How do I copy a character array into another character array in C using pointers and without using string library?
I've tried this:
Header File:
char strconcat(char a[100], char b[100]) {
int i=0,j=0;
while(a[i] != '\0'){
i++;
}
while(b[j] != '\0'){
a[i] = b[j];
j++;
i++;
}
return a[100];
}
char *strconcat(char *dst, const char *src)
{
char *bak = dst;
while (*dst) dst++;
while (*dst = *src)
{
dst++;
src++;
}
return bak;
}
Note you cannot have char a[100] as your function parameters. In C this notation is automatically converted to char a[] that is equivalent to char *a.
You also don't have to compare things to 0. Omitting a comparison will make that happen by default.
*src being NUL. The value of an assignment expression is the value being assigned.
*src to *dst. It is setting the value of *dst to *src and the loop will stop if that happened to be the null-terminator \0.
dst and src are pointers to arrays. dst points to dst[0], and *dst IS dst[0] (get value of pointer). When I do dst++ I walk the array, and it now points to dst[1], and *dst is dst[1]. So basically I'm doing the same as you but I'm walking the arrays without using i/j indexes.
void strconcat(char *a, char *b)
{
int i=0,j=0;
while(a[i++]!='\0')
;
while(b[j]!='\0')
a[i++]=b[j++];
a[i] = '\0';
}
The first version naively assumes enough space in destination,
char *
my_strcat(char *destp, char *srcp)
{
if(!destp) return(destp); //check that dest is valid
if(!srcp) return(destp); //check that src is valid
char *dp=destp; //save original destp
while(*dp) { dp++; } //find end of destp
while(*srcp)
{
*dp++ = *srcp++; //copy src to dest, then increment
}
return(destp);
}
The second version allows you to specify maximum size for destination,
char *
my_strncat(char *destp, char *srcp, long max)
{
if(!destp) return(destp); //check that dest is valid
if(!srcp) return(destp); //check that src is valid
char *dp=destp; //save original destp
long x=0;
while(*dp && (x<max)) { dp++; ++x; } //find end of destp
while(*srcp && (x<max)) //copy from src while more space in dst
{
*dp++ = *srcp++; ++x; //copy src to dest, then increment
}
*dp = '\0'; //ensure destination null terminated
return(destp);
}
*dp++ = *srcp++; <<< the C standard guarantees that this will be doing what you expect it to do?
*(dp++) = *(srcp++) and (*dp)++ = (*srcp)++ will have completely different behaviours. The absence of parenthesis leaves it open for interpretation unless something guarantees the order of those parameters.(*dp)++ isn't an lvalue), postfix binds stronger than everything else (including (prefix) unary).
ahappens to already have 100 chars worth of text in it before you start the copy operation, or doesn't have a null terminator.strcat()