在C++中，有兩種型別的字串表示形式：

• C-風格字串
• C++引入的string類

C-風格字串

C 風格的字串起源於 C 語言，並在 C++ 中繼續得到支援。字串實際上是使用 null 字元 ‘\0’ 終止的一維字元陣列。因此，一個以 null 結尾的字串，包含了組成字串的字元。
下面的宣告和初始化建立了一個 “Hello” 字串。由於在陣列的末尾儲存了空字元，所以字元陣列的大小比單詞 “Hello” 的字元數多一個。

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

其實，您不需要把 null 字元放在字串常量的末尾。C++ 編譯器會在初始化陣列時，自動把 ‘\0’ 放在字串的末尾。所以也可以利用下面的形式進行初始化

char greeting[] = "Hello";

以下是 C/C++ 中定義的字串的記憶體表示：

C++ 中有大量的函式用來操作以 null 結尾的字串：

C++ 中的 String 類

C++ 標準庫提供了 string 類型別，支援上述所有的操作，另外還增加了其他更多的功能。比如：

• append() – 在字串的末尾新增字元
• find() – 在字串中查詢字串
• insert() – 插入字元
• length() – 返回字串的長度
• replace() – 替換字串
• substr() – 返回某個子字串
• …

4種字串型別

C++中的字串一般有以下四種類型，

• string

• char*

• const char*
• char[]

下面分別做簡單介紹，並說明其中的一些區別

string

string是一個C++類庫中的一個類，它位於名稱空間std中，因此必須使用using編譯指令或者std::string來引用它。它包含了對字串的各種常用操作，它較char*的優勢是內容可以動態拓展，以及對字串操作的方便快捷，用+號進行字串的連線是最常用的操作

char*

char* 是指向字串的指標(其實嚴格來說，它是指向字串的首個字母)，你可以讓它指向一串常量字串。

const char*

該宣告指出，指標指向的是一個const char型別，即不能通過當前的指標對字串的內容作出修改

注意這裡有兩個概念：

• char * const [指向字元的靜態指標]
• const char * [指向靜態字元的指標]

前者const修飾的是指標，代表不能改變指標
後者const修飾的是char，代表字元不能改變，但是指標可以變，也就是說該指標可以指標其他的const char。

char[]

與char*與許多相同點，代表字元陣列，可以對應一個字串，如

char * a="string1";
char b[]="string2";

這裡a是一個指向char變數的指標，b則是一個char陣列（字元陣列）
也就是說：

二者的不同點

一，char*是變數，值可以改變， char[]是常量，值不能改變！
a是一個char型指標變數，其值（指向）可以改變；
b是一個char型陣列的名字，也是該陣列首元素的地址，是常量，其值不可以改變

二，char[]對應的記憶體區域總是可寫，char*指向的區域有時可寫，有時只讀
比如：

char * a="string1";
char b[]="string2";
gets(a); //試圖將讀入的字串儲存到a指向的區域，執行崩潰！ 
gets(b) //OK

解釋： a指向的是一個字串常量，即指向的記憶體區域只讀；
b始終指向他所代表的陣列在記憶體中的位置，始終可寫！

注意，若改成這樣gets(a)就合法了：

char * a="string1";
char b[]="string2";
a=b; //a,b指向同一個區域
gets(a) //OK
printf("%s",b) //會出現gets(a)時輸入的結果

解釋： a的值變成了是字元陣列首地址，即&b[0]，該地址指向的區域是char *或者說 char[8]，習慣上稱該型別為字元陣列，其實也可以稱之為“字串變數”，區域可讀可寫。

總結：char *本身是一個字元指標變數，但是它既可以指向字串常量，又可以指向字串變數，指向的型別決定了對應的字串能不能改變！

三，char * 和char[]的初始化操作有著根本區別：
測試程式碼：

char *a="Hello World"; 
char b[]="Hello World"; 
printf("%s, %d\n","Hello World", "Hello World"); 
printf("%s, %d %d\n", a, a,  &a);                           
printf("%s, %d %d\n", b,     b,  &b);

結果：

Hello World，13457308
Hello World，13457308    2030316
Hello World，2030316 2030316

結果可見：儘管都對應了相同的字串，但”Hellow World”的地址 和 a對應的地址相同，與b指向的地址有較大差異；&a 、&b都是在同一記憶體區域，且&b==b
根據c記憶體區域劃分知識，我們知道，區域性變數都建立在棧區，而常量都建立在文字常量區，顯然，a、b都是棧區的變數，但是a指向了常量（字串常量），b則指向了變數（字元陣列），指向了自己(&b==b==&b[0])。
說明以下問題：
char * a=”string1”;是實現了3個操作：

1. 宣告一個char*變數(也就是聲明瞭一個指向char的指標變數);
2. 在記憶體中的文字常量區中開闢了一個空間儲存字串常量”string1”
3. 返回這個區域的地址，作為值，賦給這個字元指標變數a

最終的結果：指標變數a指向了這一個字串常量“string1”
（注意，如果這時候我們再執行：char * c=”string1”；則，c==a，實際上，只會執行上述步驟的1和3，因為這個常量已經在記憶體中建立）

char b[]=”string2”;則是實現了2個操作：

1. 宣告一個char 的陣列，
2. 為該陣列“賦值”，即將”string2”的每一個字元分別賦值給陣列的每一個元素

最終的結果：“陣列的值”（注意不是b的值）等於”string2”，而不是b指向一個字串常量

實際上， char * a=”string1”; 的寫法是不規範的！
因為a指向了即字元常量，一旦strcpy(a,”string2”)就糟糕了，試圖向只讀的記憶體區域寫入，程式會崩潰的！儘管VS下的編譯器不會警告，但如果你使用了語法嚴謹的Linux下的C編譯器GCC，或者在windows下使用MinGW編譯器就會得到警告。
所以，我們還是應當按照”型別相同賦值”的原則來寫程式碼：

const char * a="string1";

保證意外賦值語句不會通過編譯

另外，關於char*和char[]在函式引數中還有一個特殊之處，執行下面的程式碼

void fun1 ( char *p1,  char p2[] ) {
 printf("%s %d %d\n",p1,p1,&p1);
 printf("%s %d %d\n",p2,p2,&p2);
p2="asdf"; //通過! 說明p2不是常量！ 
printf("%s %d %d\n",p2,p2,&p2);
}
void main(）{
char a[]="Hello";
fun1(a,a);
}

執行結果：

Hello 3471628 3471332
Hello 3471628 3471336
asdf 10704764 3471336

結果出乎意料！上面結果表明p2這時候根本就是一個指標變數！
結論是：作為函式的形式引數，兩種寫法完全等效的！都是指標變數！

const char*與char[]的區別：
const char * a=”string1”
char b[]=”string2”;
二者的區別在於：

1. a是const char 型別， b是char const型別
   （ 或者理解為 (const char)xx 和 char (const xx) ）

2. a是一個指標變數，a的值（指向）是可以改變的，但a只能指向（字串）常量，指向的區域的內容不可改變；

3. b是一個指標常量，b的值（指向）不能變；但b指向的目標（陣列b在記憶體中的區域）的內容是可變的

4. 作為函式的宣告的引數的時候，char []是被當做char *來處理的！兩種形參宣告寫法完全等效！

字串型別之間的轉換： string、const char*、 char* 、char[]相互轉換

一、轉換表格

二、總結方法：

1. 變成string,直接賦值。
2. char[]變成別的，直接賦值。
3. char*變constchar*容易，const char*變char*麻煩。<const_cast><char*>(constchar*);
4. string變char*要通過const char*中轉。
5. 變成char[]。string逐個賦值，char* const char* strncpy_s()。

三，程式碼示例

1、string轉為其他型別

①、string轉const char*

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    std::string str = "HelloWorld!";     //初始化string型別，並具體賦值
    const char* constc = nullptr;         //初始化const char*型別，並賦值為空
    constc= str.c_str();                 //string型別轉const char*型別
    printf_s("%s\n", str.c_str());        //列印string型別資料 .c_str()
    printf_s("%s\n", constc);             //列印const char*型別資料
    return 0;
}

②、string轉char*

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    std::string str = "HelloWorld!";     //初始化string型別，並具體賦值
    char* c = nullptr;                    //初始化char*型別，並賦值為空
    const char* constc = nullptr;         //初始化const char*型別，並賦值為空
    constc= str.c_str();                 //string型別轉const char*型別
    c= const_cast<char*>(constc);        //const char*型別轉char*型別
    printf_s("%s\n", str.c_str());        //列印string型別資料 .c_str()
    printf_s("%s\n",c);                  //列印char*型別資料
    return 0;

}

③、string轉char[]

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    std::string str = "HelloWorld!";      //初始化string型別，並具體賦值
    char arrc[20] = {0};                   //初始化char[]型別，並賦值為空
    for (int i = 0; i < str.length(); i++) //string型別轉char[]型別
    {
        arrc[i]=str[i];
    }
    printf_s("%s\n", str.c_str());         //列印string型別資料 .c_str()
    printf_s("%s\n", arrc);                //列印char[]型別資料
    return 0;
}

2、const char*轉為其他型別

①const char*轉string

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    const char* constc = "Hello World!";     //初始化const char* 型別，並具體賦值
    std::string str;                        //初始化string型別
    str= constc;                            //const char*型別轉string型別
    printf_s("%s\n", constc);                //列印const char* 型別資料
    printf_s("%s\n", str.c_str());           //列印string型別資料
    return 0;
}

②const char*轉char*

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    const char* constc = "Hello World!";     //初始化const char* 型別，並具體賦值
    char* c = nullptr;                       //初始化char*型別
    c= const_cast<char*>(constc);           //const char*型別轉char*型別
    printf_s("%s\n", constc);                //列印const char* 型別資料
    printf_s("%s\n", c);                     //列印char*型別資料
    return 0;
}

③const char*轉char[]

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    const char* constc = "Hello World!";     //初始化const char* 型別，並具體賦值
    char arrc[20] = { 0 };                   //初始化char[]型別，並賦值為空
    strncpy_s(arrc,constc,20);              //const char*型別轉char[]型別
    printf_s("%s\n", constc);                //列印const char* 型別資料
    printf_s("%s\n", arrc);                  //列印char[]型別資料
    return 0;
}

3、char*轉為其他型別

①char*轉string

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    char* c = "HelloWorld!";           //初始化char* 型別，並具體賦值
    std::string str;                   //初始化string型別
    str= c;                            //char*型別轉string型別
    printf_s("%s\n", c);                //列印char* 型別資料
    printf_s("%s\n", str.c_str());      //列印string型別資料
    return 0;
}

②char*轉const char*

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    char* c = "HelloWorld!";         //初始化char* 型別，並具體賦值
    const char* constc = nullptr;     //初始化const char* 型別，並具體賦值
    constc= c;                       //char*型別轉const char* 型別
    printf_s("%s\n", c);              //列印char* 型別資料
    printf_s("%s\n", constc);         //列印const char* 型別資料
    return 0;
}

③char*轉char[]

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    char* c = "HelloWorld!";         //初始化char* 型別，並具體賦值
    char arrc[20] = { 0 };           //初始化char[] 型別，並具體賦值
    strncpy_s(arrc,c,20);             //char*型別轉char[] 型別
    printf_s("%s\n", c);              //列印char* 型別資料
    printf_s("%s\n", arrc);           //列印char[]型別資料
    return 0;
}

4、char[]轉為其他型別

#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
    char arrc[20] = "HelloWorld!";//初始化char[] 型別並具體賦值
    std::string str;                 //初始化string
    const char* constc = nullptr;   //初始化const char*
    char*c = nullptr;                //初始化char*
    str= arrc;                     //char[]型別轉string型別
    constc= arrc;             //char[]型別轉const char* 型別
    c= arrc;                        //char[]型別轉char*型別
    printf_s("%s\n", arrc);         //列印char[]型別資料
    printf_s("%s\n", str.c_str());  //列印string型別資料
    printf_s("%s\n", constc);       //列印const char* 型別資料
    printf_s("%s\n", c);            //列印char*型別資料
    return 0;
}