C++编程语言:标准库:第36章——字符串类(Bjarne Stroustrup)

C++程序设计--第 1 章 · 初识C++ 本章首先讲解了 C++ 语言的特点,然后带领大家编写了第一个 C++ 程序,最后讲解了 C++语言在 C 语言上的一些扩充,如命名空间、类型增强、默认参数、引用等新特性。通过本章学习,希望大家能够对 C++ 语言有基本认识,为后续章节的学习奠定好基础!当然啦~C++这个系列知识点会非常基础,特别适合小白跟学欧~~~我也会跟一些关于C++的好题分享 ~~一起学习吧 阅读详情

第 36 章  字符串类(Strings)

目录

36.1  引言

36.2  字符分类

36.2.1  分类识别函数(Classification Functions)

36.2.2  字符特征类(Chracter Traits)

36.3  字符串类(basic_string)

36.3.1  string对比于C风格字符串

36.3.2  构造函数

36.3.3  基本运算

36.3.4  字条串I/O操作

36.3.5  数值转换(Numeric Conversions)

36.3.6  类STL运算(STL-Like Operations)

36.3.7  find函数族(The find Family)

36.3.8  子字符串(Substrings)

36.4  建议(Advice)


36.1  引言

    标准库在 <cctype> (§36.2) 中提供了字符分类操作,在 <string> (§36.3) 中提供了字符串及其相关操作,在 <regex> (第 37 章) 中提供了正则表达式匹配,并在 <cstring> (§43.4) 中提供了对 C 风格字符串的支持。第 39 章讨论了如何处理不同的字符集、编码和约定(语言环境)。

    §19.3 中给出了简化的字符串实现。

36.2  字符分类

标准库提供了分类函数来帮助用户操作字符串(和其他字符序列),以及指定字符类型属性的特征,以帮助实现字符串操作。

36.2.1  分类识别函数(Classification Functions)

字符分类识别函数

isspace(c)

判断c是否为空白(空格‘’,水平制表符(tab)(跳格)‘\t’,换行符‘\n’, 垂直制表符(跳格)‘\v’,换页(form feed) ‘\f’,回车(carriage return)‘\f’)。

isalpha(c)

判断c是否为字母( 'a'..'z', 'A'..'Z' ),注意,不要用下划线‘_’。

isdigit(c)

判断c是否为一个十进制数( '0'…'9')

isxdigit(c)

判断c是否为一个十六进制数(十进制数或 'a'..'f' 或  'A'..'F')

isupper(c)

判断c是否为一个大写字母

islower(c)

判断c是否为一个小写字母

isalnum(c)

isalpha(c)或isdigit(c)

iscntrl(c)

判断c是否为一个控制字符ASCII 0..31 和 127

ispunct(c)

判断c是否为一个字母,数字,空白字符,或不可见控制字符

isprint(c)

判断c是否为可打印(ASCII ‘’..‘~’’)

isgraph(c)

判断是否为isalpha(c)或isdigit(c)或ispunct(c),注意,没有空白。

此外,标准库提供了两个大小写转换函数。

大小写转换函数

toupper(c)

c转为大写

tolower(c)

c转为小写

宽字符等效的函数在 <cwctype> 中提供。

字符分类函数对“C”语言环境(§39.5.1,§39.5.2)敏感。其他语言环境的等效函数在 <locale>(§39.5.1)中提供。

这些字符分类函数之所以有用,原因之一是字符分类可能比看起来更棘手。例如,新手可能会写出:

if ('a'<ch && ch<'z') // a character

这比以下更冗长(并且很可能更慢):

if (islower(ch)) // a lowercase character

此外,无法保证字符在代码空间中是连续的。另有,使用标准字符分类更容易转换为其他语言环境:

if (islower,danish) // a lowercase character in Danish(丹麦语)

// (假设 ‘‘danish’’ 一个丹麦语本地化的名称)

请注意,丹麦语比英语多三个小写字符,因此使用“a”和“z”的初始显式测试是完全错误的。

36.2.2  字符特征类(Chracter Traits)

       如§23.2所示,字符串模板原则上可以使用任何具有适当复制操作的类型作为其字符类型。但是,对于没有用户定义复制操作的类型,可以提高效率并简化实现。因此,标准字符串要求用作其字符类型的类型必须是POD(§8.2.6)。这也有助于使字符串的I/O操作简单高效。

    字符类型的属性由其 char_traits 定义。char_traits 是模板的特化:

template<typename C> struct char_traits { };

所有 char_traits 均定义在 std 中,标准 char_traits 则在 <string> 中呈现。通用 char_traits 本身没有属性;只有针对特定字符类型的 char_traits 特化才具有属性。以 char_traits<char> 为例:

template<>

struct char_traits<char> { // char_traits operations should not throw exceptions

using char_type = char;

using int_type = int; // type of integer value of character

using off_type = streamoff; // offset in stream

using pos_type = streampos; // position in stream

using state_type = mbstate_t; // multibyte stream state (§39.4.6)

// ...

};

该标准提供了 char_traits 的四种专业化(§iso.21.2.3):

template<> struct char_traits<char>;

template<> struct char_traits<char16_t>;

template<> struct char_traits<char32_t>;

template<> struct char_traits<wchar_t>;

标准 char_traits 的成员都是static函数:

char_traits<C> static  成员 (§iso.21.2)

c=to_char_type(i)

int_type 到 char_type 的转换

i=to_int_type(c)

char_type 到 int_type 的转换

eq_int_type(c,c2)

to_int_type(c)==to_int_type(c2)

eq(c,c2)

c 是否被视为等于 c2?

lt(c,c2)

c 是否被视为小于 c2?

i=compare(p,p2,n)

[p:p+n) 和 [p2:p2+n) 的词典比较

assign(c,c2)

对于 char_type,c=c2

p2=assign(p,n,c)

将 n 个 c 副本分配给 [p:p+n); p2=p

p3=move(p,p2,n)

将 [p:p+n) 复制到 [p2:p2+n);[p:p+n) 和 [p2:p2+n) 可能重叠;p3=p

p3=copy(p,p2,n)

将 [p:p+n) 复制到 [p2:p2+n);[p:p+n) 和 [p2:p2+n) 不得重叠;p3=p

n=length(p)

n 是 [p:q) 中的字符数,其中 ∗q 是第一个元素,因此 eq(q,charT{})

p2=find(p,n,c)

p 指向 [p:p+n) 中 c 的第一次出现,或者 nullptr

i=eof()

i 是表示文件结束的 int_type 值

i=not_eof(i)

若 !eq_int_type(i,eof()) 测结果为i; 否则 i 可以是任何不等于 eof() 的值

与 eq() 的比较通常不仅仅是简单的 == 。例如,不区分大小写的 char_traits 会定义其 eq(),这样 eq('b','B') 就会返回 true。

由于 copy() 不能防止重叠范围,因此它可能比 move() 更快。

compare() 函数使用 lt() 和 eq() 来比较字符。它返回一个 int 值,其中 0 表示完全匹配,负数表示第一个参数按字典顺序位于第二个参数之前,正数表示第一个参数位于第二个参数之后。

    I/O 相关函数用于低级 I/O(§38.6)的实现。

36.3  字符串类(basic_string)

    在 <string> 中,标准库提供了一个通用的字符串模板basic_string:

template<typename C,

typename Tr = char_traits<C>,

typename A = allocator<C>>

class basic_string {

public:

using traits_type = Tr;

using value_type = typename Tr::char_type;

using allocator_type = A;

using size_type = typename allocator_traits<A>::size_type;

using difference_type = typename allocator_traits<A>::difference_type;

using reference = value_type&;

using const_reference = const value_type&;

using pointer = typename allocator_traits<A>::pointer;

using const_pointer = typename allocator_traits<A>::const_pointer;

using iterator = /* implementation-defined */;

using const_iterator = /* implementation-defined */;

using reverse_iterator = std::reverse_iterator<iterator>;

using const_reverse_iterator = std::reverse_iterator<const_iterator>;

static const size_type npos = −1; // integer representing end-of-string

// ...

};

元素(字符)连续存储,以便底层输入操作可以安全地使用 basic_string 的字符序列作为源或目标。

    basic_string 提供了强有力的保证(§13.2):如果 basic_string 操作抛出异常,则字符串保持不变。

    针对一些标准字符类型提供了特化功能:

using string = basic_string<char>;

using u16string = basic_string<char16_t>;

using u32string = basic_string<char32_t>;

using wstring = basic_string<wchar_t>;

所有这些字符串都提供了大量的操作。

    与容器(第 31 章)类似,basic_string 不应用作基类,而是提供移动语义,以便可以高效地按值返回。

36.3.1  string对比于C风格字符串

    我假设读者已经通过本书中的众多示例对string有所了解,因此我首先从几个示例开始来对比string的使用和 C 风格字符串(§43.4),C 风格字符串在主要熟悉 C 和 C 风格 C++ 的程序员中很受欢迎。

    考虑通过连接用户标识符和域名来组成电子邮件地址:

string address(const string& identifier, const string& domain)

{

return identifier + '@' + domain;

}

void test()

{

string t = address("bs","somewhere");

cout << t << '\n';

}

这很简单。现在考虑一个合理的 C 风格版本。C 风格字符串是一个指向以0结尾的字符数组的指针。用户控制分配并负责释放:

char∗ address(const char∗ identifier, const char∗ domain)

{

int iden_len = strlen(identifier);

int dom_len = strlen(domain);

char∗ addr = (char∗)malloc(iden_len+dom_len+2); // remember space for 0 and '@'

strcpy(identifier,addr);

addr[iden_len] = '@';

strcpy(domain,addr+iden_len+1);

return addr;

}

void test2()

{

char∗ t = address("bs","somewhere");

printf("%s\n",t);

free(t);

}

我写对了吗?希望如此。至少它给出了我预期的输出。像大多数经验丰富的 C 程序员一样,我第一次就写对了 C 版本(我希望如此),但还有很多细节需要完善。然而,经验(例如错误日志)表明情况并非总是如此。通常,这种简单的编程任务会交给相对新手,他们还不了解所有必要的技巧。C 风格的 address() 函数的实现包含许多棘手的指针操作,并且它的使用需要调用者记住释放返回的内存。你更愿意维护哪段代码?

有时,人们声称 C 风格的字符串比 string的字符串更高效。然而,在大多数情况下,string的分配和释放操作比 C 风格的等效字符串更少(这得益于小字符串优化和移动语义;§19.3.3,§19.3.1)。此外,strlen() 是一个 log(N) 运算,而 string::size() 只是一个简单的读取操作。在示例中,这意味着 C 风格的代码会遍历每个输入字符串两次,而字符串版本对每个输入只进行一次遍历。这种级别的效率考量往往是错误的,但string版本却具有根本性的优势(edge)。

C 风格字符串和string的根本区别在于,string是一种具有约定俗成的语义的固有类型,而 C 风格字符串则是由一些实用函数支持的一组约定。考虑赋值和比较:

void test3()

{

string s1 = "Ring";

if (s1!="Ring") insanity();

if (s1<"Opera")cout << "check";

string s2 = address(s1,"Valkyrie");

char s3[] = "Ring";

if (strcmp(s3,"Ring")!=0) insanity();

if (strcmp(s3,"Opera")<0) cout << "check";

char∗ s4 = address(s3,"Valkyrie");

free(s4);

}

最后,考虑排序:

void test4()

{

vector<string> vs = {"Grieg", "Williams", "Bach", "Handel" };

sort(vs.begin(),vs.end()); // assuming that I haven’t defined sort(vs)

const char∗ as[] = {"Grieg", "Williams", "Bach", "Handel" };

qsort(as,sizeof(∗as),sizeof(as)/sizeof(∗as),(int(∗)(const void∗,const void∗))strcmp);

}

C 风格的字符串排序函数 qsort() 在 §43.7 中介绍。同样,sort() 的速度与 qsort() 一样快(通常甚至快得多),因此没有必要为了性能而选择更低级、更冗长且更难维护的编程风格。

36.3.2  构造函数

    basic_string 提供了多种令人眼花缭乱的构造函数:

basic_string<C,Tr,A>构造函数(iso.21.4.2)

x可以为一个basic_string,一个C风格字符串,或者一个initializer_list<char_type>

basic_string s {a};

s 是带有分配器 a 的空字符串;explicit

basic_string s {};

默认构造函数:basic_string s {A{}};

basic_string s {x,a};

s 从 x 获取字符;使用分配器 a

basic_string s {x};

移动和复制构造函数: basic_string s {x,A{}};

basic_string s {s2,pos,n,a};

s 获取字符 s2[pos:pos+n);使用分配器 a

basic_string s {s2,pos,n};

basic_string s {s2,pos,n,A{};}

basic_string s {s2,pos};

basic_string s {s2,pos,string::npos,A{}};

basic_string s {p,n,a};

从 [p:p+n] 初始化 s;p 是 C 风格字符串;使用分配器 a

basic_string s {p,n};

basic_string s {p,n,A{}};

basic_string s {n,c,a};

s 保存字符 c 的 n 个副本;使用分配器 a

basic_string s {n,c};

basic_string s {n,c,A{};}

basic_string s {b,e,a};

s 从 [b:e] 获取字符;使用分配器 a

basic_string s {b,e};

basic_string s {b,e,A{}};

s.˜basic_string()

析构函数:释放所有资源

s=x

复制:s从x获得字条

s2=move(s)

移动:s2 从 s 中获取字符;noexcept

最常见的(构造函数)变体也是最简单的:

string s0; // 空string

string s1 {"As simple as that!"}; // 从C风格字条串构造string

string s2 {s1}; // 复制构造函数

析构函数几乎总是被隐式调用。

    没有只接受若干数量元素的字符串构造函数:

string s3 {7}; // error : no string(int)

string s4 {'a'}; // error : no string(char)

string s5 {7,'a'}; // OK: 7 'a's

string s6 {0}; // 当心: 传递 nullptr

s6 的声明显示了习惯于 C 风格字符串的程序员有时会犯的一个错误:

const char∗ p = 0; // 置p为 ‘‘no string’’

遗憾的是,编译器无法捕获 s6 的定义,或者 const char∗ 持有 nullptr 的更糟糕的情况:

string s6 {0}; // 当心: 传递 nullptr

string s7 {p}; // 可以或不可以,取决于 p 的值

string s8 {"OK"}; // OK: 传递C风格字符串的指针

不要尝试用 nullptr 初始化字符串。轻则会导致严重的运行时错误,重则会导致难以捉摸的未定义行为。

    如果你尝试构造一个字符串,其字符数超出了你的实现所能处理的范围,构造函数就会抛出 std::length_error。例如:

string s9 {string::npos,'x'}; // throw length_error

值 string::npos 表示超出字符串长度的位置,通常用于表示“字符串的末尾”。例如:

string ss {"Fleetwood Mac"};

string ss2 {ss,0,9}; // "Fleetwood"

string ss3 {ss,10,string::npos}; // "Mac"

请注意,子字符串符号是 (位置,长度) 而不是 [开始,结束)。

    没有string类型的字面量(literals)。可以使用用户自定义字面量(§19.2.6),例如“The Beatles”和“Elgar”。请注意 s 后缀。

36.3.3  基本运算

    basic_string 提供比较、大小和容量控制以及访问操作。

basic_string<C,Tr,A>比较(iso.21.4.8)

s 或 s2 不能同时是 C 风格字符串

s==s2

s 是否等于 s2?使用 traits_type 比较字符值

s!=s2

!(s==s2)

s<s2

s 是否按字典顺序位于 s2 之前?

s<=s2

按字典顺序排列,s 是否在 s2 之前或等于 s2?

s>s2

s 是否按字典顺序位于 s2 之后?

s>=s2

按字典顺序排列,s 是否在 s2 之后或等于 s2?

有关更多比较操作,请参阅§36.3.8。

basic_string 的大小和容量机制与vector(§31.3.3)相同:

basic_string<C,Tr,A>大小和容量(iso.21.4.4)

n=s.size()

n 是 s 中字符的数量。

n=s.length()

n=s.size()

n=s.max_size()

n是s.size()的最大可能值。

s.resize(n,c)

使 s.size()==n ;获得 c 的值并加入s

s.resize(n)

s.resiz e(n,C{})

s.reserve(n)

确保 s 可以容纳 n 个字符而无需进一步分配

s.reserve()

无效:s.reserve(0)

n=s.capacity()

s 可以容纳 n 个字符,无需进一步分配

s.shrink_to_fit()

使得 s.capacity==s.size()

s.clear()

清空s

s.empty()

s是否为空

a=s.get_allocator()

a 是s的分配器

resize() 或 reserve() 会导致 size() 超过 max_size(),从而引发 std::length_error。

resize() 或 reserve() 会导致 size() 超过 max_size(),从而引发 std::length_error。

一个例子:

void fill(istream& in, string& s, int max)

// 使用 s 作为底层输入的目标(简化)

{

s.reserve(max); // make sure there is enough allocated space

in.read(&s[0],max);

const int n = in.gcount(); // number of characters read

s.resize(n);

s.shrink_to_fit(); //discard excess capacity

}

这里,我“忘记”利用已读字符数了。真是太草率了。

basic_string<C,Tr,A>访问(iso.21.4.5)

s[i]

下标:s[i] 是 s 中第 i 个元素的引用;没有范围检查

s.at(i)

下标:s.at(i) 是 s 中第 i 个元素的引用;如果 s.size()<=i,则抛出 range_error

s.front()

s[0]

s.back()

s[s.size()−1]

s.push_back(c)

追加字符c

s.pop_back()

从s中移除最后一个字符:s.erase(s.size()−1)

s+=x

将 x 追加到 s 的末尾;x 可以是字符、字符串、C 风格字符串或初始化列表 <char_type>

s=s1+s2

连接:s=s1;s+=s2 的优化版本;

n2=s.copy(s2,n,pos)

s 从 s2[pos:n2) 中获取字符

其中 n2 为 min(n,s.size()−pos);

如果 s.size()<pos,则抛出 out_of_range 错误

n2=s.copy(s2,n)

s 从 s2 中获取所有字符;n=s.copy(s2,n,0)

p=s.c_str()

p 是 s 中字符的 C 风格字符串版本(以零结尾);

const C∗

p=s.data()

p=s.c_str()

s.swap(s2)

交换 s 和 s2 的值;noexcept

swap(s,s2)

s.swap(s2)

使用 at() 进行超出范围的访问会抛出 std::out_of_range。如果 +=()、push_back() 或 + 导致 size() 超过 max_size(),则会抛出 std::length_error。

    字符串无法隐式转换为 char∗ 。这种做法在很多地方都尝试过,但发现容易出错。因此,标准库提供了显式转换函数 c_str() 来将 string 转换为 const char∗ 。

    字符串可以包含零值字符(例如 '\0')。使用 strcmp() 等函数,如果该函数对包含零字符的字符串执行 s.c_str() 或 s.data() 的结果假定遵循 C 风格字符串约定,则可能会引发意外结果。

36.3.4  字条串I/O操作

    可以使用 << (§38.4.2) 输出 basic_string,并使用 >> (§38.4.1) 读入:

basic_string<C,Tr,A>I/O操作(iso.21.4.8.9)

in>>s

从in读一个空白分隔的字到s中

out<<s

输出s到out

getline(in,s,d)

将 in 中的字符读入 s 中,直到遇到字符 d;d 从 in 中移除,但不会附加到 s

getline(in,s)

getline(in,s,'\n') 其中 '\n' 被加宽以匹配字符串的字符类型

导致 size() 超过 max_size() 的输入操作将抛出 std::length_error。

getline() 会从输入流中删除其终止符(默认为 '\n'),但不会将其输入到字符串中。这简化了行处理。例如:

vector<string> lines;

for (string s; getline(cin,s);)

lines.push_back(s);

字符串 I/O 操作都会返回其输入流的引用,以便可以链式执行操作。例如:

string first_name;

string second_name;

cin >> first_name >> second_name;

输入操作的字符串目标在读取前设置为空,并扩展以容纳读取的字符。读取操作也可以通过到达文件末尾(§38.3)来终止。

36.3.5  数值转换(Numeric Conversions)

    在 <string> 中,标准库提供了一组函数,用于从字符串或 wstring(注意:不是 basic_string<C,Tr,A>)中的字符表示中提取数值。所需的数值类型已编码在函数名称中:

数值转换(iso.21.5)

s 可以是string或 wstring

x=stoi(s,p,b)

字符串到 int;x 是整数;如果 p!=nullptr,则从 s[0] 开始读取,∗p 设置为用于 x 的字符数;b 是数字的基数(介于 2 和 36 之间,包括 2 和 36)

x=stoi(s,p)

x=stoi(s,p,10);十进制数

x=stoi(s)

x=stoi(s,nullptr,10);十进制数;不报告字符数

x=stol(s,p,b)

字符串转为long

x=stoul(s,p,b)

字符串转为 unsigned long

x=stoll(s,p,b)

字符串转为 long long

x=stoull(s,p,b)

字符串转为 unsigned long long

x=stof(s,p)

字符串转为float

x=stod(s,p)

字符串转为double

x=stold(s,p)

字符串转为long double

s=to_string(x)

s 是 x 的字符串表示形式;x 必须是整数或浮点数

ws=to_wstring(x)

s 是 x 的 wstring 表示形式;x 必须是整数或浮点数

这些 sto∗ (* indicates String to xxx(some other types)) 函数都有三个变体,例如 stoi。例如:

string s = "123.45";

auto x1 = stoi(s); // x1 = 123

auto x2 = stod(s); // x2 = 123.45

sto∗ 函数的第二个参数是一个指针,用于表示在字符串中搜索数值的进度(译注:搜索到哪个位置)。例如:

string ss = "123.4567801234";

size_t dist = 0; // 存放已读字符数

auto x = stoi(ss,&dist); // x = 123 (整数)

++dist; //忽略小数这个点

auto y = stoll(&ss[dist]); // x = 4567801234 (a long long)

这不是我最喜欢的从字符串解析多个数的接口。我更喜欢使用 string_stream (§38.2.2)。

开头的空格会被跳过。例如:

string s = " 123.45";

auto x1 = stoi(s); // x1 = 123

基数参数的范围为 [2:36],其中 0123456789abcdefghijklmnopqrstuvwxyz 用作“数字”,其值由其在此序列中的位置决定。任何超出基数(base value)的数值都将被视为错误或扩展。例如:

string s4 = "149F";

auto x5 = stoi(s4); // x5 = 149

auto x6 = stoi(s4,nullptr,10); // x6 = 149

auto x7 = stoi(s4,nullptr,8); // x7 = 014

auto x8 = stoi(s4,nullptr,16); // x8 = 0x149F

string s5 = "1100101010100101"; // binar y

auto x9 = stoi(s5,nullptr,2); // x9 = 0xcaa5

如果转换函数在其字符串参数中找不到可以转换为数字的字符,则会抛出 invalid_argument 异常。如果转换函数发现目标类型无法表示的数字,则会抛出 out_of_range 异常;此外,转换为浮点类型时,errno 会被设置为 ERANGE (§40.3)。例如:

stoi("Hello, World!"); // throws std::invalid_argument

stoi("12345678901234567890"); // throws std::out_of_range; errno=ERANGE

stof("123456789e1000"); // throws std::out_of_range; errno=ERANGE

sto∗ 函数在其名称中编码了目标类型。这使得它们不适合用于目标可以作为模板参数的通用代码。在这种情况下,请考虑使用 to<X> (§25.2.5.1)。

36.3.6  类STL运算(STL-Like Operations)

    basic_string 提供了常用的迭代器集:

basic_string<C,Tr,A> 字符串迭代器(§iso.21.4.3)

所有的操作都是noexcept的

p=s.begin()

p 是指向 s 第一个字符的迭代器

p=s.end()

p 是指向 s 末尾之后的迭代器

p=s.cbegin()

p 是指向第一个字符的 const_iterator

p=s.cend()

p 是指向 s 末尾之后的 const_iterator

p=s.rbegin()

p 是 s 的逆序列的开头

p=s.rend()

p 是 s 的逆序列的结尾

p=s.crbegin()

p 是指向 s 反向序列开头的 const_iterator

p=s.crend()

p 是指向 s 反向序列末尾的 const_iterator

由于string具有所需的成员类型以及获取迭代器的函数,因此可以与标准算法(第 32 章)一起使用。例如:

void f(string& s)

{

auto p = find_if(s.begin(),s.end(),islower);

// ...

}

最常见的string操作都直接由 string 提供。希望这些版本能够针对string进行优化,使其超越一般算法的易操作性。

    标准算法(第 32 章)对字符串的适用性不如人们想象的那么强。一般算法倾向于假设容器的元素在孤立的情况下是有意义的。但对于字符串来说,情况通常并非如此。

    basic_string 提供复杂的assignment():

basic_string<C,Tr,A> 赋值(§iso.21.4.6.3)

所有操作都返回应用它们的字符串

s.assign(x)

s=x; x 可以是字符串、C 风格的字符串或 initializer_list<char_type>

s.assign(move(s2))

移动:s2 是一个字符串;noexcept

s.assign(s2,pos,n)

s 获取字符 s2[pos:pos+n)

s.assign(p,n)

s 获取字符 [p:p+n);p 是 C 风格字符串

s.assign(n,c)

s 获取字符 c 的 n 个副本

s.assign(b,e)

s 获取来自 [b:e) 的字符

我们可以在 basic_string 中insert(),append()和erase() :

basic_string<C,Tr,A> 插入和删除(§iso.21.4.6.2,§iso.21.4.6.4,§iso.21.4.6.5)

所有操作都返回应用它们的字符串

s.append(x)

将 x 附加到 s 的末尾;x 可以是字符、string、C 风格字符串或initializer_list<char_type>

s.append(b,e)

在 s 末尾附加 [b:e)

s.append(s2,pos,n)

将 s2[pos:pos+n) 附加到 s 的末尾

s.append(p,n)

将字符 [p:p+n) 附加到 s 的末尾;p 是 C 风格字符串

s.append(n,c)

将字符 c 的 n 个副本附加到 s 的末尾

s.insert(pos,x)

在 s[pos] 之前插入 x;x 可以是字符、字符串、C 风格字符串或 initializer_list<char_type>

s.insert(p,c)

在迭代器 p 之前插入 c

s.insert(p,n,c)

在迭代器 p 之前插入 n 个 c 的副本

insert(p,b,e)

在迭代器 p 之前插入 [b:e)

s.erase(pos)

从 s 中删除尾随字符,以 s[pos] 开头;s.size() 变为 pos

s.erase(pos,n)

从 s 中删除 n 个字符,从 s[pos] 开始;s.size() 变为 max(pos,s.size()−n)

例如:

void add_middle(string& s, const string& middle) // add middle name

{

auto p = s.find(' ');

s.insert(p,' '+middle);

}

void test()

{

string dmr = "Dennis Ritchie";

add_middle(dmr,"MacAlistair");

cout << dmr << '\n';

}

对于vector,append()(在末尾添加字符)通常比在其他地方insert()更有效。

下面我使用 s[b:e) 来表示 s 中元素 [b:e) 的序列:

basic_string<C,Tr,A> 替换(§iso.21.4.6.6)

所有操作都返回应用它们的字符串

s.replace(pos,n,s2,pos2,n2)

用 s2[pos2:pos2+n2) 替换s[pos:pos+n); s2是一个string或C风格字符串

s.replace(pos,n,p,n2)

用 [p:p+n2)替换s[pos:pos+n);

s=s.replace(pos,n,s2)

用 s2 替换s[pos:pos+n);

s2是一个string或C风格字符串

s.replace(pos,n,n2,c)

将 s[pos:pos+n) 替换为字符 c 的 n2 个副本

s.replace(b,e,x)

将 [b:e) 替换为 x;x 可以是字符串、C 风格字符串或 initializer_list<char_type>

s.replace(b,e,p,n)

将 [b:e) 替换为 [p:p+n)

s.replace(b,e,n,c)

将 [b:e) 替换为 n 个字符 c

s.replace(b,e,b2,e2)

将 [b:e) 替换为 [b2:e2)

replace() 函数会将一个子字符串替换为另一个子字符串,并相应地调整字符串的大小。例如:

void f()

{

string s = "but I have heard it works even if you don't believe in it";

s.replace(0,4,""); //erase initial "but "

s.replace(s.find("even"),4,"only");

s.replace(s.find(" don't"),6,""); // erase by replacing with ""

assert(s=="I have heard it works only if you believe in it");

}

依赖于“神奇”常量(例如要替换的字符数)的代码容易出错。

    replace() 返回调用它的对象的引用。这可以用于链式操作:

void f2()

{

string s = "but I have heard it works even if you don't believe in it";

s.replace(0,4,"").replace(s.find("even"),4,"only").replace(s.find(" don't"),6,"");

assert(s=="I have heard it works only if you believe in it");

}

36.3.7  find函数族(The find Family)

    用于查找子字符串的函数种类繁多,令人眼花缭乱。通常,find() 从 s.begin() 开始向前搜索,而 rfind() 则从 s.end() 开始向后搜索。find 函数使用 string::npos(“非位置”)表示“未找到”。

basic_string<C,Tr,A> 查找元素(§iso.21.4.7.2)

x 可以是字符,string或 C 风格字符串。所有操作均为 noexcept

pos=s.find(x)

在 s 中查找 x;pos 是找到的第一个字符的索引或 string::npos

pos=s.find(x,pos2)

pos=find(basic_string(s,pos2)

pos=s.find(p,pos2,n)

pos=s.find(basic_string{p,n},pos2)

pos=s.rfind(x,pos2)

在 s[0:pos2] 中查找 x;pos 是 x 中距离 s 末尾最近的第一个字符的位置,或 string::npos

pos=s.rfind(x)

pos=s.rfind(p,string::npos)

pos=s.rfind(p,pos2,n)

pos=s.rfind(basic_string{p,n},pos2)

例如:

void f()

{

string s {"accdcde"};

auto i1 = s.find("cd"); // i1==2 s[2]=='c' && s[3]=='d'

auto i2 = s.rfind("cd"); // i2==4 s[4]=='c' && s[5]=='d'

}

find∗of() 函数与 find() 和 rfind() 函数的不同之处在于,它查找的是单个字符,而不是整个字符序列:

basic_string<C,Tr,A> 查找来自于集合的元素(§iso.21.4.7.4)

x 可以是字符,string或 C 风格字符串;p是C风格字符串。所有操作均为 noexcept

pos2=s.find_first_of(x,pos)

在 s[pos:s.size()) 中查找 x 中的一个字符;

pos2 是 x 中第一个字符在 s[pos:s.size()) 或 string::npos 中的位置

pos=s.find_first_of(x)

pos=s.find_first_of(s2,0)

pos2=s.find_first_of(p,pos,n)

pos2=s.find_first_of(pos,basic_string{p,n})

pos2=s.find_last_of(x,pos)

在 s[0:pos) 中查找 x 中的一个字符;

pos2 是 x 中距离 s 或 string::npos 末尾最近的字符的位置

pos=s.find_last_of(x)

pos=s.find_first_of(s2,0)

pos2=s.find_last_of(p,pos,n)

pos2=s.find_last_of(pos2,basic_string{p,n})

pos2=s.find_first_not_of(x,pos)

在 s[pos:s.size()) 中查找不属于 x 的字符;

pos2 是 x 中第一个不属于 s[pos:s.size()) 或 string::npos 的字符的位置

pos=s.find_first_not_of(x)

pos=s.find_first_not_of(s2,0)

pos2=s.find_first_not_of(p,pos,n)

pos2=s.find_first_not_of(pos,basic_string{p,n})

pos2=s.find_last_not_of(x,pos)

在 s[0:pos) 中查找不属于 x 的字符;

pos 是 x 中距离 s 末尾最近的字符的位置,或 string::npos

pos=s.find_last_not_of(x)

pos=s.find_first_not_of(s2,0)

pos2=s.find_last_not_of(p,pos,n)

pos=s.find_last_not_of(pos,basic_string{p,n})

例如:

string s {"accdcde"};

auto i1 = s.find("cd"); // i1==2 s[2=='c' && s[3]=='d'

auto i2 = s.rfind("cd"); // i2==4 s[4]=='c' && s[5]=='d'

auto i3 = s.find_first_of("cd"); // i3==1 s[1]=='c'

auto i4 = s.find_last_of("cd"); // i4==5 s[5]=='d'

auto i5 = s.find_first_not_of("cd"); // i5==0 s[0]!='c' && s[0]!='d'

auto i6 = s.find_last_not_of("cd"); // i6==6 s[6]!='c' && s[6]!='d'

36.3.8  子字符串(Substrings)

    basic_string 提供了子字符串的底层概念:

basic_string<C,Tr,A> 子字符串(§iso.21.4.7.8)

s2=s.substr(pos,n)

s2=basic_string(&s[pos],m) 其中m=min(s.size()−n,n)

s2=s.substr(pos)

s2=s.substr(pos,string::npos)

s2=s.substr()

s2=s.substr(0,string::npos)

注意,substr() 创建了一个新的字符串对象:

void user()

{

string s = "Mary had a little lamb";

string s2 = s.substr(0,4); // s2 == "Mary"

s2 = "Rose"; // 不影响 s

}

我们可以比较子字符串:

basic_string<C,Tr,A> 比较(§iso.21.4.7.9)

n=s.compare(s2)

对 s 和 s2 进行字典顺序比较;使用 char_traits<C>::compare() 进行比较;如果 s==s2,则 n=0;如果 s<s2,则 n<0;如果 s2>s,则 n>0;noexcept;

n2=s.compare(pos,n,s2)

n2=basic_string{s,pos,n}.compare(s2)

n2=s.compare(pos,n,s2,pos2,n2)

n2=basic_string{s,pos,n}.compare(basic_string{s2,pos2,n2})

n=s.compare(p)

n=compare(basic_string{p});

p是一个C风格字符串

n2=s.compare(pos,n,p)

n2=basic_string{s,pos,n}.compare(basic_string{p});

p是一个C风格字符串

n2=s.compare(pos,n,p,n2)

n2=basic_string{s,pos,n}.compare(basic_string{p,n2});

p是一个C风格字符串

例如:

void f()

{

string s = "Mary had a little lamb";

string s2 = s.substr(0,4); // s2 == "Mary"

auto i1 = s.compare(s2); // i1 is positive

auto i2 = s.compare(0,4,s2); // i2==0

}

明确使用常量来表示位置和长度是脆弱且容易出错的。

36.4  建议(Advice)

[1] 使用字符分类判断函数,而不是手动验证字符范围;§36.2.1。

[2] 如果实现类似字符串的抽象,请使用 character_traits 来实现字符操作;§36.2.2。

[3] basic_string 可用于创建任何类型的字符串;§36.3。

[4] 将string用作变量和成员,而不是基类;§36.3。

[5] 优先使用string操作,而不是 C 风格的字符串函数;§36.3.1。

[6] 按值返回string(依赖于移动语义);§36.3.2。

[7] 使用 string::npos 表示“字符串的其余部分”;§36.3.2。

[8] 不要将 nullptr 传递给期望 C 风格字符串的string函数;§36.3.2。

[9] string可以根据需要增长和收缩;§36.3.3。

[10] 当需要进行范围检查时,请使用 at() 而不是迭代器或 [];§36.3.3,§36.3.6。

[11] 当需要优化速度时,请使用迭代器和 [] 而不是 at();§36.3.3,§36.3.6。

[12] 如果使用string,请在某处捕获 length_error 和 out_of_range 错误;§36.3.3。

[13] 仅在必要时使用 c_str() 生成字符串的 C 风格字符串表示;§36.3.3。

[14] string输入对类型敏感,不会溢出;§36.3.4。

[15] 优先使用 string_stream 或通用值提取函数(例如 to<X>),而不是直接使用 str∗ 数值转换函数; §36.3.5。

[16] 使用 find() 操作定位字符串中的值(而不是编写显式循环);§36.3.7。

[17] 直接或间接地使用 substr() 读取子字符串,使用 replace() 写入子字符串;§36.3.8。

内容来源:

<<The C++ Programming Language >> 第4版,作者 Bjarne Stroustrup

【运筹学】什么是基变量?对于线性规划问题中“基”概念的理解(3月3日学习笔记) 在学习《线性规划与目标规划》的过程中,课程的主讲老师郭韧给出了对于基概念的定义如下图 图片来源:运筹学(中国大学mooc网) 由此我产生了几个疑惑:1.如何理解B是线性规划问题的一个基?2.为什么说最多有CnmC_n^mCnm​个基呢?     1.如何理解B是线性规划问题的一个基?1.如何理解B是线性规划问题的一个基?1.如何理解B是线性规划问题的一个基? 在回答第一个... 阅读详情

相关推荐

信息安全-入侵检测技术原理与应用

入侵检测技术原理与应用、入侵检测概述、入侵检测技术、入侵检测系统组成与分类、入侵检测系统主要产品与技术指标、入侵检测系统应用

我的个人博客 1万+

C++之父Bjarne谈C++的未来发展

富有活力的语言需要不断改变和成长,C++也不例外。在本文中,Bjarne Stroustrup提出了自己对C++的设计和演化的看法。为了让编译器、工具和类库实现者跟上节奏,让用户吸收标准C++所支持的编程技术,在早有预计的、沉寂了几年之后,委员会再次考虑语言扩展问 题了。”扩展工作组”已经建立了,它代替了”演化工作组”。名称的改变(这是Tom Plum的建议)反映了更重要的是语言特性和标准类库

老李 3017

知识图谱_知识图谱 | 知识图谱做用户画像

导读:最近一直在思考怎么用知识图谱做推荐,但是目前能知道的内容都是基于路径的推荐和基于图特征的推荐,所以能不能换一个角度,探究一下用知识图谱怎么做用户画像,因为画像也是推荐系统重要的一部分。现在的知识图谱+推荐怎么做的传统的用户画像怎么做现在的知识图谱+推荐怎么做的?基于路径:可以理解成基于图谱的多路径召回,或者多路径推荐,然后根据路径的转移概率进行排序从而达到推荐的效果,基于路径比较适合简单的推...

weixin_28801659的博客 1462

一、初识C++(个人学习总结,不断更新......)

C++

qq_59762728的博客 496

华三模拟器实战:3分钟搞定路由器DHCP地址池配置(附常见错误排查)

本文提供华三模拟器中路由器DHCP地址池的实战配置指南。通过分步详解,帮助用户在3分钟内完成基础设置,并深入讲解多地址池、中继配置等进阶应用。文章重点剖析了DHCP服务无法工作的常见原因,提供从客户端到服务器的系统性排错方法,助力快速定位并解决地址分配失败、获取参数错误等典型问题。

w1x2y3的博客 362

【Python程序开发】湖南省职业院校技能大赛python程序开发赛项样题二

【Python程序开发】湖南省职业院校技能大赛python程序开发赛项样题二

况老师话竞赛&blog 2208

C++编程入门:从零基础到现代开发实践指南

编程语言是计算机科学的基础工具,其核心原理在于将人类可读的代码转换为机器指令。C++作为一门支持多范式编程的系统级语言,其设计哲学强调零开销抽象,即高级特性的使用不应带来不必要的性能损耗,这使得它在性能敏感场景中具有独特价值。在系统软件、游戏引擎、高频交易等对执行效率和硬件控制要求极高的领域,C++凭借其接近硬件的特性和强大的抽象能力,成为不可或缺的技术选型。理解其编译链接过程、内存管理机制和标准库生态,是掌握现代软件开发的关键。本文基于C++11/17等现代标准和CMake构建工具,为初学者梳理从环境搭建

weixin_30367169的博客 322

VR大空间开发前期,设备选项与流程

欢迎开发者加入 VR 大空间开发之旅!本系列教程将以 Pico 和 HTC 设备为核心,系统拆解从基础搭建到功能实现的全流程,助你快速掌握开发要点。本系列共 12 篇,专为有编程基础但缺乏大空间开发经验的开发者设计。前 7 篇针对 Pico 和 HTC 设备差异分别讲解,后续步骤通用。核心目录如下:​1. 空间环境要求 - 灯光设置 - 场地面积规划 - 识别图案设计2. 网络部署方案3. 客户端体验模式解析 - 一体机模式 - 云渲染模式 - 背包体验模式4. Pico空间录制方法

unitygroup的博客 1357

C与C++深度对比:从哲学差异到工程实践的核心分野

在系统级编程领域,类型系统和内存管理是构建可靠软件的基础。类型系统通过编译时检查确保数据操作的安全性,而内存管理则直接关系到程序的性能和稳定性。C语言采用松散的类型系统和完全手动内存管理,赋予程序员极高的控制权,但也带来了安全风险。C++通过严格的类型系统、引用、模板以及RAII(资源获取即初始化)和智能指针等机制,在保持高性能的同时大幅提升了开发安全性与效率。这些核心原理的价值在于,它们使得构建大型、复杂且易于维护的系统成为可能,广泛应用于操作系统、游戏引擎、嵌入式设备和高性能服务器等场景。本文聚焦于C与

weixin_33923762的博客 340

基于STM32L4XX、HAL库的STS40-CD1B-R3温度传感器 驱动程序设计

/ HAL库需要左移一位。// 每2秒读取一次。// 等待测量完成 - 高精度模式大约需要15ms。// 执行软复位确保传感器处于已知状态。温度测量范围:-40°C ~ +125°C。湿度测量范围:0% ~ 100% RH。// 复位后需要等待至少1ms。// 初始化STS40传感器。// 读取温湿度数据。// 转换原始数据为实际值。// 发送读取序列号命令。// 读取序列号数据。湿度精度:±1.5% RH。

zhusl6688的博客 288

【HALCON工业视觉应用探索】08. C#+Halcon视觉引导机器人抓取:从入门到工业级实战(附完整代码+部署指南)

摘要:本文聚焦C#+Halcon在视觉引导机器人抓取领域的落地应用,从新手友好的“二十分钟基础引导系统”切入,逐步深入工业级场景(汽车变速箱壳体抓取)。内容涵盖核心概念(手眼标定原理、坐标转换、机器人通信协议)、完整技术流程(图像采集→目标定位→标定转换→机器人执行→结果反馈)、工业级代码实现(多目标识别、智能抓取策略、实时状态监控),以及现场部署关键技巧(硬件选型、通信配置、精度优化)。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1268

C++与C语言核心差异解析:从编程范式到现代特性

编程语言的核心差异往往源于其设计哲学与编程范式。过程式编程以函数和数据流为核心,强调对硬件的直接控制,适合底层系统开发。而面向对象编程通过封装、继承和多态等机制,将数据与操作绑定,提升了代码的模块化和复用性。在此基础上,泛型编程进一步实现了类型无关的算法抽象,增强了代码的通用性。这些编程范式的演进,本质上是为了应对日益复杂的软件工程挑战,如代码复用、资源管理和系统可维护性。C++作为一门多范式语言,融合了过程式、面向对象和泛型编程,同时通过RAII(资源获取即初始化)和智能指针等机制,在保持高性能的同时显著

weixin_34393428的博客 427

由JavaScript版迷宫游戏引出Java版迷宫地图生成器

Java案例:迷宫地图生成器 一、引入问题 本期18软件1班网页脚本实训项目是完成一个JavaScript版迷宫游戏。 迷宫地图是如何生成的呢?很简单,将一个正方形区域等分为若干行与若干列,比如25行25列,这样就有625个单元格,用一个二维数组map[25][25]就可以保存625个单元格信息,map[i][j] = 1表示该单元格要绘制砖,而map[i][j] = 0表示该单元格不绘制砖。 ...

howard2005的专栏 1473

C++编程思想深度解析:从语法到设计哲学的实战指南

面向对象编程是现代软件开发的核心范式,其三大支柱——封装、继承与多态——构成了构建复杂系统的理论基础。封装通过隐藏实现细节来隔离变化,继承建立了清晰的“is-a”层次关系,而多态则借助虚函数机制实现了运行时动态绑定,让代码能够处理未知类型的对象。这些原理共同支撑了软件的可维护性、可扩展性和复用性,在大型系统架构、框架设计和高性能计算中有着广泛应用。理解这些基础概念后,开发者需要掌握如何将其落地到具体语言中。以C++为例,其独特的资源管理机制(如RAII)、常量正确性保障以及模板泛型编程,都是实现上述设计思想

子夜轻风 443

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

C++入门核心指南:从底层原理到现代编程实践

编程语言的核心价值在于其底层原理与工程实践的结合。理解计算机系统的基础概念,如内存管理、数据类型和编译链接过程,是掌握高效编程的关键。这些原理不仅决定了程序的性能与稳定性,更是构建操作系统、游戏引擎和高频交易系统等核心技术的基石。通过深入探究指针、引用、RAII(资源获取即初始化)和智能指针等机制,开发者能够实现对资源的精准控制,避免内存泄漏等常见问题。现代C++(C++11/14/17)进一步引入了智能指针、自动类型推导和Lambda表达式等特性,显著提升了代码的安全性与简洁性。本文聚焦于C++入门阶段的

weixin_33913332的博客 352

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

侯捷-C++面向对象高级开发-上

侯捷老师经典课程《C++ 面向对象高级开发(上)》的个人学习笔记

weixin_56148345的博客 309

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

libstdc++.so.6: cannot open shared object file: No such file or directory

找不到libstdc++.so.6的原因,大致有以下几种: 1.程序中没有编入路径,使用rpath指定路径,在Makefile中加入如下路径: OBJS=*.o ODIR=obj LDFLAGS=-Wl,-rpath=/lib $(ROOT_DIR)/$(BIN_DIR)/$(BIN):$(ROOT_DIR)/$(OBJS_DIR)/$(OBJS) $(CC) $^ -o $@ $(LDFLAGS) 其中/lib为库的路径。 2.由于环境变量的原因,或者是32位或者64位的兼容原因,确实...

ComputerInBook的专栏 1万+

c++调用静态函数的方法

今天在写c++程序时,发新现在的gcc和vc++对于静态函数的调用方式有所改变,在旧标准的c++中,调用类的静态方法只能用类名::函数名的方式,在新的标准中,类的对像也可以像调用类的方法一样调用静太函数。示例如下: class Date{ int y,m,d; public: Date(); static void Print(); }; Date::Date() {} void Date::Print() { printf("Hello Worl...

ComputerInBook的专栏 1万+

C语言数组指针加1的问题

指向数组的指针存储的是连续的内存地址,而内存地址的最小编址单位是1字节,如果存储的数据本身移动几个字节,则内存地址也相应地移动几个字节。而数组指针的加1移动几个字节,取决于所指向的数组类型,这部分是由C/C++的编译器实现去处理的。下面具几个例子说明(下面的例子在MSVC的X64平台,指针本身占8个字节): 1. 用C++语言测试 (1) 指向1字节的数组指针: void TestPointerSize() { char data[] = {1,2,3,4,5,6,7,8,9,10}; ...

ComputerInBook的专栏 6045

集合论基本概念——覆盖(cover或covering)

集合论基本概念——覆盖(cover或covering)

ComputerInBook的专栏 4417

在Visual Studio C++ 项目中加入一个汇编语言源文件的方法

1.说明:Visual Studio工程系统通过使用MASM的方式支持在C++项目中使用汇编语言文件。MASM完全支持x64汇编语言源文件, 并自动将它们构建到目标文件中。然后,你可以将这些目标文件链入你为X64平台写的C++代码中。这是克服缺少x64内联汇编器的一种方法(意思就是说克服C++编译器不能直接编译.asm后缀的汇编语言源文件的方法,目前还没有内联支持直接编译汇编语言源文件)。 2.具体步骤 2.1 第一步:按Visual Studio向导建立C++工程,下面重点是第二步。 2.2 第二步:.

ComputerInBook的专栏 3464

集合论基本概念——紧致性(compact或compactness)

集合论:紧致性

ComputerInBook的专栏 3329

linux下编译出现multiple definition of 错误

这个错误从表面上看,是出现了重复定义类或函数的情况,大部分都是确实是重复定义了,但是出现这样的重复定义的原因,即是不太容易获知,我这次出现这样错误,是由于Makefile和操作不当引起的错误。 我是做了这样的操作后出现这种情况的,或许对类似的情况有所启发: 1.编写Makefile文件,正常编译没有问题,编译生成了以下2个文件: client.o v4l2-camara.o 2.这个时候,我把源文件改了个名称,改成了v4l2-camera.cpp,在没有make clean的情况...

ComputerInBook的专栏 2812

c&c++的int和long各自所占字节数

做如下测试: 在windows 64 bit 平台上,使用VC分别编译成32位程序和64位程序,int和long都是占4个字节。 在Linux 64 bit 平台上(测试环境为suse linux,gcc编译器),编译成64位程序,int占4字节,long占8个字节。 因此,int和long到底各占多少字节,是和平台和编译器实现有关。 ...

ComputerInBook的专栏 2322

C++编程语言——基础设施:第7章——指针,数组和引用(Bjarne Stroustrup)

指针,数组和引用

ComputerInBook的专栏 2183

C++编程语言——基础设施:第8章——结构,合并和枚举(Bjarne Stroustrup)

C++: 结构,联合和枚举

ComputerInBook的专栏 2092
上一篇: 代数——第6章——对称性(Michael Artin)
下一篇: C++编程语言:标准库:第37章——正则表达式(Bjarne Stroustrup)
ComputerInBook
博客等级 码龄19年 1168粉丝 465原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值