大家好，欢迎来到IT知识分享网。

C语言中只有字符数组这一说法，没有C++专门封装的字符串类std::string。而字符数组C-String以\0作为结束符。std::string其实还是存储了C-String这个指针，只不过不同的编译期对std::string中的存储结构都做了不同的处理，这里我们不讨论std::string的实现，只关心一件事，那就是C-String和std::string的相互转换。

C-String 2 std::string

std::string的定义是std::basic_string<char>，因此，重点还是在std::basic_string。

关于std::basic_string的成员函数，可以参考https://en.cppreference.com/w/cpp/string/basic_string

这之中的一些成员函数就提供了转换的功能，我们一起来看看。

构造函数

这里的构造函数包含普通构造函数和赋值构造函数。

普通构造函数

basic_string( const CharT* s,
              size_type count, 
              const Allocator& alloc = Allocator() );
              
basic_string( const CharT* s,
              const Allocator& alloc = Allocator() );
              
template< class InputIt >
basic_string( InputIt first, InputIt last, 
              const Allocator& alloc = Allocator() );

std::basic_string只有这三个普通构造函数与C-String相关，可以看到，这三个构造函数分别接受一个字符指针和字符个数、一个字符指针、[开始字符指针，结束字符指针)。这就是转换。下面是例子。

std::string strA("FlushHip");
std::string strB("FlushHip", 5);
std::string strC("FlushHip", "FlushHip" + 8);

赋值构造函数

basic_string& operator=( const CharT* s );

这允许我们可以直接把字符数组赋值给std::string。

std::string str = "FlushHip";

assign

basic_string& append( const CharT* s, size_type count );

basic_string& append( const CharT* s );

template< class InputIt >
basic_string& append( InputIt first, InputIt last );

这和普通构造函数的三个函数很类似，一样的用法，我们可以在空字符串后追加C-String来达到转换的目的。

std::string().append("FlushHip");
std::string().append("FlushHip", 5);
std::string().append("FlushHip", "FlushHip" + 8);

operator+=

basic_string& operator+=( const CharT* s );

std::string str;
str += "FlushHip";

assign

basic_string& assign( const CharT* s,
                      size_type count );

basic_string& assign( const CharT* s );

template< class InputIt >
basic_string& assign( InputIt first, InputIt last );

和std::string::append差不多，只不过这里变成了给std::string“赋值”，和operator=的作用是一样的。

std::str;
str.assign("FlushHip");
str.assign("FlushHip", 5);
str.assign("FlushHip", "FlushHip" + 8);

std::string 2 C-String

在C++中调用系统API，而系统API通常需要C-String字符数组，因此。这里还是比较重要的。

c_str

const CharT* std::basic_string::c_str() const;

返回std::string存储的常量字符数组指针，这是我们从std::string转到const char *最常用的手段；

返回的字数数组指针指向的字符数组以\0结束。因此[c_str(); c_str() + size()]都是有效的。

std::string str("FlushHip);

assert(s.size() == std::strlen(s.c_str()));
assert(std::equal(s.begin(), s.end(), s.c_str()));
assert(std::equal(s.c_str(), s.c_str() + s.size(), s.begin()));
assert(0 == *(s.c_str() + s.size()));

const char *pString = str.c_str();	// pString = "FlushHip"

data

const CharT* std::basic_string::data() const;

std::basic_string::data和std::basic_string::c_str的作用是一样的，唯一的不同就是C++98中，data返回的常量字符数组指针指向的字符数组不以\0结尾。但是自从C++11起，std::basic_string::data和std::basic_string::c_str就完全等同了。

copy

size_type std::basic_string::copy( CharT* dest,
						                size_type count,
						                size_type pos = 0) const;

如果我们不需要常量字符数组的指针，那么，只有重新开一个字符数组，用std::string::copy复制了；

既然是复制，那么就不会复制\0到新的字符数组，那么最后就要自己手动添加\0，如果开始位置pos > size()就会抛出std::out_of_range异常；

同时，如果count == std::string::npos，那么复制的范围是[pos, size())。

std::string str("FlushHip");
char arrayString[9];
str.copy(arrayString, 8, 0);
arrayString[8] = '\0'; // arrayString = "FlushHip"

当然，你可以用std::string::c_str搭配std::memcpy或者strcpy来完成。

总结

转换的方法很多，觉得好用方便就行。