C++基础---字符串(string型字符串)

1. 字符串(string型字符串)

1.1 C++字符串的定义

字符串：是以空字符(即 ‘\0’)结尾的字符数组。

注：‘\0’是一个空字符标志，它的ASCII码为0。C++中有好多处理字符串的函数，他们都是以空字符为结束标志，如cin和cout，他们在碰到空字符后将会停止输入或输出。

1.2 string型字符串

string型字符串：是C++风格的字符串。

string型字符串：是C++的STL提供的一种自定义类型，它可以方便地执行char型字符串所不能执行的一切操作。

string型字符串：是用string类来定义字符串的，string类存在于名字空间std中。

1.3 string类的构造与析构函数

string();

默认构造函数，构造一个空字符串。

string(const string& str);

拷贝构造函数，构建一个复制的结构。

string(const string& str, size_t pos, size_t len = npos);

构造子字符串的函数，从string型字符串str中下标为pos处开始拷贝len个字符。

string(const char* s);

用char型字符串s构造，拷贝以空终止符结束的字符序列。

string(const char* s, size_t n);

从char型字符串s的起始位置开始拷贝n个字符。

string(size_t n, char c);

用n个字符c构造字符串。

template < class InputIterator> string(InputIterator first, InputIterator last);

Copies the sequence of characters in the range [first,last), in the same order.

string(initializer_list il);

Copies each of the characters in il, in the same order.

string(string&& str) noexcept;

Acquires the contents of str.str is left in an unspecified but valid state.

~string();

析构字符串对象，释放字符串的存储空间。

注：当构造的string太长而无法表达时会抛出length_error异常。

1.4 string型字符串转化为char型字符串

const char* data() const;

将自身转化为一个以空终止符结束（即带”\0“结尾）的char型字符串。

const char* c_str() const;

将自身转化为一个以空终止符结束（即带”\0“结尾）的char型字符串。

int copy(char *s, int n, int pos = 0) const;

从源字符串以下标为pos（默认为0）处开始拷贝n个字符到char型字符串s中，返回实际拷贝的数目。

注： string::data和 string::c_str同义，且返回的值是相同的—C++11

1.5 获取指定下标字符操作

const char& operator[] (size_t n) const;

返回源字符串下标为n处的字符的引用，不能被修改。

char& operator[] (size_t n);

返回源字符串下标为n处的字符的引用，可以被修改。

const char& at(size_t n) const;

返回源字符串下标为n处的字符的引用，不能被修改。

char& at(size_t n);

返回源字符串下标为n处的字符的引用，可以被修改。

const char& back() const;

返回源字符串最后一个字符的引用，不能被修改。

char& back();

返回源字符串最后一个字符的引用，可以被修改。

const char& front() const;

返回源字符串第一个字符的引用，不能被修改。

char& front();

返回源字符串第一个字符的引用，可以被改变。

代码示例：

string str = "hello";
char c = str[0];//输出字符h，不提供访问越界检查
char c = str[8];//运行崩溃，不提供访问越界检查，Debug Assertion Failed Expression:string subscript out of range

<=>等价于

char c = str.at(0);//输出字符h，提供访问越界检查
char c = str.at(8);//运行崩溃，不提供访问越界检查，123.exe 中的 0x75644598 处有未经处理的异常: Microsoft C++ 异常: 内存位置 0x00d1f568 处的 std::out_of_range。

注：operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。

1.6 获取存储容量和长度大小操作

size_t capacity() const;

返回string分配的存储容量。

size_t max_size() const;

返回string对象中可存放的最大字符串的长度。

size_t size() const;

返回源字符串的长度大小。

size_t length() const;

返回源字符串的长度大小。

bool empty() const;

判断源字符串是否为空。

void reserve(size_t n = 0);

重新给源字符串分配存储最小为n的容量。

void resize(size_t n);

调整源字符串的长度为n。

void resize(size_t n, char c);

调整字符串长度为n，并用字符c填充不足的部分 。

注：size()与length()方法的功能一样，都是计算能够输出的可见字符的长度 ，length()是早期的版本，size()是后来添加的为了兼容STL。

1.7 输入输出操作

ostream& operator<< (ostream& os, const string& str);

用于输出操作，将字符串插入流。

istream& operator>> (istream& is, string& str);

用于输入操作，从流中提取字符串。

istream& getline(istream& is, string& str, char delim);

从流中提取一行字符串，存入str直到划界字符delim(delimitation)被发现。

istream& getline(istream&& is, string& str, char delim);

从流中提取一行字符串，存入str直划界字符delim(delimitation)被发现。

istream& getline(istream& is, string& str);

从流中提取一行字符串，存入str直到划界字符delim(delimitation)”\n“换行符被发现。

istream& getline(istream&& is, string& str);

从流中提取一行字符串，存入str直到划界字符delim(delimitation)”\n“换行符被发现。

1.8 赋值操作

string& operator= (const string& str);

把string型字符串str赋给当前字符串。

string& operator= (const char* s);

把char型字符串s赋给当前字符串。

string& operator= (char c);

把字符c赋给当前字符串。

string& operator= (initializer_list il);

An initializer_list object.These objects are automatically constructed from initializer list declarators.The characters are copied, in the same order.

string& operator= (string&& str) noexcept;

Acquires the contents of str.str is left in an unspecified but valid state.

string& assign(const string& str);

用string型字符串str赋值给当前字符串。

string& assign(const string& str, size_t subpos, size_t sublen);

用string型字符串str中下标为subpos处开始拷贝sublen个字符赋值给当前字符串。

string& assign(const char* s);

用char型字符串s赋值给当前字符串。

string& assign(const char* s, size_t n);

用char型字符串s的前n个字符赋值给当前字符串。

string& assign(size_t n, char c);

用n个字符c赋值给当前字符串。

template < class InputIterator>string& assign(InputIterator first, InputIterator last);

Copies the sequence of characters in the range [first,last), in the same order.

string& assign(initializer_list il);

Copies each of the characters in il, in the same order.

string& assign(string&& str) noexcept;

Acquires the contents of str.str is left in an unspecified but valid state.

1.9 比较操作

bool operator== (const string& lhs, const string& rhs) noexcept;

比较string型字符串lhs与string型字符串rhs是否相等，相等返回true，不相等返回false。

bool operator== (const char* lhs, const string& rhs);

比较char型字符串lhs与string型字符串rhs是否相等，相等返回true，不相等返回false。

bool operator== (const string& lhs, const char* rhs);

比较string型字符串lhs与char型字符串rhs是否相等，相等返回true，不相等返回false。

bool operator!= (const string& lhs, const string& rhs) noexcept;

比较string型字符串lhs与string型字符串rhs是否不相等，不相等返回ture，相等返回false。

bool operator!= (const char* lhs, const string& rhs);

比较char型字符串lhs与string型字符串rhs是否不相等，不相等返回ture，相等返回false。

bool operator!= (const string& lhs, const char* rhs);

比较string型字符串lhs与char型字符串rhs是否不相等，不相等返回ture，相等返回false。

bool operator< (const string& lhs, const string& rhs) noexcept;

比较string型字符串lhs是否小于string型字符串rhs，小于返回true，大于或等于返回false。

bool operator< (const char* lhs, const string& rhs);

比较char型字符串lhs是否小于string型字符串rhs，小于返回true，大于或等于返回false。

bool operator< (const string& lhs, const char* rhs);

比较string型字符串lhs是否小于char型字符串rhs，小于返回true，大于或等于返回false。

bool operator<= (const string& lhs, const string& rhs) noexcept;

比较string型字符串lhs是否小于或等于string型字符串rhs，小于或等于返回true，大于返回false。

bool operator<= (const char* lhs, const string& rhs);

比较char型字符串lhs是否小于等于string型字符串rhs，小于或等于返回true，大于返回false。

bool operator<= (const string& lhs, const char* rhs);

比较string型字符串lhs是否小于等于char型字符串rhs，小于或等于返回true，大于返回false。

bool operator> (const string& lhs, const string& rhs) noexcept;

比较string型字符串lhs是否大于string型字符串rhs，大于返回true，小于或等于返回false。

bool operator> (const char* lhs, const string& rhs);

比较char型字符串lhs是否大于string型字符串rhs，大于返回true，小于或等于返回false。

bool operator> (const string& lhs, const char* rhs);

比较string型字符串lhs是否大于char型字符串rhs，大于返回true，小于或等于返回false。

bool operator>= (const string& lhs, const string& rhs) noexcept;

比较string型字符串lhs是否大于或等于string型字符串rhs，大于或等于返回true，小于返回false。

bool operator>= (const char* lhs, const string& rhs);

比较char型字符串lhs是否大于或等于string型字符串rhs，大于或等于返回true，小于返回false。

bool operator>= (const string& lhs, const char* rhs);

比较string型字符串lhs是否大于或等于char型字符串rhs，大于或等于返回true，小于返回false。

int compare (const string& str) const noexcept;

比较源字符串和string型字符串str的大小。

int compare(size_t pos, size_t len, const string& str) const;

比较源字符串以下标为pos处开始的len个字符组成的字符串与string型字符串str的大小。

int compare(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen = npos) const;

比较源字符串以下标为pos处开始的len个字符组成的字符串与string型字符串str中以下标为subpos处开始的sublen个字符组成的字符串的大小。

int compare(const char* s) const;

比较源字符串与char型字符串s的大小。

int compare(size_t pos, size_t len, const char* s) const;

比较源字符串以下标为pos处开始的len个字符组成的字符串与char型字符串s的大小。

int compare(size_t pos, size_t len, const char* s, size_t n) const;

比较源字符串以下标为pos处开始的len个字符组成的字符串与char型字符串s的前n个字符组成的字符串的大小。

注：compare函数

(1)返回值value = 0，比较的两个字符串相等；

(2)返回值value < 0，比较的两个字符串，前一个字符的值较低；

(3)返回值value > 0，比较的两个字符串，后一个字符的值较低；

1.10 查找操作

size_t find(const string& str, size_t pos = 0) const noexcept;

从源字符串起始位置pos(默认为0)处，查找有目标字符串str(string型字符串)的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find(const char* s, size_t pos = 0) const;

从源字符串起始位置pos(默认为0)处，查找有目标字符串s(char型字符串)的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find(const char* s, size_t pos, size_type n) const;

从源字符串起始位置pos处，查找有目标字符串s前n个字符(char型字符串)的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find(char c, size_t pos = 0) const noexcept;

从源字符串起始位置pos(默认为0)处，查找有目标字符c的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_of(const string& str, size_t pos = 0) const noexcept;

从源字符串起始位置pos(默认为0)处，依此查找每个字符。如果某字符在目标字符串str(string型字符串)中，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_of(const char* s, size_t pos = 0) const;

从源字符串起始位置pos(默认为0)处，依此查找每个字符。如果某字符在目标字符串s(char型字符串)中，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_of(const char* s, size_t pos, size_t n) const;

从源字符串起始位置pos处，依此查找每个字符。如果该字符在目标字符串s前n个字符(char型字符串)中，则返回该字符首次匹配的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_of(char c, size_t pos = 0) const noexcept;

从源字符串起始位置pos(默认为0)处，依此查找每个字符。如果某字符等于目标字符c，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_not_of(const string& str, size_t pos = 0) const noexcept;

从源字符串起始位置pos(默认为0)处，依此查找每个字符。如果某字符不在目标字符串str(string型字符串)中，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_not_of(const char* s, size_t pos = 0) const;

从源字符串起始位置pos(默认为0)处，依此查找每个字符。如果某字符不在目标字符串s(char型字符串)中，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_not_of(const char* s, size_t pos, size_t n) const;

从源字符串起始位置pos处，依此查找每个字符。如果某字符不在目标字符串s前n个字符(char型字符串)中，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t find_first_not_of(char c, size_t pos = 0) const noexcept;

从源字符串起始位置pos(默认为0)处，依此查找每个字符。如果某字符不等于目标字符c，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的前端开始查找，从左到右遍历字符串)。

size_t rfind(const string& str, size_t pos = npos) const noexcept;

从源字符串起始位置pos(默认为npos)处，查找有目标字符串str(string型字符串)的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t rfind(const char* s, size_t pos = npos) const;

从源字符串起始位置pos(默认为npos)处，查找有目标字符串s(char型字符串)的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t rfind(const char* s, size_t pos, size_t n) const;

从源字符串起始位置pos处，查找有目标字符串s前n个字符(char型字符串)的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t rfind(char c, size_t pos = npos) const noexcept;

从源字符串起始位置pos(默认为npos)处，查找有目标字符c的位置。如果找到，则返回首次匹配的开始位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_of(const string& str, size_t pos = npos) const noexcept;

从源字符串起始位置pos(默认为npos)处，依此查找每个字符。如果某字符在目标字符串str(string型字符串)中，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_of(const char* s, size_t pos = npos) const;

从源字符串起始位置pos(默认为npos)处，依此查找每个字符。如果某字符在目标字符串s(char型字符串)中，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_of(const char* s, size_t pos, size_t n) const;

从源字符串起始位置pos处，依此查找每个字符。如果某字符在目标字符串s前n个字符(char型字符串)中，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_of(char c, size_t pos = npos) const noexcept;

从源字符串起始位置pos(默认为npos)处，依此查找每个字符。如果某字符等于目标字符c，则返回首次匹配的该字符的位置，如果没有找到匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_not_of(const string& str, size_t pos = npos) const noexcept;

从源字符串起始位置pos(默认为npos)处，依此查找每个字符。如果某字符不在目标字符串str(string型字符串)中，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_not_of(const char* s, size_t pos = npos) const;

从源字符串起始位置pos(默认为npos)处，依此查找每个字符。如果某字符不在目标字符串s(char型字符串)中，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_not_of(const char* s, size_t pos, size_t n) const;

从源字符串起始位置pos处，依此查找每个字符。如果某字符不在目标字符串s前n个字符(char型字符串)中，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

size_t find_last_not_of(char c, size_t pos = npos) const noexcept;

从源字符串起始位置pos(默认为npos)处，依此查找每个字符。如果某字符不等于目标字符c，则返回首次不匹配的该字符的位置，如果没有找到不匹配的内容，则返回string::npos(从字符串的末端开始查找，从右到左遍历字符串)。

1.11 清空和删除操作

void clear() noexcept;

将字符串的内容清空，让源字符串成为一个空字符串（长度为0个字符）。

string& erase(size_t pos = 0, size_t len = npos);

删除源字符串以下标为pos开始的len个字符，返回修改后的字符串。

iterator erase(const_iterator p);

删除源字符串迭代器对象p指向的字符，返回删除后迭代器的位置。

iterator erase(const_iterator first, const_iterator last);

删除源字符串迭代器范围为[first，last）内的所有字符，返回删除后迭代器的位置。

void pop_back();

删除字符串的最后一个字符，有效的减少它的长度。

1.12 插入操作

string& insert(size_t pos, const string& str);

在源字符串下标为pos处插入string型字符串str。

string& insert(size_t pos, const string& str, size_t subpos, size_t sublen = npos);

在源字符串下标为pos处插入string型字符串str中以下标处为subpos开始的sublen个字符组成的子字符串。

string& insert(size_t pos, const char* s);

在源字符串下标为pos处插入char型字符串s。

string& insert(size_t pos, const char* s, size_t n);

在源字符串下标为pos处插入char型字符串s的前n个字符组成的子字符串。

string& insert(size_t pos, size_t n, char c);

在源字符串下标为pos处插入n个字符c。

iterator insert(const_iterator p, size_t n, char c);

在源字符串的迭代器p处插入n个字符c，返回插入后迭代器的位置。

iterator insert(const_iterator p, char c);

在源字符串的迭代器p处插入字符c，返回插入后迭代器的位置。

template < class InputIterator>iterator insert(iterator p, InputIterator first, InputIterator last);

Inserts a copy of the sequence of characters in the range [first,last), in the same order.

string& insert(const_iterator p, initializer_list il);

Inserts a copy of each of the characters in il, in the same order.

1.13 替换操作

string& replace(size_t pos, size_t len, const string& str);

删除源字符串从下标为pos处开始的len个字符，然后在pos处插入string型字符串str。

string& replace(const_iterator i1, const_iterator i2, const string& str);

删除源字符串从迭代i1到i2的所有字符，然后在迭代i1处插入string型字符串str。

string& replace(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen = npos);

删除源字符串从下标为pos处开始的len个字符，然后在pos处插入string型字符串str的从下标为subpos开始的sublen个字符组成的子字符串。

string& replace(size_t pos, size_t len, const char* s);

删除源字符串从下标为pos处开始的len个字符，然后在pos处插入char型字符串s。

string& replace(const_iterator i1, const_iterator i2, const char* s);

删除源字符串从迭代i1到i2的所有字符，然后在迭代i1处插入char型字符串s。

string& replace(size_t pos, size_t len, const char* s, size_t n);

删除源字符串从下标为pos处开始的len个字符，然后在pos处插入char型字符串s前n个字符组成的子字符串。

string& replace(const_iterator i1, const_iterator i2, const char* s, size_t n);

删除源字符串从迭代i1到i2的所有字符，然后在迭代i1处插入char型字符串s前n个字符组成的子字符串。

string& replace(size_t pos, size_t len, size_t n, char c);

删除源字符串从下标为pos处开始的len个字符，然后在pos处插入n个字符c。

string& replace(const_iterator i1, const_iterator i2, size_t n, char c);

删除源字符串从迭代i1到i2的所有字符，然后在迭代i1处插入n个字符c。

template < class InputIterator>string& replace(const_iterator i1, const_iterator i2, InputIterator first, InputIterator last);

Copies the sequence of characters in the range [first,last), in the same order.

string& replace(const_iterator i1, const_iterator i2, initializer_list il);

Copies each of the characters in il, in the same order.

1.14 连接操作

string& operator+= (const string& str);

把string型字符串str连接到源字符串的结尾。

string& operator+= (const char* s);

把char型字符串s连接到源字符串的结尾。

string& operator+= (char c);

把字符c连接到源字符串的结尾。

string& operator+= (initializer_list il);

An initializer_list object.These objects are automatically constructed from initializer list declarators.The characters are appended to the string, in the same order.

string& append(const string& str);

把string型字符串str连接到源字符串结尾。

string& append(const string& str, size_t subpos, size_t sublen);

用string型字符串str中从下标为subpos处开始的sublen长度的字符串连接到当前字符串结尾。

string& append(const char* s);

把char型字符串s连接到当前字符串结尾。

string& append(const char* s, size_t n);

用char型字符串s开始的n个字符连接到当前字符串结尾。

string& append(size_t n, char c);

在当前字符串结尾添加n个字符c。

template < class InputIterator> string& append(InputIterator first, InputIterator last);

Appends a copy of the sequence of characters in the range [first,last), in the same order.

string& append(initializer_list il);

Appends a copy of each of the characters in il, in the same order.

void push_back(char c);

添加字符到字符串的末尾。

1.15 迭代器操作

const_iterator begin() const noexcept;

返回string的迭代起始位置（从字符串的前到后的迭代）。

iterator begin() noexcept;

返回string的迭代起始位置（从字符串的前到后的迭代）。

const_iterator end() const noexcept;

返回string的迭代结束位置（从字符串的前到后的迭代）。

iterator end() noexcept;

返回string的迭代结束位置（从字符串的前到后的迭代）。

const_reverse_iterator rbegin() const noexcept;

返回string的迭代起始位置（从字符串的后到前的迭代）。

reverse_iterator rbegin() noexcept;

返回string的迭代起始位置（从字符串的后到前的迭代）。

const_reverse_iterator rend() const noexcept;

返回string的迭代结束位置（从字符串的后到前的迭代）。

reverse_iterator rend() noexcept;

返回string的迭代结束位置（从字符串的后到前的迭代）。

const_iterator cbegin() const noexcept;

返回一个const_iterator指向字符串的第一个字符（从字符串的前到后的迭代）。

const_iterator cend() const noexcept;

返回一个const_iterator指向字符串的最后一个字符（从字符串的前到后的迭代）。

const_reverse_iterator crbegin() const noexcept;

返回一个const_iterator指向字符串的第一个字符（从字符串的后到前的迭代）。

const_reverse_iterator crend() const noexcept;

返回一个const_iterator指向字符串的最后一个字符（从字符串的后到前的迭代）。

1.16 获取子串操作

string substr (size_t pos = 0, size_t len = npos) const;

返回源字符串以下标为pos开始的len个字符组成的字符串。

1.17 交换两个字符串操作

void swap (string& str);

交换源字符串与string型字符串str的值。

1.18 字符串流处理

通过定义ostringstream和istringstream变量实现，#include 头文件中

代码示例：

string input("hello,this is a test");
istringstream is(input);
string s1,s2,s3,s4;
//s1="hello,this";
//s2="is";
//s3="a";
//s4="test";
ostringstream os;
is>>s1>>s2>>s3>>s4;
os<<s1<<s2<<s3<<s4;
cout<<os.str();

补充：在你所用的所有头文件之前包含#include < afxwin.h >，例如：可以在stdafx.h文件的最前面包含#include < afxwin.h >头文件，这样在你的源代码中就可以使用CString类了，不过这样也有一个缺点，就是编译出来的程序要比原来的大很多。我试过一个小程序，选择”Use Standard Windows Libraries” 编译出的Release版本大概92kb，使用”Use MFC in a Static Library”编译出来的Release版本大概192kb，足足大了100kb，这个就个人考虑了……

参考文献：

[1] 网络资源： http://www.cplusplus.com/reference/string/string/