C语言中字符串的存储-yiteyi-C++库

在C语言中，可以使用字符指针或字符数组来引用字符串。 字符串作为字符数组

null

C

char str[4] = "GfG" ; /*One extra for string terminator*/

/* OR */

char str[4] = {‘G’, ‘f’, ‘G’, ' ' }; /* ' ' is string terminator */

当字符串声明为字符数组时，它们会像C中其他类型的数组一样存储自动变量然后字符串存储在堆栈段中，如果它是全局变量或静态变量，则存储在堆栈段中数据段等

使用字符指针的字符串 使用字符指针字符串可以通过两种方式存储：

1) 共享段中的只读字符串。在大多数编译器中，当字符串值直接分配给指针时，它存储在函数之间共享的只读块（通常在数据段中）中。

C

char *str = "GfG" ;

在上面的行中，“GfG”存储在共享的只读位置，但指针str存储在读写内存中。您可以将str更改为指向其他对象，但不能更改当前str的值。因此，只有当我们不想在程序的后期修改字符串时，才应该使用这种字符串。

2) 在堆段中动态分配。

字符串像其他动态分配的东西一样存储在C中，可以在函数之间共享。

C

                         char                                     *str;                       
                         int                                     size = 4;                                     /*one extra for ‘ ’*/                       
                         str = (                                     char                                     *)                                     malloc                                     (                                     sizeof                                     (                                     char                                     )*size);                       
                         *(str+0) =                                     'G'                                     ;                       
                         *(str+1) =                                     'f'                                     ;                       
                         *(str+2) =                                     'G'                                     ;                       
                         *(str+3) =                                     ' '                                     ;                       

让我们看一些例子来更好地理解上述存储字符串的方法。

示例1（尝试修改字符串） 以下程序可能会崩溃（给出分段错误），因为行*（str+1）=“n”试图写入只读存储器。

C

                         int                                     main()                       
                         {                       
                                                 char                                     *str;                       
                                                 str =                                     "GfG"                                     ;                                     /* Stored in read only part of data segment */                       
                                                 *(str+1) =                                     'n'                                     ;                                     /* Problem:  trying to modify read only memory */                       
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

下面的程序运行良好，因为str[]存储在可写堆栈段中。

C

                         int                                     main()                       
                         {                       
                                                 char                                     str[] =                                     "GfG"                                     ;                                     /* Stored in stack segment like other auto variables */                       
                                                 *(str+1) =                                     'n'                                     ;                                     /* No problem: String is now GnG */                       
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

下面的程序也可以很好地工作，因为str上的数据存储在可写堆段中。

C

                         int                                     main()                       
                         {                       
                                                 int                                     size = 4;                       
                                   
                                                 /* Stored in heap segment like other dynamically allocated things */                       
                                                 char                                     *str = (                                     char                                     *)                                     malloc                                     (                                     sizeof                                     (                                     char                                     )*size);                       
                                                 *(str+0) =                                     'G'                                     ;                       
                                                 *(str+1) =                                     'f'                                     ;                       
                                                 *(str+2) =                                     'G'                                     ;                       
                                                 *(str+3) =                                     ' '                                     ;                       
                                                 *(str+1) =                                     'n'                                     ;                                     /* No problem: String is now GnG */                       
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

示例2（尝试从函数返回字符串） 下面的程序工作得非常好，因为字符串存储在一个共享段中，存储的数据即使在返回getString（）后仍保留在该段中

C

                         char                                     *getString()                       
                         {                       
                                                 char                                     *str =                                     "GfG"                                     ;                                     /* Stored in read only part of shared segment */                       
                                   
                                                 /* No problem: remains at address str after getString() returns*/                       
                                                 return                                     str;                       
                         }                       
                                   
                         int                                     main()                       
                         {                       
                                                 printf                                     (                                     "%s"                                     , getString());                       
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

下面的程序也可以很好地工作，因为字符串存储在heap段中，而heap段中存储的数据即使在返回getString（）之后仍然存在

C

                         char                                     *getString()                       
                         {                       
                                                 int                                     size = 4;                       
                                                 char                                     *str = (                                     char                                     *)                                     malloc                                     (                                     sizeof                                     (                                     char                                     )*size);                                     /*Stored in heap segment*/                       
                                                 *(str+0) =                                     'G'                                     ;                       
                                                 *(str+1) =                                     'f'                                     ;                       
                                                 *(str+2) =                                     'G'                                     ;                       
                                                 *(str+3) =                                     ' '                                     ;                       
                                   
                                                 /* No problem: string remains at str after getString() returns */                       
                                                 return                                     str;                       
                         }                       
                         int                                     main()                       
                         {                       
                                                 printf                                     (                                     "%s"                                     , getString());                       
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

但是，下面的程序可能会打印一些垃圾数据，因为字符串存储在函数getString（）的堆栈框架中，并且getString（）返回后数据可能不在那里。

C

                         char                                     *getString()                       
                         {                       
                                                 char                                     str[] =                                     "GfG"                                     ;                                     /* Stored in stack segment */                       
                                   
                                                 /* Problem: string may not be present after getString() returns */                       
                                                 /* Problem can be solved if write static before char, i.e. static char str[] = "GfG";*/                       
                                                 return                                     str;                       
                         }                       
                         int                                     main()                       
                         {                       
                                                 printf                                     (                                     "%s"                                     , getString());                       
                                                 getchar                                     ();                       
                                                 return                                     0;                       
                         }                       

如果你在上面的文章中发现任何错误，或者你想分享更多关于字符串存储的信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END