如何正确分配新的字符串值？

Question

我试图以最清洁/最安全的方式了解如何在C中解决这个琐碎的问题。这是我的示例：

#include <stdio.h>

int main(int argc, char *argv[])
{
    typedef struct
    {
        char name[20];
        char surname[20];
        int unsigned age;
    } person;

    // Here I can pass strings as values...how does it work?
    person p = {"John", "Doe", 30};

    printf("Name: %s; Age: %d\n", p.name, p.age);

    // This works as expected...
    p.age = 25;

    //...but the same approach doesn't work with a string
    p.name = "Jane";

    printf("Name: %s; Age: %d\n", p.name, p.age);

    return 1;
}

编译器的错误是：

main.c：在功能'main'：main.c：18： 错误：不兼容的类型 从类型分配给'char [20]' 'char *'

我知道C（不是C ++）没有字符串类型，而是使用char s的数组char s：

#include <stdio.h>

int main(int argc, char *argv[])
{
    typedef struct
    {
        char *name;
        char *surname;
        int unsigned age;
    } person;

    person p = {"John", "Doe", 30};

    printf("Name: %s; Age: %d\n", p.name, p.age);

    p.age = 25;

    p.name = "Jane";

    printf("Name: %s; Age: %d\n", p.name, p.age);

    return 1;
}

这是按预期工作的，但是我想知道是否有更好的方法可以做到这一点。

Answer 1

第一个示例不起作用，因为您无法将值分配给数组 - 数组在这方面像const指针一样工作。但是，您可以做的是将新值复制到数组中：

strcpy(p.name, "Jane");

如果您知道先前知道字符串的最大尺寸，例如，在第一个示例中，您可以使用100％的名称适合19个字符（不是20个字符，总是需要一个字符来存储终止零值）。

相反，如果您不知道字符串的最大尺寸和/或要优化内存使用情况，则指针会更好，例如，避免保留512个字符以“ John”的名称。但是，使用指针，您需要动态分配它们指向的缓冲区，并在不再需要时将其释放，以避免内存泄漏。

更新：动态分配的缓冲区的示例（使用第二个示例中的结构定义）：

char* firstName = "Johnnie";
char* surname = "B. Goode";
person p;

p.name = malloc(strlen(firstName) + 1);
p.surname = malloc(strlen(surname) + 1);

p.age = 25;
strcpy(p.name, firstName);
strcpy(p.surname, surname);

printf("Name: %s; Age: %d\n",p.name,p.age);

free(p.surname);
free(p.name);

Answer 2

将字符串视为抽象对象，将字符阵列作为容器。字符串可以是任何尺寸，但容器必须比字符串长度（以保持空终止符）至少高1个。

C对字符串几乎没有句法支持。没有字符串操作员（仅是Char-Array和Char-Pointer Operators）。您无法分配字符串。

但是您可以调用功能以帮助实现所需的目标。

strncpy（）函数可以在此处使用。为了最大程度的安全性，我建议遵循此模式：

strncpy(p.name, "Jane", 19);
p.name[19] = '\0'; //add null terminator just in case

还请查看strncat（）和memcpy（）函数。

Answer 3

这两个结构是不同的。当您初始化第一个结构时，分配了大约40个字节的内存。当您初始化第二个结构时，分配了大约10个字节。 （实际数量是架构取决于）

您可以使用字符串文字（字符串常数）将字符数组杀死。这就是原因

Person P = {“ John”，“ Doe”，30};

在第一个示例中工作。

您无法（从常规意义上）分配C中的字符串C。

当您的代码执行时，您拥有的字符串文字（“ John”）被加载到内存中。当您用其中一种文字初始化数组时，将字符串复制到新的内存位置中。在第二个示例中，您只是将指针复制到字符串字面的位置。做类似的事情：

char* string = "Hello";
*string = 'C'

可能导致编译或运行时错误（我不确定。）这是一个坏主意，因为您正在修改字符串“ Hello”，例如，在微控制器上，它可以位于只读的内存中。

Answer 4

第一个结构是字符数组[]，第二个结构是字符串的指针 *（64位机器的大小8字节）。 According to Stephen Kochan's book "Programming in C", the only time that C lets you assign a constant string is when defining and initializing a char array as in

char name[20] = { "John Doe" };

not even with

char name[20];
name = { "John Doe" };

In the case of char *name;名称是角色指针，而不是数组。 When you did

p.name = "Jane";

it points to another string object.

person p = { .surname = "Doe", .name = "Johnny", .age = 30 };
printf("Ptr. value:\tp.name: 0x%p;\tp.surname: 0x%p\n", p.name, p.surname);
p.name = "Spy, watch out!";
printf("Ptr. value:\tp.name: 0x%p;\tp.surname: 0x%p\n", p.name, p.surname);

output:

Ptr. value:     p.name: 0x00007FF726F7B16C;     p.surname: 0x00007FF726F7B174
Ptr. value:     p.name: 0x00007FF726F7ACE8;     p.surname: 0x00007FF726F7B174

However, in the character array [] case, after you do

strcpy(p.name, "Jane");

to change its content, the address of the buffer p.name[] never changes.

C和Python之间的一个有趣的相似之处是
Python的字符串是不变的，与C的字符串指针相似
字符串文字是只读的。
Python的列表是可变的，类似于C的角色阵列。

>>> name = "John"
>>> print(hex(id(name)))
0x261654235f0
>>> name = "Jane"
>>> print(hex(id(name)))
0x261654237b0
>>> type(name)
<class 'str'>
>>> name[1] = 'o'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> name = list(name)
>>> type(name)
<class 'list'>
>>> name
['J', 'a', 'n', 'e']
>>> name[1] = 'o'
>>> name
['J', 'o', 'n', 'e']
>>> name = ''.join(name)
>>> name
'Jone'
>>> type(name)
<class 'str'>
>>>

Answer 5

在这两种情况下，您都在编写：

p.age = 25;
p.name = "Jane";

• 不可能在C中分配数组
• 在第一种情况下，p.name是一个数组，在第二种情况下 ，p.Name是char*，可以分配给字符串文字，因为字符串文字是char> char的数组（数组可转换为指针），

您可以使用诸如<<<<代码> strcpy ，memcpy et al。如其他响应中所示，但是您还可以通过分配整个struct来规避此问题。

// compound literal, C99 feature
p = (person) {.age = 25, .name = "Jane", .surname = p.surname};

实际上，将字符串作为char*和size_t捆绑在一起很有用出色地。

Answer 6

这是如何实现安全字符串分配的示例。如果字符串长于目标数组，则断言失败并且程序退出。

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

#define LEN(arr) (sizeof (arr) / sizeof (arr)[0])
#define APAR(arr) (arr), LEN(arr)

void Assign(char target[], int targetLen, const char source[], int sourceLen)
{   
    size_t srcStrLen;
    
    srcStrLen = strnlen(source, sourceLen);
    assert(targetLen > srcStrLen);
    memcpy(target, source, srcStrLen);
    target[srcStrLen] = '\0';
}

int main(void)
{
    typedef struct {
        char name[20];
        char surname[20];
        int unsigned age;
    } person;
    
    person p;
    
    Assign(APAR(p.name), APAR("Jane"));
    Assign(APAR(p.surname), APAR("Anderson"));
    p.age = 25;
    printf("Name: %s %s; Age: %d\n", p.name, p.surname, p.age);
    return 0;
}