C-C++之string和char的使用及区别

本文深入剖析C语言中以\0结尾的char数组(C风格字符串)与C++中std::string类的本质差异:前者是无类型约束的内存约定,后者是具备内存管理、长度保障和值语义的安全类型。重点涵盖char类型语义、三种C字符串形态、std::string内部结构(含SSO)、互转方法及七大典型坑点(如指针失效、缓冲区溢出、字面量修改、局部数组返回等),强调在混合编程中正确传参、避免未定义行为。

前言


初学 C/C++ 的人几乎都会经历同一个困惑:一会儿写 char s[] = "abc";,一会儿写 char* p = "abc";,一会儿又写 std::string s = "abc";——三者看起来都在"存字符串",但行为、生命周期、可否修改、能不能相互赋值,处处不同。更麻烦的是,C 与 C++ 混用时,编译器给出的报错往往只能意会不能言传,比如 const char* 无法转换为 char*、sizeof 出来的值跟想象的字符数不一样。


这背后的核心矛盾其实只有一句话:C 语言的字符串是"以 '\0' 结尾的 char 数组"这一约定,不是一种类型;而 C++ 的 std::string 是一个真正管理内存的类。理解了这句话,剩下的全是细节推论。本文从 char 本身讲起,再讲 C 风格字符串的三种形态,最后讲 std::string,并给出互转、传参、以及真实踩坑的完整示例。


一、char 到底是什么:一个"最小的整数"


char 首先是一个整数类型,大小恒为 1 字节(sizeof(char) == 1,这是标准规定)。它能否表示负数取决于实现:




类型取值范围(典型)说明



char-128 ~ 127 或 0 ~ 255由实现定义,x86 上多为有符号

signed char-128 ~ 127明确有符号

unsigned char0 ~ 255明确无符号



这一点带来的第一个实用结论是:凡是把 char 当作"字节值"参与算术或下标运算(如哈希、位图、UTF-8 解析),一律用 unsigned char。 一个字节 0xE4(UTF-8 汉字首字节)作为有符号 char 是 -28,直接用作数组下标就会越界。


#include <stdio.h>
int main(void) {
char c = (char)0xE4;
unsigned char u = 0xE4;
printf("char=%d, unsigned char=%u, sizeof(char)=%zu\n",
(int)c, (unsigned)u, sizeof(char)); // char=-28, unsigned char=228, 1
return 0;
}

字符串字面量 "abc" 的类型也不是 char*,而是 const char[4](含结尾 '\0')。它在 C 中被隐式转换为 char* 仅为兼容历史,修改它属于未定义行为;在 C++ 中则根本不允许把 const char* 赋给 char*。


二、C 风格字符串的三种形态




写法存储位置可修改生命周期



char a[] = "abc";栈(数组,拷贝一份)✅ 可改随作用域结束

char* p = "abc";字面量在只读段(rodata)❌ 改了崩溃程序全程有效

char* p = malloc(n)堆✅ 可改到 free 为止

static char a[] = "abc";静态数据区✅ 可改程序全程有效



关键区别在于数组会拷贝,指针只指向字面量:


#include <stdio.h>

void demo(void) {
char a[] = "hello"; // 栈上 6 字节,内容是 'h','e','l','l','o','\0'
char* p = "hello"; // p 指向只读段的 6 字节

a[0] = 'H'; // ✅ 合法,输出 Hello
// p[0] = 'H'; // ❌ 未定义行为,多数平台直接段错误
printf("%s %s\n", a, p);
}

sizeof 在这里也是坑:sizeof(a) 是数组大小 6,sizeof(p) 是指针大小 8(64 位),与字符串长度无关。求长度必须用 strlen。


char a[] = "hello";
char* p = a;
printf("%zu %zu %zu\n", sizeof(a), sizeof(p), strlen(a)); // 6 8 5

三、std::string 是什么


std::string 是 std::basic_string<char> 的别名,是一个管理动态内存的类:



  • 内部维护"数据指针 + 长度 + 容量",字符串内容存在堆上(短字符串可能被 SSO 优化存进对象内部,见后文坑点)。

  • 自动管理内存:拷贝构造 / 移动构造 / 析构都由类完成,不需要 free。

  • 提供长度 size()、拼接 +、比较 ==、子串 substr() 等成员,语义都是"值语义"(拷贝得到独立副本)。

  • 保证 data() 返回的缓冲区以 '\0' 结尾(C++11 起),因此可安全传给 C API。




维度char[] / char*std::string



类型本质数组或指针(无长度信息)类,内含长度与容量

长度获取strlen 遍历 O(n)size() 直接返回 O(1)

拼接strcat,需自行保证容量+ / append,自动扩容

比较strcmp,返回三态== / <,返回 bool 或字典序

内存管理手动 malloc/free自动(RAII)

越界安全无保护,直接 UBat() 会抛异常,[] 仍无保护

可存 '\0'否(会截断)✅ 可以,size() 才准

二进制安全❌✅



最后两行是 std::string 相对 C 风格字符串的质的优势:std::string 可以保存中间含 '\0' 的二进制数据,长度以 size() 为准;而 C 风格字符串一旦中间有 '\0',后面全部丢失。


四、互转:三条路


#include <string>
#include <cstring>
#include <vector>

void convert() {
// C 风格 -> std::string:直接构造(会拷贝)
const char* c = "hello";
std::string s1(c);
std::string s2(c, 3); // 只取前 3 字节 "hel"
std::string s3 = c; // 拷贝赋值

// std::string -> C 风格:c_str() / data() 返回 const char*
const char* p = s1.c_str(); // 只读,勿修改
const char* q = s1.data(); // C++11 起同样以 '\0' 结尾

// 需要可写缓冲区时,不能用 c_str(),要自己拷一份
std::vector<char> buf(s1.begin(), s1.end());
buf.push_back('\0'); // 别忘了结尾
// 或者(C++17):
// std::string tmp = s1; tmp.data()[0] = 'H'; // data() 返回可写指针(C++17 起非 const 重载)
}

要点:c_str() 返回的指针指向 std::string 内部缓冲区,任何导致扩容的操作都会让它失效;也不能通过它修改内容(是 const char*)。想改,就自己拷贝到 std::vector<char> 或新的 std::string。


五、代码实战:一个跨 C/C++ 的字符串处理示例


下面这份代码可直接编译,演示了长度计算、拼接、比较、互转以及常见错误的正确写法。


// 编译:g++ -std=c++17 -O2 -Wall -Wextra demo_char_string.cpp -o demo
#include <cstdio>
#include <cstring>
#include <string>
#include <iostream>

// 把 C 风格字符串按给定分隔符切分,返回 std::string 版本(二分查找更好,此处演示)
void toUpperC(char* s) { // 参数是"可写"的,调用者保证
for (; *s; ++s) {
if (*s >= 'a' && *s <= 'z') *s = static_cast<char>(*s - 'a' + 'A');
}
}

int main() {
// 1) 长度:sizeof 与 strlen 的区别
char arr[] = "abc";
char* ptr = arr;
std::printf("sizeof(arr)=%zu strlen=%zu sizeof(ptr)=%zu\n",
sizeof(arr), std::strlen(arr), sizeof(ptr)); // 4 3 8

// 2) 数组可改,字面量不可改
toUpperC(arr);
std::printf("after toUpperC: %s\n", arr); // ABC

// 3) std::string 拼接收尾无需关心 '\0'
std::string s = "Hello";
s += ", ";
s += "World";
s.push_back('!');
std::cout << s << " len=" << s.size() << '\n'; // Hello, World! len=13

// 4) 互转
const char* cs = s.c_str(); // string -> C,只读
std::string s2(cs); // C -> string,拷贝
std::cout << std::strlen(cs) << ' ' << s2.size() << '\n'; // 13 13

// 5) 二进制安全:std::string 可以存 '\0'
std::string bin("a\0b", 3);
std::cout << "bin.size()=" << bin.size() << '\n'; // 3
std::printf("C strlen=%zu\n", std::strlen(bin.c_str())); // 1(被 '\0' 截断)

// 6) 比较语义不同
std::printf("strcmp=%d\n", std::strcmp("abc", "abd")); // 负数(<0)
std::cout << ("abc" < std::string("abd")) << '\n'; // 1(bool 真)
return 0;
}

常见坑点


坑 1:把 c_str() 的指针长期保存


❌ 错误写法:


std::string s = "hello";
const char* p = s.c_str();
s += " world, this is a very long string that forces reallocation";
printf("%s\n", p); // p 可能已失效 → 输出乱码或崩溃

✅ 正确写法:


std::string s = "hello";
s += " world, ...";
const char* p = s.c_str(); // 内容定了再取指针
printf("%s\n", p);

c_str() / data() 返回的指针在字符串扩容或修改后即失效。若确需长期持有,请拷贝成 std::string 或 std::vector<char>。


坑 2:修改字符串字面量


❌ 错误写法:


char* p = "hello";
p[0] = 'H'; // 未定义行为,Linux 上段错误,部分嵌入式平台"居然能过"

✅ 正确写法:


char p[] = "hello";   // 拷贝到栈上,可改
p[0] = 'H';
// 或者
const char* q = "hello"; // 明确只读,编译器会帮你挡

坑 3:缓冲区溢出 —— strcpy / sprintf 不检查长度


❌ 错误写法:


char buf[8];
strcpy(buf, userInput); // 只要输入超过 7 字节就溢出
sprintf(buf, "%s-%d", name, id);

✅ 正确写法:


char buf[8];
snprintf(buf, sizeof(buf), "%s", userInput); // C99 起,自动截断并保证 '\0'
// 或使用 strncpy 并手动补 '\0'(注意 strncpy 不保证结尾)
strncpy(buf, userInput, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = '\0';

缓冲区溢出(buffer overflow)是 C 代码最经典的安全漏洞,栈上溢出可被利用来劫持返回地址。新代码应优先使用 std::string 或 std::span(C++20)替代裸数组。


坑 4:返回局部数组的指针


❌ 错误写法:


char* getName(void) {
char buf[32] = "tom";
return buf; // buf 在函数返回后即销毁 → 悬垂指针
}

✅ 正确写法:


// 方案 A:调用者提供缓冲区
void getName(char* out, size_t n) { snprintf(out, n, "%s", "tom"); }

// 方案 B(C++):直接返回 std::string,由返回值优化/移动语义接管
std::string getName() { return "tom"; }

坑 5:strncpy 不保证以 '\0' 结尾


char buf[4];
strncpy(buf, "hello", sizeof(buf)); // buf = {'h','e','l','l'},无 '\0'
printf("%s\n", buf); // ❌ 越界读取,直到偶然遇到 '\0'

strncpy(dst, src, n) 在 strlen(src) >= n 时不会补 '\0'。要么手动补,要么用 snprintf。


坑 6:SSO 导致 c_str() 地址"看起来"稳定


主流标准库对小字符串有短字符串优化(SSO, Small String Optimization):长度不超过 15(libstdc++)或 15(MSVC)的字符串直接存在对象内部的栈缓冲区里,不分配堆内存。这会造成一种假象——"我 c_str() 之后改字符串,指针内容没变"。一旦字符串变长触发堆分配,同样的代码立刻崩溃。不要依赖 SSO 行为写代码,它不在标准里,且各实现阈值不同。


坑 7:std::string 与 '\0' 的长度陷阱


std::string s("a\0b", 3);      // size()==3
const char* p = s.c_str();
printf("%s\n", p); // 输出 a(被第一个 '\0' 截断)
printf("%zu\n", strlen(p)); // 1,不是 3

传给 C API 时会"丢数据"。处理二进制数据时,务必同时传长度,不要只传指针。


总结




场景推荐做法原因



需要可修改的字符串常量char a[] = "...";栈上拷贝,可写

只读字符串字面量const char* p = "...";明确只读,避免 UB

一般业务字符串std::string自动内存管理、O(1) 长度、可存 '\0'

传给 C APIs.c_str()保证 '\0' 结尾(勿长期持有)

接收 C API 写回std::vector<char>可写、可自行控制长度

字节/哈希运算unsigned char避免负下标与符号扩展

格式化输出snprintf有长度上限,不溢出



一句话收尾:C 的字符串是"约定",C++ 的 std::string 是"类型"。约定需要你手工维护(长度、结尾、容量),类型则由编译器与标准库替你维护。能用类型的地方就不要用约定,这是从 C 走向 C++ 最重要的一步。




深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值