strcpy using pointers

Question

I\'m trying to write strcpy on my own using pointers and I get an error during runtime.

void str_cpy(char **destination, const char *source) {
//    char *s1         


        

Answer 1

I don't see any need to pass a pointer-to-pointer:

void str_cpy(char *dst, const char *src) {
   while (*src != '\0') {
      *dst++ = *src++; 
   }
   *dst = '\0';
}

And you need to allocate memory for dst before passing:

const char *src = "String";
char *str = malloc(strlen(src)+1); //plus one for null byte
str_cpy(dst, src);

Answer 2

Recently I faced same problem of above one using double pointer strcpy implementation

It might helpful to others below code

 void strcpy_i( char **dst, const char *src )
 {
    *dst=(char *)malloc((strlen(src)+1)*sizeof(char));

    char *tmp=*dst;

    if(tmp == NULL || src == NULL)
    return ;

    while((*tmp++=*src++)!='\0');
}

int main()
{
    char v[]="Vinay Hunachyal";
    char *d=NULL;

    strcpy_i(&d,v);
    printf("%s",d);

 return 0;

}

Answer 3

You should likely allocate some memory for that pointer before passing it off to a function that fills what it points to (which in this case, is NULL).

Example:

char *str = malloc(128);
if (str)
{
   str_cpy(&str, "String");
   free(str);
   str = NULL;
}

I advise not doing this without also providing target-buffer size information (i.e. if you're writing your own, then boundary-check the target buffer, otherwise your version has the same security flaws as strcpy() which are bad enough as it is).

Note: Unless you're planning on changing the address held by the pointer passed as the target, you need not use a double pointer either. The double pointer usage you have prevents the traditional strcpy() usage pattern of:

char str[128];
str_cpy(&str, "Hello"); // error. 

An array address cannot be passed as a pointer-to-pointer, so your code cannot fill a static array without an intermediate pointer:

char str[128];
char *p = str;
str_cpy(&p, "Hello");  //ok. passing address of pointer.

If this is not intentional (and I don't see why it could be unless you have ideas of internally emulating strdup() on a NULL pointer passage) You should address this.

Answer 4

Here is a complete implementation. Good article from here. Describes timing and performance. I did not measure myself though. http://www.howstuffworks.com/c35.htm

char* mystrcpy(char *dst, const char *src) {
char *ptr = dst;
while ((*dst++ = *src++) ) ;
return ptr;
}

int main(int argc, char *argv[]) {
const char *src = "This is C.\0";
char *dst = malloc(sizeof(char)*(strlen(src)+1)); //+1 for the null character
dst = mystrcpy(dst, src);
printf("%s",dst);
return 1;
}

Answer 5

No, it's not okay. Why? Because str is a NULL pointer. It's pointing to nothing. When you try to write values into it, where will they go? It's not pointing to any allocated memory!

You first have to allocate memory for str. You can do:

char *str = malloc(strlen("String") + 1); // + 1 for the '\0' character at the end of C-style strings

Or you can do:

char str[256]; // make str large enough to hold 256 chars. Note that this is not as safe as the above version!

Also, destination should be a single pointer, not a double pointer. Well, it's not technically wrong to use a double pointer, it's just unnecessary.

Optionally, you can allocate the memory in the str_cpy function, like so:

void str_cpy(char **destination, const char *source) {
    *destination = malloc(strlen(source) + 1);
    // ... continue as normal

Answer 6

#include<stdio.h>
void main()
{

    void mystrcpy(char *,char *);

    char s1[100],s2[100];
    char *p1;
    char *p2;
    p1=s1;
    p2=s2;
    printf("Enter the string to copy to s2...?\n");
    scanf("%s",p1);


    mystrcpy(p2,p1);

    printf("S2 after copying = %s",p2);

}
void mystrcpy(char *p2,char *p1)
{
    while(*p1!='\0')
    {
        *p2=*p1;
        p2++;
        p1++;
    }
    *p2='\0';

}

Its my solution..Simple to understand..