可以使用using聲明而無需專門的前綴：using namespace::name;.。位于頭文件的代碼一般來說不應該使用using聲明，這是因為頭文件的內容會拷貝到所有引用他的文件中去，如果頭文件中有某個using聲明，那么每個使用了該頭文件的文件都會有這個聲明。對于某些程序來說，由于不經意間包含了一些名字，反而可能產生始料未及的名字沖突。

使用string類型需要添加頭文件#include<string>，并且要對string進行聲明：using std::string;

string類型的初始化：

string s1;		默認初始化，s1是一個空字符串
string s2 = s1;	s2是s1的副本，等價于s2(s1)
string s3 = "hello";	s3是該字符串字面值的副本，等價于s3("hello");
string s4(10, 'c');	s4的內容是10個c

需要注意的是s3是的內容不包括字面值最后的空字符。當初始值只有一個的時候，拷貝初始化（使用=）和直接初始化都可以，但是如果有多個初始值（s4的初始化），就只能夠使用直接初始化的方式。

string的操作

os<<s		將s寫入都輸出流os中，返回os
is>>s		從is中讀取字符串賦給s，字符串以空白分隔，返回is
getline(is, s)	從is中讀取一行賦給s，返回is
s.empty()	s為空返回true，否則返回false
s.size()	返回s中字符的個數
s[n]		返回s中第n個字符的引用
s1+s2		返回s1和s2連接后的結果
s1=s2		用s2的副本代替s1中原本的字符
s1==s2		如果s1和s2所包含的字符完全一樣，則返回true
s1!=s2
<,<=,>,>=	根據字典序進行比較	

可以使用while(cin>>s)進行循環讀入，getline會讀入換行符，但是不會把換行符保存到string對象中。因為getline返回的也是輸入流，因此也可以使用while(getline(cin,s))進行循環讀入

size()函數返回值是string::size_type類型，這是一個無符號整型，因此如果我們直接使用size()的返回值和一個負數比較，則幾乎肯定是true，這是因為負數n會自動轉換成一個比較大的無符號整數。（在C++中int和unsigned int在一起的時候前者會自動轉換為后者）。盡量還是用一個int變量保存返回值或者進行強制類型轉換。

如果兩個字符串前面都相同，長的那個比短的大

復合運算符+=負責把右側string對象追加到左側string對象的后面

當把string對象和字符（串）字面值混在一條語句中使用時，必須確保每個加法運算符+兩側的運算對象至少有一個是string。

string a = "Hello";
string b = a + "world" + "!";	//正確
string c = "Hello" + "world" + a;	//錯誤

字符串字面值與string是不同的類型

應該盡可能使用C++版本的C標準庫頭文件（去掉結尾的.h，在前面加上c表示屬于C標準庫的頭文件），雖然兩者內容一樣，但是在名為cname中的頭文件中定義的名字從屬于命名空間std，而.h頭文件則不然。

可以使用庫cctype判斷一個字符的類別

isalnum(c)	當c為字母或數字為真
isalpha(c)	當c為字母為真
iscntrl(c)	當c為控制字符為真
isdigit(c)	當c為數字為真
islower(c)	當c為小寫字母為真
ispunct(c)	當c為標點符號為真
isspace(c)	當c為空白字符為真
isupper(c)	當c為大寫字母為真
tolower(c)	如果c是大寫字母則返回小寫字母，否則原樣輸出
toupper(c)	如果c是小寫字母則返回大寫字母，否則原樣輸出	

如果想要改變string對象中字符的值則必須把循環變量定義成引用類型：

string s;
cin >> s;
//將s中每個字母變成大寫
for(auto &c : s)
{c = toupper(c);
}
cout << s << endl;

從這里也可以看出c每次會重新定義

string類型的下標是string::size_type類型的，任何一個帶符號類型的值將自動轉化為這種無符號類型。注意不要越界，越界的行為是未定義的。

注意邏輯運算符&&和||的短路性質

const string的每一個字符是const char類型的

模板本身不是類或者函數，可以將模板看做編譯器生成類或者函數編寫的一份說明。編譯器根據模板創建類或函數的過程成為實例化 。當使用模板時，需要指出編譯器應把類或函數實例化成何種類型。

vector<int> a;
vector<vector<string>> file;	

vector能容納絕大多數類型的對象作為元素，但是因為引用不是對象，所以不存在包含引用的vector。
需要指出的是，在舊版本中多維vector的聲明中最后的>之間必須有空格，否則編譯器會認為是右移運算符。

vector初始化：

vector<T> v1;		v1是一個空的vector，潛在的元素是T類型的，執行默認初始化
vector<T> v2(v1);	v2包含有v1所有元素的副本
vector<T> v2 = v1;	等價于v2(v1)
vector<T> v3(n, val)v3包含了n個重復元素，每個元素的值都是val
vector<T> v4(n)		v4包含了n個重復地執行了值初始化的對象
vector<T> v5{a, b, c,...}v5包含了初始值個數的元素，每個元素被賦予對應的初始值
vector<T> v5 = {a, b, c...}等價于v5{a, b, c,...}	

C++幾種初始化方式一般來說可以相互等價地使用，但是也有幾種特殊情況：

• 使用拷貝初始化（使用=的時候）只能提供一個初始值
• 類內初始化只能使用拷貝初始化或花括號的形式
• 如果提供的是初始元素之的列表，則只能把初始值放在花括號里而不能放在圓括號里

可以只提供vector對象容納的元素數量而略去初始值，此時庫會創建一個值初始化的元素初值，并把它賦給容器中的所有元素。但是如果元素對象是一個類，而這個類明確要求需要提供初始值，則無法完成初始化工作。

如果使用圓括號來初始化，可以說提供的值是用來構造vector對象的；如果使用花括號，可以表述成我們想列表初始化該vector對象。但是如果提供的值不支持列表初始化，編譯器就會嘗試理解為直接初始化（把{當做(來處理），如果仍舊無法進行初始化，則報錯

使用push_back方法向vector的尾部添加元素。C++標準要求vector應該能在運行時高效添加元素，因為vector對象能夠高效地增長，在定義vector對象設定其大小沒有什么必要，事實上這么做性能可能更差，這一點和Java不同。

如果循環體內部包含向vector對象添加元素的語句，則不能使用范圍for循環（for(auto item:a)）

常見的vector操作：

v.empty()
v.size()
v.push_back(t)
v[n]
v1 = v2		用v2中元素的拷貝替換v1中的元素
v1 = {a,b,c...}	用列表中元素的拷貝替換v1中的元素
v1 == v2 	v1和v2相等當且僅當他們的元素數量相同而且對應位置的元素值都相同
<, <=, >, >=	顧名思義，以字典順序進行比較	

size函數返回size_type類型，需要指定對應的模板類型，例如：

vector<int>::size_type		//正確
vector::size_type			//錯誤	

使用比較運算符需要元素可以相互比較
vector的下標運算符可用于訪問已經存在的元素，而不能用于添加元素

所有標準庫容器都可以使用迭代器，但是其中只有少數幾種才同事支持下標運算符。嚴格來說，string對象不屬于容器類型，但是string支持很多與容器類型類似的操作。這些類型都擁有名為begin和end的成員，其中begin成員負責指向第一個元素的迭代器，end成員負責返回指向容器尾元素的下一位置的迭代器（尾后迭代器或尾迭代器）。如果容器為空，begin和end返回同一個迭代器。使用auto進行迭代器的定義比較方便。
常見操作：

*iter 	返回迭代器所指元素的引用
iter->member	相當于(*iter).member
++iter	令迭代器指向容器的下一個元素
--iter	令迭代器指向容器的上一個元素
iter1 == iter2	判斷兩個迭代器是否相等
iter1 != iter2 	

試圖解引一個尾后迭代器是未定義的行為

//以此處理s的字符串直到我們全部處理完或遇到空白字符
for(auto it = s.begin(); it != s.end() && !isspace(*it); ++it)
{*it = toupper(*it);
}	

在C++中我們更愿意使用迭代器和!=判斷是否到達尾部。這樣做的原因是所有容器都支持這些操作，而下標和<則只有很少的容器定義。

迭代器的類型有兩種：iterator和const_iterator，后者表示不能修改元素值，如果vector或string是const的，則只能使用這種類型。

string::iterator it1;
vector<int>::const_iterator it2;

如果容器是常量，則begin和end返回的類型是const_iterator類型的迭代器。如果我們使用cbegin和cend則無論容器是否是常量都返回const_iterator類型的迭代器。

//依次輸出text的每一行直到遇到第一個空白行
for(auto it = text.cbegin(); it != text.cend() && !it->empty(); ++it)
{cout << *it << endl;3
}	

使用范圍for循環或者使用迭代器進行循環都不能改變容器對象的容量，否則有可能使得迭代器失效

迭代器運算：string和vector的迭代器提供了更多的運算符，可以讓迭代器每次跨過多個元素，另外也支持迭代器進行關系運算

//小心越界
iter + n 		迭代器向后移動n個元素
iter - n		迭代器向前移動n個元素
iter += n
iter -= niter1 - iter2 	返回兩個迭代器之間的距離
<, <=, >, >=

其中迭代器之間的-返回difference_type的帶符號整數

int bSearch(const vector<int> &a, int x)
{	auto begin = a.cbegin();auto end = a.cend();auto mid = begin + (end - begin) / 2;while(mid != end && *mid != x){if(*mid < x)begin = mid + 1;else end = mid;mid = begin + (end - begin) / 2;}if(mid == end) return -1;else return mid - begin;
}

數組也是存放類型相同的對象的容器，這些對象本身沒有名字，需要通過其所在位置訪問，不過數組的大小不能改變。

數組是一種復合類型，元素的個數也屬于數組類型的一部分，編譯的時候維度應該是已知的（維度必須是一個常量表達式）。數組的元素會被默認初始化，如果數組的元素是內置類型而且數組在函數內部定義，則每個元素不會被初始化。不允許用auto關鍵字由初始值的列表推斷類型，且不存在引用的數組

如果用初始值列表初始化數組，則數組的維度可以不指明，默認為初始值列表的長度。如果指定維度的話則維度至少要比初始值列表的長度長，剩下的元素會被默認初始化

字符數組可以用字符串字面值進行初始化，不過需要注意的是字符串字面值的末尾有一個空字符也會被拷貝到字符數組中，因此字符數組的長度應該是可見的字符個數加一

不能將數組的內容拷貝給其他數組作為初始值，也不能用數組為其他數組賦值

對于聲明中有括號的應該先理解括號里面的，再從右往左進行理解

int *ptr[10];	ptr是含有10個整型指針的數組
int &ptr[10];	錯誤，不存在引用的數組
int (*ptr)[10];	ptr是指針，指向含有10個元素的數組
int (&ptr)[10] = arr;	ptr是引用,指向一個含有10個元素的數組	

在使用數組下標時，通常將其定義為size_t了類型。size_t是一種機器相關的無符號類型，被設計得足夠大能夠表示內存中任意對象的大小。在cstddef頭文件中定義

對于數組我們同樣可以使用范圍for循環：

unsigned scores[11] = {};	//進行初始化
for (auto i : scores)cout << i << " ";	

在C++中，使用指針的時候編譯器一般會把它轉換成指針。在很多用到指針名字的地方，編譯器都會自動將其替換為一個指向數組首元素的指針。

當我們將數組作為一個auto變量的初始值時，推斷得到的類型是指針而非數組。但是用decltype返回的類型仍然是數組

int ia[] = {0, 1, 2, 3, 4};
auto ia2(ia);	//ia2是一個整型指針
decltype(ia) ia3 = {};	//含有5個元素的整型數組	

我們可以像使用迭代器一樣使用指針，為了讓指針的使用更簡單、安全，C++11新標準引入兩個名為begin和end的函數。這兩個函數定義在iterator頭文件中

int a[10] = {};
int *beg = begin(a);	//相當于int *beg = a;
int *last = end(a);		//相當于int *last = &a[10];

同尾后迭代器一樣，尾后指針不能執行解引操作和遞增操作

迭代器支持的操作指針都支持，包括和整數進行加減、指針和指針的減法、指針和指針比較大小，但是需要注意的是上面的操作兩個指針要在同一個數組中才有意義。特別地，允許給空指針加上或減去一個值為0 的整型常量表達式。兩個空指針也循序彼此相減，結果當然是0。

指針同時有解引和其他運算的時候最好加上括號標明運算順序

標準庫類型限定使用的下標必須是無符號類型，而內置的下表運算無此要求

盡管C++支持C風格字符串，但在C++程序中最好還是不要使用他們，這是因為C風格字符串不僅使用起來不太方便，而且極容易引發程序漏洞，是諸多安全問題的根本原因。

C風格字符串存放在字符數組中并以空字符結束。

在頭文件cstring中有一些操作C風格字符串的函數：

strlen(p)		返回p的長度
strcmp(p1, p2)	比較p1和p2，如果p1==p2，返回0，如果p1<p2，返回負數，否則返回正數
strcat(p1, p2)	將p2附加到p1之后，返回p1
strcpy(p1, p2)	將p2拷貝給p1，返回p1

傳入此類函數的指針必須指向以空字符作為結束的數組

任何出現字符串字面值的地方都可以用以空字符結束的字符數組來替代：

• 允許使用以空字符結束的字符數組來初始化string對象或為string對象賦值
• 在string對象的加法運算中允許使用以空字符結束的字符數組作為其中一個運算對象（不能兩個對象都是），在string對象的復合賦值運算中允許使用以空白字符結尾的字符數組作為右側的運算對象

string對象的成員函數c_str()返回值是一個C風格的字符串，也就是說，函數的返回值是一個指針， 該指針指向一個以空字符結束的字符數組，而這個數組所存的數據恰好與那個string對象一樣。結果指針的類型是const char*，從而確保我們不會改變字符數組的內容。我們無法保證c_str()函數返回的數組一直有效，事實上，如果后續的操作改變了s的值就可能讓之前返回的數組失去作用。如果執行完c_str()函數后程序想一直都能使用其返回的字符數組，最好將該數組重新拷貝一份。

const char *str = s.c_str();	

允許使用數組來初始化vector對象，只需要指明拷貝區域的首元素地址和尾后地址即可。

int int_arr[] = {0, 1, 2, 3};
vector<int> a(begin(int_arr), end(int_arr));	

現代的C++程序應當盡量使用vector和迭代器，避免使用內置數組和指針；應該盡量使用string，避免使用C風格的基于數組的字符串

C++語言中沒有多維數組，通常所說的多維數組其實是數組的數組。

多維數組的初始化

int ia[3][4] = {{0, 1, 2, 3}.{4, 5, 6, 7},{8, 9, 10, 11}
};
int ia[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int ia[3][4] = { {0}, {4}, {8} };	只初始化每行的首元素，其他未列出的元素執行默認初始化
int ia[3][4] = {0, 3, 6, 9};	只初始化第一行的元素，其他的初始化為0	

多維數組的操作：

int (&row)[4] = ia[1];	//把row綁定到ia的第二個4元素數組上
int cnt = 0;
for (auto &row : ia) {for( auto &col : row) {col = cnt++;}
}	

注意：要使用范圍for循環處理多維數組，除了最內層的循環外，其他所有循環控制變量都應該是引用類型。如果不是引用類型，編譯器的會把數組類型轉化成指針類型，這樣內層循環就無法使用范圍for語句了，因為對一個指針進行循環顯然沒有意義。

當程序使用多維數組的名字時，也會自動將其轉換成指向數組首元素的指針。因為多維數組實際上是數組的數組，所以由多維數組名轉換得來的指針實際上是指向第一個內層數組的指針。

int ia[3][4]
int (*p)[4] = ia;	//p指向含有4個整數的數組ia[0]
p = &ia[2];			//p指向ia的尾元素ia[2]	

上面的括號必不可少，如果沒有括號，int *p[4]的意義將會是大小為4的整型指針數組

隨著C++11新標準的提出，通過使用auto或者decltype就能盡可能避免在數組前面加上一個指針類型了。

int a[3][4];
for (auto p = ia; p != ia + 3; ++p) {
//int (*p)[4]for (auto q = *p; q != p + 4; ++q) {//int *qcout << *q << ' ';}cout << endl;
}	

可以使用標準庫函數begin和end實現同樣的功能：

for (auto p = begin(ia); p != end(ia); ++p) {for (auto q = begin(*p); q != end(*p); ++q) {cout << *q << ' ';}cout << endl;
}	

可以使用類型別名簡化多維數組的指針

using int_arr = int[4];
typedef int int_arr[4];	//同上面等價+	

第三章看完啦，啦啦啦啦，后面要稍微加快進度