Question

如果我们使用例如：

   char* strs[2];
    strs[1] = "Hello";
    strs[2] = "World!";
    strcat(strs[1],strs[2]);

然后出现访问冲突（访问冲突写入位置0x0028CC75）。

为什么使用const char *strs[2];，因为strs1[1]，strs1[2]无法更改？

Answer 1

// string literals are non-writeable so const is appropriate here
const char* strs[2] = {"Hello", "World!"};
// let's create a target buffer with sufficient space
char buffer[20];
// copy the first string there
strcpy(buffer, strs[0]);
// add the second string there
strcat(buffer, strs[1]);

Answer 2

您案件中访问冲突的两个来源

字符串文字是只读的，写入它们是未定义的行为
在c数组中，基于0索引，因此strs[2]不存在，只有strs[0]和strs[1]。

使用const可以防止您意外修改它们，但它不会禁止您。

阵列是可以修改的，

#include <stdio.h>
#include <string.h>

int
main(void)
 {
    char strs[2][11] = {"Hello", "World"};
    strcat(strs[0], strs[1]);
    return 0;
 }

以上按预期工作。

这是您使用动态分配正确完成的方法

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char *
autostrcat(const char *const head, const char *const tail)
 {
    char  *result;
    size_t headlen;
    size_t taillen;

    if ((head == NULL) || (tail == NULL))
        return NULL;

    headlen = strlen(head);
    taillen = strlen(tail);
    result  = malloc(1 + headlen + taillen);
    if (result == NULL)
        return NULL;
    memcpy(result, head, headlen);
    memcpy(&result[headlen], tail, taillen);

    result[headlen + taillen] = '\0';
    return result;
 }

int
main(void)
 {
    const char *strs[2] = {"Hello", "World"};
    char *result = autostrcat(strs[0], strs[1]);
    if (result != NULL)
        printf("%s\n", result);
    free(result);
    return 0;
 }

由于您使用了strlen()，因此您知道字符串的长度是多少，因此使用strcat()会非常昂贵，因为它会再次将第一个字符串的长度计算为strlen()确实

Answer 3

哇。这么多错。

数组是基于0的，而不是基于C的1。
字符串基于程序空间，很可能，因此不可写。

你应该创建一个缓冲区，然后填充它。

char* concat = (char *) _alloca(strlen(strs[0]) + strlen(strs[1])+1);
strcpy(concat, strs[0]);
strcat(concat, strs[1]);

当我们无法更改指针的包含时，为什么要使用const char * prt1

3 个答案: