5

我正在尝试使用指针自己编写 strcpy，但在运行时出现错误。

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

   while (*source != '\0') {
      **destination++ = *source++; //Get an error here
   }
   **destination = '\0';
}

我调用函数如下：

char *str = NULL;
str_cpy(&str, "String");

不好吗？

谢谢！

4

7 回答 7

8

不，这不好。为什么？因为str是NULL指针。它什么都没有。当您尝试将值写入其中时，它们会去哪里？它没有指向任何分配的内存！

您首先必须为str. 你可以做：

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

或者你可以这样做：

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

另外，destination应该是单指针，而不是双指针。好吧，使用双指针在技术上并没有错，只是没有必要。

或者，您可以在函数中分配内存str_cpy，如下所示：

void str_cpy(char **destination, const char *source) {
    *destination = malloc(strlen(source) + 1);
    // ... continue as normal
于 2012-11-19T19:45:35.677 回答
4

为简单起见，这可以在函数的一行中完成。

void mystrcpy(char *dest, const char *src) {
  while (*dest++ = *src++);
}

话虽这么说，您确实需要为dest预先使用分配内存，malloc或者只是通过使用像char dest[256].

于 2012-11-19T19:50:31.457 回答
3

我认为不需要传递指针到指针：

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

并且您需要dst在传递之前分配内存：

const char *src = "String";
char *str = malloc(strlen(src)+1); //plus one for null byte
str_cpy(dst, src);
于 2012-11-19T19:45:49.173 回答
2

您可能应该为该指针分配一些内存，然后再将其传递给填充其指向的函数（在本例中为 NULL）。

例子：

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

strcpy()我建议不要在不提供目标缓冲区大小信息的情况下执行此操作（即，如果您正在编写自己的内容，则对目标缓冲区进行边界检查，否则您的版本具有与已经足够糟糕的相同的安全漏洞）。

注意：除非您打算更改作为目标传递的指针所持有的地址，否则您也不需要使用双指针。您使用的双指针用法阻止了以下传统strcpy()使用模式：

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

数组地址不能作为指针传递，因此您的代码不能在没有中间指针的情况下填充静态数组：

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

strdup()如果这不是故意的（除非您有在内部模拟NULL 指针通道的想法，否则我不明白为什么会这样）您应该解决这个问题。

于 2012-11-19T19:44:30.380 回答
0

这是一个完整的实现。好文章来自这里。描述时间和性能。虽然我没有测量自己。 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;
}
于 2013-05-18T00:26:29.190 回答
0

最近我遇到了与上述相同的问题double pointer strcpy implementation

它可能对以下代码的其他人有所帮助

 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;

}

于 2014-10-11T17:11:51.060 回答
0 
#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';

}

这是我的解决方案..简单易懂..

于 2016-01-26T19:31:07.020 回答