【C++】内存中的字符串

前文 内存中的字符串类型 学习研究了Go的字符串在内存中的结构和数据类型。

文本是两年多前的一篇学习笔记，研究的是C++字符串在内存中的结构。

环境

 
 
 
 
    
  
  
  
  
  1. 1. 操作系统：Ubuntu 16.04。 
    2. 
  
  
  
  
  2. 2. 调试软件：GNU gdb (Ubuntu 7.11.1-0ubuntu1~16.5) 7.11.1。 
    3. 
  
  
  
  
  3. 3. 编译工具：g++ (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609。 
    4.

string类的定义

string定义在/usr/include/c++/5/bits/stringfwd.h头文件中，如下：

 
 
 
 
    
  
  
  
  
  1. typedef basic_string string; 
    2.

basic_string类的定义通过泛型编程技术实现，详细定义请参考/usr/include/c++/5/bits/basic_string.h头文件，看起来非常复杂，具体实现此处并不关心，不再讨论。

测试string对象占用内存空间

通过以下代码可以测试string类对象占用内存空间情况。

 
 
 
 
    
  
  
  
  
  1. // demo.cpp 
    2. 
  
  
  
  
  2. #include  
    3. 
  
  
  
  
  3. #include  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. int main(int argc, char const *argv[]) 
    6. 
  
  
  
  
  6. { 
    7. 
  
  
  
  
  7.     using namespace std; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.     string s15(15, 'a'); // 字符串长度15 
    10. 
  
  
  
  
  10.     string s16(16, 'x'); // 字符串长度16 
    11. 
  
  
  
  
  11.      
    12. 
  
  
  
  
  12.     cout << "sizeof(string) = " << sizeof(string) << endl; 
    13. 
  
  
  
  
  13.     cout << "sizeof(s15) = " << sizeof(s15) << endl; 
    14. 
  
  
  
  
  14.     cout << "sizeof(s16) = " << sizeof(s16) << endl; 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.     return 0; 
    17. 
  
  
  
  
  17. } 
    18.

因为32位和64位可执行程序不同，以下将分别编译测试。

将以上代码编译成32位可执行程序并执行，结果如下：

 
 
 
 
    
  
  
  
  
  1. $ g++ -m32 -g demo.cpp 
    2. 
  
  
  
  
  2. $ ./a.out  
    3. 
  
  
  
  
  3. sizeof(string) = 24 
    4. 
  
  
  
  
  4. sizeof(s15) = 24 
    5. 
  
  
  
  
  5. sizeof(s16) = 24 
    6.

从以上输出结果，可以十分确定string类对象在内存中占用24个字节。

将以上代码编译成64位可执行程序并执行，结果如下：

 
 
 
 
    
  
  
  
  
  1. $ g++ -m64 -g demo.cpp 
    2. 
  
  
  
  
  2. $ ./a.out 
    3. 
  
  
  
  
  3. sizeof(string) = 32 
    4. 
  
  
  
  
  4. sizeof(s15) = 32 
    5. 
  
  
  
  
  5. sizeof(s16) = 32 
    6.

从以上输出结果，可以十分确定string类对象在内存中占用32个字节。

32位可执行程序string对象的内存分配

为了查看内存分配，需要用到动态调试工具，此处使用gdb，并在源码16行设置断点。

调试过程中，打印main方法的栈数据，以及string对象及相关数据的内存，可以清晰看到string对象数据的内存占用情况。

 
 
 
 
    
  
  
  
  
  1. $ gdb a.out  
    2. 
  
  
  
  
  2. GNU gdb (Ubuntu 7.11.1-0ubuntu1~16.5) 7.11.1 
    3. 
  
  
  
  
  3. Reading symbols from a.out...done. 
    4. 
  
  
  
  
  4. (gdb) b 16 
    5. 
  
  
  
  
  5. Breakpoint 1 at 0x8048a80: file demo.cpp, line 16. 
    6. 
  
  
  
  
  6. (gdb) r 
    7. 
  
  
  
  
  7. Starting program: a.out  
    8. 
  
  
  
  
  8. sizeof(string) = 24 
    9. 
  
  
  
  
  9. sizeof(s15) = 24 
    10. 
  
  
  
  
  10. sizeof(s16) = 24 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12. Breakpoint 1, main (argc=1, argv=0xffffced4) at demo.cpp:16 
    13. 
  
  
  
  
  13. 16      return 0; 
    14. 
  
  
  
  
  14. (gdb) x /24wx $esp  // 以16进制格式打印24个宽度为4字节的main函数堆栈数据（共96个字节） 
    15. 
  
  
  
  
  15. 0xffffcdd0:  0x08048790  0x0804a0ed  0x0804a04c  0xffffced4 
    16. 
  
  
  
  
  16. 0xffffcde0:  0xffffffff  0x00004a00  0xffffce08  0xffffcdf4 
    17. 
  
  
  
  
  17. 0xffffcdf0:  0x0000000f  0x61616161  0x61616161  0x61616161 
    18. 
  
  
  
  
  18. 0xffffce00:  0x00616161  0x0804fa10  0x00000010  0x00000010 
    19. 
  
  
  
  
  19. 0xffffce10:  0x00000001  0xffffced4  0xffffcedc  0xd0415500 
    20. 
  
  
  
  
  20. 0xffffce20:  0xffffce40  0x00000000  0x00000000  0xf7c86637 
    21. 
  
  
  
  
  21. (gdb) x /wx &s15    // 打印变量s15的内存地址 
    22. 
  
  
  
  
  22. 0xffffcdec:  0xffffcdf4 
    23. 
  
  
  
  
  23. (gdb) x /6xw 0xffffcdec // 打印string对象s15占用的24个字节内存数据 
    24. 
  
  
  
  
  24. 0xffffcdec:  0xffffcdf4  0x0000000f  0x61616161  0x61616161 
    25. 
  
  
  
  
  25. 0xffffcdfc:  0x61616161  0x00616161 
    26. 
  
  
  
  
  26. (gdb) x /s 0xffffcdf4   // string对象s15的1-4个字节是一个指向字符数据的指针 
    27. 
  
  
  
  
  27. 0xffffcdf4:  'a'  
    28. 
  
  
  
  
  28. (gdb) x /16x 0xffffcdf4 // string对象s15的9-24个字节是代表数据的字符数组 
    29. 
  
  
  
  
  29. 0xffffcdf4:  0x61  0x61  0x61  0x61  0x61  0x61  0x61  0x61 
    30. 
  
  
  
  
  30. 0xffffcdfc:  0x61  0x61  0x61  0x61  0x61  0x61  0x61  0x00 
    31. 
  
  
  
  
  31. (gdb) x /wx &s16    // 打印变量s16的内存地址 
    32. 
  
  
  
  
  32. 0xffffce04:  0x0804fa10 
    33. 
  
  
  
  
  33. (gdb) x /6xw 0xffffce04 // 打印string对象s16占用的24个字节内存数据 
    34. 
  
  
  
  
  34. 0xffffce04:  0x0804fa10  0x00000010  0x00000010  0x00000001 
    35. 
  
  
  
  
  35. 0xffffce14:  0xffffced4  0xffffcedc 
    36. 
  
  
  
  
  36. (gdb) x /s 0x0804fa10  // string对象s16的1-4个字节是一个指向字符数据的指针 
    37. 
  
  
  
  
  37. 0x804fa10:  'x'  
    38. 
  
  
  
  
  38. (gdb) x /16x 0x0804fa10 
    39. 
  
  
  
  
  39. 0x804fa10:  0x78  0x78  0x78  0x78  0x78  0x78  0x78  0x78 
    40. 
  
  
  
  
  40. 0x804fa18:  0x78  0x78  0x78  0x78  0x78  0x78  0x78  0x78 
    41. 
  
  
  
  
  41. (gdb) c 
    42. 
  
  
  
  
  42. Continuing. 
    43. 
  
  
  
  
  43. [Inferior 1 (process 20982) exited normally] 
    44. 
  
  
  
  
  44. (gdb) q 
    45.

从以上调试可以看出，string对象的内存结构和以下结构体的非常相似：

 
 
 
 
    
  
  
  
  
  1. typedef long int u32; 
    2. 
  
  
  
  
  2. struct String 
    3. 
  
  
  
  
  3. { 
    4. 
  
  
  
  
  4.     char *data_ptr; // 指向字符数组的指针，在32位程序占用4个字节 
    5. 
  
  
  
  
  5.     u32 length;     // 字符数组的长度，在32位程序占用4个字节 
    6. 
  
  
  
  
  6.     char data[16];  // 可以容纳15个字符的数组，占用16个字节 
    7. 
  
  
  
  
  7. }; 
    8.

1.string对象的1-4个字节是一个指向字符数据的指针。

2.string对象的5-8个字节是一个表示字符数据长度的整形数值。

3.string对象的9-24个字节的含义根据字符数据的长度发生变化。

  • 如果string对象包含的字符数组长度小于16，则将字符数据保存在string对象本身所占用的内存中;以上述结构体String为例，将字符数据保存在data中。
  • s15.data_ptr == &(s15.data[0]);
  • 如果string对象包含的字符数组长度大于等于16，则其字符数据位于可执行文件的数据区或分配到堆内存中，而不是栈内存中;以上述结构体String为例，无法将字符数据保存在data字段中。

64位可执行程序string对象的内存分配

64位程序与32位程序非常相似，只不过64程序中，指针对象占用8字节内存;通过动态调试，发现内存分配与以下结构体非常相似：

 
 
 
 
    
  
  
  
  
  1. typedef long long int u64; 
    2. 
  
  
  
  
  2. struct String 
    3. 
  
  
  
  
  3. { 
    4. 
  
  
  
  
  4.     char *data_ptr; // 指向字符数组的指针，在64位机器占用8个字节 
    5. 
  
  
  
  
  5.     u64 length;     // 字符数组的长度，在64位机器占用8个字节 
    6. 
  
  
  
  
  6.     char data[16];  // 可以容纳15个字符的数组，占用16个字节 
    7. 
  
  
  
  
  7. }; 
    8.

以上内容是两年多前的学习笔记，最近在以下环境中进行测试，得到的结论与上述内容一致。

 
 
 
 
    
  
  
  
  
  1. 操作系统：Ubuntu 20.04。 
    2. 
  
  
  
  
  2. 调试软件：GNU gdb (Ubuntu 9.2-0ubuntu1~20.04) 9.2。 
    3. 
  
  
  
  
  3. 编译工具：g++ (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0。 
    4.

本文转载自微信公众号「Golang In Memory」

当前名称：【C++】内存中的字符串
网站网址：http://www.shufengxianlan.com/qtweb/news7/320907.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

软件开发知识

同城分类信息

服务器托管　　 　网站优化排名推广　　 　成都网站建设报价　　 　雅安电信机房　　 　软文营销　　 　香港云主机　　 　成都宣传海报　　 　特丽尔硅藻泥　　 　网站制作报价　　 　成都网站设计　　 　成都商城网站建设公司　　 　重庆服务器托管　　 　品牌网站定制　　 　梅州网站建设　　 　成都微信公众号开发　　 　成都网站制作　　 　资阳做网站　　 　网站制作　　 　定制网站设计　　 　门户网站建设方案