可以關(guān)注 微 信 公 眾 號  “C和C加加”  回復 “ZXC” 即可獲取 詳細教程 和 PDF版,！

二、基本語法

• 對象-對象具有狀態(tài)的行為,。對象是類的實例,。
• 類-類可以定義為對象行為,、狀態(tài)的模版。
• 方法-從基本上講,，一個方法表示一種行為,，一個類可以包含多種方法。
• 變量

1,、注釋

2,、關(guān)鍵字

3、標識符

標識符是用來標識變量,、函數(shù),、類、模塊,，或任何其他用戶自定義項目的名稱,。一個標識符以字母 A-Z 或 a-z 或下劃線 _ 開始，后跟零個或多個字母,、下劃線和數(shù)字（0-9）,。

標識符內(nèi)不允許出現(xiàn)標點字符，比如 @,、& 和 %,。C++ 是區(qū)分大小寫的編程語言。

三,、數(shù)據(jù)類型

1,、第一個C++程序

 2、基本數(shù)據(jù)類型

七種基本的C++數(shù)據(jù)類型：bool,、char,、int、float,、double,、void、wchar_t

類型修飾符：signed,、unsigned,、short、long

注：一些基本類型可以使用一個或多個類型修飾符進行修飾,，比如：signed short int簡寫為short,、signed long int 簡寫為long。

3,、數(shù)據(jù)類型在不同系統(tǒng)中所占空間大小

 這個與機器,、操作系統(tǒng)、編譯器有關(guān)。比如同樣是在32bits的操作系統(tǒng)系,，VC++的編譯器下int類型為占4個字節(jié),；而tuborC下則是2個字節(jié)。

原因：

c/c++規(guī)定int字長和機器字長相同

操作系統(tǒng)字長和機器字長未必一致

編譯器根據(jù)操作系統(tǒng)字長來定義int字長

4,、typedef聲明

5,、枚舉類型

C++中的一種派生數(shù)據(jù)類型，它是由用戶定義的若干枚舉常量的集合,；枚舉元素是一個整型,，枚舉型可以隱式的轉(zhuǎn)換為int型，int型不能隱式的轉(zhuǎn)換為枚舉型,。

如果枚舉沒有初始化, 即省掉"=整型常數(shù)"時, 則從第一個標識符開始;

默認情況下,，第一個名稱的值為 0，第二個名稱的值為 1,，第三個名稱的值為 2,，以此類推。但是,，您也可以給名稱賦予一個特殊的值,，只需要添加一個初始值即可。

例如：

6 ,、常量及符號

（1）整型常量

整型常量可以分為有符號整型常量和無符號整型常量

八進制：以0開頭,，即以0作為八進制數(shù)的前綴，每位取值范圍是0~7,，八進制數(shù)通常是無符號數(shù)。

例如：016,、0101,、0128都是合法的八進制數(shù)
十六進制：以0x或者0X開頭，其數(shù)碼取值范圍0 ~ 9,，以及A ~ F或者a ~ f

例如：0X2A1,、0XC5、0XFFFF都是合法的16進制數(shù)

（2）實型常量

小數(shù)表示法：由整數(shù)部分和小數(shù)部分組成,，整數(shù)部分和小數(shù)部分每位取值范圍是0~9,，例如：0.0、3.25,、0.00596,、2.0
指數(shù)表示法：指數(shù)部分以符號"e"或者"E"開始，但必須是整數(shù),，并且符號"e"或"E"兩邊都必須有一個數(shù),，例如：1.2e20和-3.4e-2

（3）字符常量

字符常量是單引號括起來的字符，例如：'a'和'?'都是合法字符常量。字符'a'的ASCII碼值是97,，字符'A'的ASCII碼值是41,，字符'?'的ASCII碼值是63

轉(zhuǎn)義字符是特殊的字符常量，使用時以字符串’'代表開始轉(zhuǎn)義,，和后面不同的字符表示轉(zhuǎn)義的字符,。轉(zhuǎn)義字符表如下所示：

 （4）字符串常量

是由一對雙引號括起來的零個或多個字符序列，例如：“welcome to our school”,、“hello world”,。""可以表示一個空字符串。

字符常量’A’和字符串常量"A"是不同的,，字符串常量"A"是由'A'和'\0'兩個字符組成的,，字符串長度是2，字符串常量'A'只是一個字符,，沒有長度,。

（5）其他常量

• 布爾常量：布爾常量只有兩個，一個是true,，表示真,；另一個是false，表示假,。
• 枚舉常量：枚舉型數(shù)據(jù)中定義的成員也是常量,，這將在后文介紹。
• 宏定義常量：通過#define宏定義的一些值也是常量,。例如：define PI3.1415,。其中PI就是常量。

7,、變量

變量其實只不過是程序可操作的存儲區(qū)的名稱,。C++ 中每個變量都有指定的類型，類型決定了變量存儲的大小和布局,，該范圍內(nèi)的值都可以存儲在內(nèi)存中,，運算符可應用于變量上。

（1）標識符：是用來對C++程序中的常量,、變量,、語句標號以及用戶自定義函數(shù)的名稱進行標識的符號。
標識符命名規(guī)則：

• 有字母,、數(shù)字及下劃線組成,，且不能以數(shù)字開頭。
• 大寫和小寫字母代表不同意義,。
• 不能與關(guān)鍵字同名
• 盡量“見名知義”,，應該受一定規(guī)則的約束,。
• 不合法的標識符：6A、ABC*,、case（保留字）

c++保留關(guān)鍵字,，如圖所示：

（2）變量與變量說明：變量使用前一定要定義或說明，變量聲明的一般形式如下：[修飾符] 類型 變量名標識符,；

類型是變量類型的說明符,，說明變量的數(shù)據(jù)類型。修改師傅是任選的,，可以沒有,。

 （3）整型變量：整型變量可以分為短整型、整型和長整型,，變量類型說明符分別是short,、int、long,。根據(jù)是否有符號還可分為以下6種,。

• 整型 [signed] int
• 無符號整型 unsigned [int]
• 有符號短整型 [signed] short [int]
• 無符號短整型 unsigned short [int]
• 有符號長整型 [signed] long [int]
• 無符號長整型 unsigned long [int]

 （4）實型變量：又稱為浮點型變量，變量可分為單精度（float）,、雙精度（double）和長雙精度（long double）三種,。

（5）變量賦值：變量值是動態(tài)改變的，每次改變都需要進行賦值運算,。變量賦值的形式如下：變量名標識符 = 表達式,，例如：

 （6）變量賦初值：可以在聲明變量的時候就把數(shù)據(jù)賦給變量，這個過程叫變量賦初值,，賦初值的情況有以下幾種：

• int x=5;：表示定義x為有符號的基本整型變量,，賦初值為5
• int x，y,，z=6;：表示定義x,、y、z為有符號的基本整型變量,，z賦初值為6
• int x=3，y=3,，z=3;：表示定義x,、y、z為有符號的基本整型變量,，且賦予的初值均為3

（7）字符變量：

• 一個字符類型,，即可以字符形式輸出，也可以整數(shù)類型輸出：

• 允許對字符數(shù)據(jù)進行算術(shù)運算,，此時就是對它們的ASCII碼值進行算術(shù)運算： 

（8）變量的作用域

局部變量：在函數(shù)或一個代碼塊內(nèi)部聲明的變量,，稱為局部變量。它們只能被函數(shù)內(nèi)部或者代碼塊內(nèi)部的語句使用。
全局變量：在所有函數(shù)外部定義的變量（通常是在程序的頭部）,，稱為全局變量,。全局變量的值在程序的整個生命周期內(nèi)都是有效的。

局部變量和全局變量的名稱可以相同,，但是在函數(shù)內(nèi),，局部變量的值會覆蓋全局變量的值。
當局部變量被定義時,，系統(tǒng)不會對其初始化,；定義全局變量時，系統(tǒng)會自動初始化值：int float double 0,，char ’\0',，指針 NULL

8、自定義數(shù)據(jù)類型

（1）結(jié)構(gòu)體

結(jié)構(gòu)體可以包含不同數(shù)據(jù)類型的結(jié)構(gòu),。

定義結(jié)構(gòu)體的一般形式

結(jié)構(gòu)體變量名的定義和初始化：

//定義結(jié)構(gòu)體同時聲明結(jié)構(gòu)體變量名
struct 結(jié)構(gòu)體類型名
{
	成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
}變量名1,變量名2,...變量名n;
//先定義結(jié)構(gòu)體
[struct] 結(jié)構(gòu)體類型名 變量名;
//直接定義
struct 
{
	成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
}變量名1,變量名2,...變量名n;
struct  person
{
	int year;
	int age;
	string name;
}p1 = {2019,24,"heiren"}, p1 = { 2020,24,"heiren" };
struct  person
{
	int year;
	int age;
	string name;
};
struct person p1 = { 2019,24,"heiren" }, p1 = { 2020,24,"heiren" };
struct 
{
	int year;
	int age;
	string name;
}p1 = {2019,24,"heiren"}, p1 = { 2020,24,"heiren" };

結(jié)構(gòu)體變量的使用：

• 具有相同類型的結(jié)構(gòu)體變量可以進行賦值運算,，但是不能輸入輸出
• 對結(jié)構(gòu)體變量的成員引用：結(jié)構(gòu)體變量名.成員名
• 指向結(jié)構(gòu)體的指針變量引用格式：指針變量名->成員名;
  結(jié)構(gòu)體數(shù)組的定義，初始化和使用與結(jié)構(gòu)體變量,、基本類型數(shù)組相似

struct person
{
	int year;
	int age;
	string name;
}p[2] ={ {2019,24,"heiren"}, { 2020,24,"heiren" }};//可以不指定數(shù)組元素個數(shù)
p[1].age;

結(jié)構(gòu)體作為函數(shù)傳遞有三種：值傳遞,，引用傳遞，指針傳遞

結(jié)構(gòu)體大小和字節(jié)對齊
    現(xiàn)代計算機中內(nèi)存空間都是按照byte劃分的,，從理論上講似乎對任何類型的變量的訪問可以從任何地址開始,，但實際情況是在訪問特定類型變量的時候經(jīng)常在特 定的內(nèi)存地址訪問，這就需要各種類型數(shù)據(jù)按照一定的規(guī)則在空間上排列,，而不是順序的一個接一個的排放,，這就是對齊.
    為什么需要字節(jié)對齊？各個硬件平臺對存儲空間的處理上有很大的不同,。一些平臺對某些特定類型的數(shù)據(jù)只能從某些特定地址開始存取,。比如有些平臺每次讀都是從偶地址開始，如果一個int型（假設為32位系統(tǒng)）如果存放在偶地址開始的地方,，那么一個讀周期就可以讀出這32bit,，而如果存放在奇地址開始的地方，就需要2個讀周期,，并對兩次讀出的結(jié)果的高低字節(jié)進行拼湊才能得到該32bit數(shù)據(jù),。
三個個概念：

自身對齊值：數(shù)據(jù)類型本身的對齊值，結(jié)構(gòu)體或類的的自身對齊值是其成員中最大的那個值,，例如char類型的自身對齊值是1,，short類型是2；
指定對齊值：編譯器或程序員指定的對齊值,，32位單片機的指定對齊值默認是4,；
有效對齊值：自身對齊值和指定對齊值中較小的那個,。
字節(jié)對齊的三個準則
結(jié)構(gòu)體變量的首地址能夠被其有效對齊值的大小所整除
結(jié)構(gòu)體的總大小為結(jié)構(gòu)體有效對齊值的整數(shù)倍。
結(jié)構(gòu)體每個成員相對于結(jié)構(gòu)體首地址的偏移量都是有效對齊值的整數(shù)倍,。
可以通過#pragma pack(n)來設定變量以n字節(jié)對齊方式

 （2）公用體(union)

幾個不同的變量共享同一個地址開始的內(nèi)存空間,。

成員類型可以是基本數(shù)據(jù)類型，也可以是構(gòu)造數(shù)據(jù)類型,。
公用體變量初始化時,，只能對第一個成員賦值。
公用體變量所占的內(nèi)存長度等于最長的成員長度,。
公用體變量在一個時刻只能一個成員發(fā)揮作用,，賦值時，成員之間會互相覆蓋,，最后一次被賦值的成員起作用,。
定義：

union 共同體類型名
{
    成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
};

初始化

union data
{
	int i;
	float f;
	char c;
}x = {123};
union data
{
	float f;
	int i;
	char c;
};
data x = {12.3};
union 
{
	char c;
	int i;
	float f;
}x = {’y'};

引用

共同體變量名.成員名;
union data
{
	int i;
	float f;
	char c;
}x = {12};
int main()
{
	cout << x.i << " " << x.f << " " << x.c << endl;//12 1.68156e-44 
	x.c = 'c';
	cout << x.i <<" "<< x.f << " " << x.c << endl;//99 1.38729e-43 c
	return 0;
}

9、數(shù)據(jù)輸入與輸出

（1）控制臺屏幕

（2）操作控制

在頭文件iomanip.h中定義了一些控制流輸出格式的函數(shù),，默認情況下整型數(shù)按十進制形式輸出,，也可以通過hex將其設置為十六進制輸出。流操作的控制具體函數(shù)如下

 四,、運算符與表達式

1,、運算符

（1）算術(shù)運算符：算術(shù)運算主要指常用的加（+）、減（-）,、乘(*),、除（/）四則運算，算術(shù)運算符中有單目運算符和雙目運算符,。

（2）關(guān)系運算符

關(guān)系運算符主要是對兩個對象進行比較,，運算結(jié)果是邏輯常量真或假。 

（3）邏輯運算符

邏輯運算符是對真和假這兩種邏輯值進行運算,，運算后的結(jié)果仍是一個邏輯值

（4）賦值運算符

（5）位運算符

 （6）移位運算符

 （7）sizeof運算符

（8）條件運算符 

（9）逗號運算符 

 （10）運算符優(yōu)先級

（11） 運算符重載

所謂重載,，就是賦予新的含義。函數(shù)重載（Function Overloading）可以讓一個函數(shù)名有多種功能,，在不同情況下進行不同的操作,。運算符重載（Operator Overloading）也是一個道理，同一個運算符可以有不同的功能。

運算符重載是通過函數(shù)實現(xiàn)的，它本質(zhì)上是函數(shù)重載。
允許重載的運算符

不允許重載的運算符

重載運算符遵循的規(guī)則：

• 不可以自己定義新的運算符,，只能對已有的C++運算符重載。
• 不能改變運算符運算對象的個數(shù)。
• 不能改變運算符的優(yōu)先級和結(jié)合性
• 應與標準類型運算功能相似，避免影響可讀性。

一般格式：

函數(shù)類型 operator運算符(參數(shù)列表)
{
	函數(shù)體
}
//舉個栗子：定義一個向量類，通過運算符重載，可以用+進行運算。
class Vector3
{
public:
	Vector3();
	Vector3(double x,double y,double z);
public:
	Vector3 operator+(const Vector3 &A)const;
	void display()const;
private:
	double m_x;
	double m_y;
	double m_z;
};
Vector3::Vector3() :m_x(0.0), m_y(0.0), m_z(0.0) {}
Vector3::Vector3(double x, double y,double z) : m_x(x), m_y(y), m_z(z) {}
//運算符重載
Vector3 Vector3::operator+(const Vector3 &A) const
{
	Vector3 B;
	B.m_x = this->m_x + A.m_x;
	B.m_y = this->m_y + A.m_y;
	B.m_z = this->m_z + A.m_z;
	return B;
}
void  Vector3::display()const
{
	cout<<"(" << m_x << "," << m_y << "," << m_z << ")" << endl;
}

 運算符重載的形式有兩種：重載函數(shù)作為類的成員,，重載函數(shù)作為類的友元函數(shù)
根據(jù)運算符操作數(shù)的不同：雙目運算符作為類成員函數(shù)，單目運算符作為類的成員函數(shù),，雙目運算符作為類的友員函數(shù),，單目運算符作為類的友元函數(shù),。

雙目運算符作為友元函數(shù)時需要制定兩個參數(shù),。
運算符重載函數(shù)作為類成員函數(shù)可以顯式調(diào)用。

常用運算符的重載

• 自增自減
• 賦值運算符
• 輸入\輸出運算符重載

2,、表達式

（1）算數(shù)表達式

（2）關(guān)系表達式

（3）條件表達式 

（4）賦值表達式

（5）邏輯表達式 

（6） 逗號表達式

五,、語法結(jié)構(gòu)

1,、while循環(huán)

while(conditon)//0為false,非0為true
{
	statement(s);
}

2、do…while循環(huán)

 3,、while與do…while比較

 4,、for

for(init;conditon;increment)//0為false,非0或什么也不寫為true
{
	statement(s);
}

• init首先被執(zhí)，且只會執(zhí)行一次,，也可以不寫任何語句。
• 然后會判斷conditon,true執(zhí)行循環(huán)主體,，false跳過循環(huán)
• 執(zhí)行完循環(huán)主體，執(zhí)行increment,跳到2

int array[5] = { 11, 22, 33, 44, 55 };
for (int x : array)
{
	cout << x << " ";
}
cout << endl;
// auto 類型也是 C++11 新標準中的,，用來自動獲取變量的類型
for (auto x : array)
{
	cout << x << " ";
}

• for each
  STL中的for增強循環(huán)。

int a[4] = { 4,3,2,1 };
for each (int var in a)
{
	cout << var << " ";
}

5,、判斷結(jié)構(gòu)

• if

if(expr)
{
	statement;//如果expr為true將執(zhí)行的語句塊 
}
if(expr)
{
   statement1;// 如果expr為true將執(zhí)行的語句塊
}
else
{
   statement2;// 如果expr為false將執(zhí)行的語句
}
if(expr1)
{
   statement1;// 如果expr1為true將執(zhí)行的語句塊
}
elseif(expr2)
{
   statement2;// 如果expr2為true將執(zhí)行的語句塊
}
...
else
{
	statementElse;// 當上面的表達式都為false執(zhí)行的語句塊
}

• switch

switch(expression){
    case constant-expression  :
       statement(s);
       break; 
    case constant-expression  :
       statement(s);
       break; 
    // 您可以有任意數(shù)量的 case 語句
    default : // 可選的
       statement(s);
}

每個case后滿的常量表達式必須各不相同,。
case語句和default語句出現(xiàn)的順序?qū)?zhí)行結(jié)果沒有影響。
若case后沒有break,執(zhí)行完就不會判斷,，繼續(xù)執(zhí)行下一個case語句,。直到遇到brerak。
default后面如果沒有case,，則break可以省略
多個case可以用一組執(zhí)行語句

char c = 'A';
	switch (c)
	{
	case 'A':
	case 'B':
	case 'C':
		cout << "及格了" << endl;
		break;
	default:
		cout << "不及格" << endl;
	}

6,、循環(huán)控制

7、循環(huán)嵌套 

 8,、三元運算符

//如果 Exp1 為真,，則計算 Exp2 的值,，結(jié)果即為整個 ? 表達式的值。如果 Exp1 為假,，則計算 Exp3 的值,，結(jié)果即為整個 ? 表達式的值
Exp1 ? Exp2 : Exp3;

9、預處理命令

預處理程序（刪除程序注釋,，執(zhí)行預處理命令等）–>編譯器編譯源程序

• 宏定義：#define 標識符 字符串
• 文件包含：#include<filename> 或者#include“filename”
• 條件編譯

//如果標識符被#define定義過,，執(zhí)行程序段1，否則執(zhí)行程序段2
#ifdef 標識符
	程序段1
#else
	程序段2
#endif
//如果標識符沒有被#define定義過,，執(zhí)行程序段1,，否則執(zhí)行程序段2
#ifndef 標識符
	程序段1
#else
	程序段2
#endif
//如果表達式為true，執(zhí)行程序段1,，否則執(zhí)行程序段2
#if 表達式
	程序段1
#else
	程序段2
#endif

六,、數(shù)組和指針

1、一維數(shù)組

 初始化的形式：數(shù)據(jù)類型 數(shù)組名[常量表達式] = {初值表};
為數(shù)組的某一個元素賦值：數(shù)組名[下標] =值(下標從0開始)
數(shù)組的引用：數(shù)組名[下標]

• 初始化數(shù)組時,，可以只給部分數(shù)組元素賦值
• 對全部元素數(shù)組賦值時,，可以不指定數(shù)組長度，編譯系統(tǒng)會根據(jù)初值個數(shù)確定數(shù)組的長度,。
• static型數(shù)組元素不賦初值，系統(tǒng)會自動默認為0,。

2,、二維數(shù)組

定義一維數(shù)組的形式：數(shù)據(jù)類型 數(shù)據(jù)名[常量表達式1][常量表達式2]
初始化的形式：數(shù)據(jù)類型 數(shù)組名[常量表達式1] [常量表達式2]= {初值表};
為數(shù)組的某一個元素賦值：數(shù)組名[行下標][列下標] =值(下標從0開始)
數(shù)組的引用：數(shù)組名[行下標][列下標]

將所有數(shù)據(jù)寫在一個花括號內(nèi)，自動按照數(shù)組元素個數(shù)在內(nèi)存中排列的順序賦值
可對部分元素賦值,，其余元素的值自動取0.
定義初始化數(shù)組時,，可以省略第一維的長度，第二維不能省,，系統(tǒng)會自動確認行數(shù)

3,、字符數(shù)組

char類型的數(shù)組，在字符數(shù)組中最后一位為’\0’）時,，可以看成時字符串,。在C++中定義了string類，在Visual C++中定義了Cstring類,。
字符串中每一個字符占用一個字節(jié),，再加上最后一個空字符。

4,、指針

指針是一個變量,，其值為另一個變量的地址。即內(nèi)存位置的直接地址,。
聲明的一般形式：

• 數(shù)據(jù)類型是指針變量所指向的變量的數(shù)據(jù)類型,，*表示其后的變量為指針變量

數(shù)據(jù)類型 *指針變量名;
int    *ip;    //整型的指針 
double *dp;    //double 型的指針 
float  *fp;    //浮點型的指針 
char   *ch;    //字符型的指針 

指針變量的初始化：

• &是取地址運算符,，&變量名表示變量的地址。
• 變量的數(shù)據(jù)類型必須于指針變量的數(shù)據(jù)類型一致,。
• 為了安全起見,，有時會把指針初始化為空指針（NULL或0）

數(shù)據(jù)類型 *指針變量名 = &變量名;
*指針變量名 = &變量名;
int a;
int *p = &a;
int *p2;
p2 = &a;

指針變量的引用：

• & 取地址符 * 指針運算符（間接運算符），其后是指針變量,，表示該指針變量所指向的變量,。
• & *的優(yōu)先級是相同的，結(jié)合方式都是自左向右,。比如 &*p等價于&(*p),。

int x = 3;
int y;
int *p;
p = &x;
y = *p;//y = a

指針運算（地址運算）

算術(shù)運算（移動指針運算）：加減，自增自減,。
p+n運算得到的地址是p+n*sizeof(數(shù)據(jù)類型),。
兩個相同數(shù)據(jù)類型的指針可以進行加減運算，一般用于數(shù)組的操作中,。
關(guān)系運算：指針指向同一串連續(xù)存儲單元才有意義,，比如數(shù)組。與0比較,，判斷是不是空指針,。
賦值運算：變量地址賦值給指針變量，數(shù)組元素地址賦值給指針變量,，指針變量賦值給其他指針變量,。

int arr[10],len;
int *p1 = &arr[2],*p2 = &arr[5];
 len = p2-p1;//arr[2] 和arr[5]之間的元素個數(shù) 3

new和delete運算符

• new-為變量分配內(nèi)存空間；
• 可以通過判斷new返回的指針的值,，判斷空間是否分配成功,。
• delete-釋放空間

指針變量 = new 數(shù)據(jù)類型(初值);
delete 指針變量;
delete[] 指針變量;//釋放為多個變量分配的地址
int *ip;
ip= new int(1);
delete ip;
int *ip;
 ip= new int[10];
 for (int i = 0; i < 10;i++)
 {
	 ip[i] = i;
 }
 delete[] ip;
int a[3][4] = {0};

5、指針與數(shù)組

6,、數(shù)組與new(動態(tài)創(chuàng)建數(shù)組) 

一維數(shù)組

int* arr1 = new int[2];//delete []arr1;
int* arr2 = new int[3]{ 1,2 };//delete []arr2

二維數(shù)組

int m=2, n=3;
int** arr3 = new int*[2];//delete []arr3
for (int i = 0; i < 10; ++i)
{ 
	arr3[i] = new int[3]; // delete []arr3[i]
}
int* arr4 = new int[m*n];//數(shù)據(jù)按行存儲 delete []arr3

7,、指針與字符串

• 字符串數(shù)組名：char ch[] = "heiren";char *p = ch;
• 字符串：char *p = "heiren";
• 指針賦值運算：char * p;p = "Heiren";
  指針與函數(shù)，指針可以作為函數(shù)的參數(shù),，也可以作為函數(shù)的返回值,。

8、指向函數(shù)的指針

 9,、引用

引用可以看做是數(shù)據(jù)的一個別名,，通過這個別名和原來的名字都能夠找到這份數(shù)據(jù)，類似于window中的快捷方式,。

引用不占內(nèi)存空間,，必須在定義的同時初始化，且不能再引用其他數(shù)據(jù),。
引用在定義時需要添加&,，在使用時不能添加&,，使用時添加&表示取地址
引用型變量聲明：數(shù)據(jù)類型 &引用名 = 變量名;

int a;
int &b = a;//a和b表示相同的變量，具有相同的地址,。

引用可以作為函數(shù)參數(shù),，也可以作為函數(shù)返回值。

void swap(int &r1, int &r2) {
    int temp = r1;
    r1 = r2;
    r2 = temp;
}
int &add1(int &r) {
	r += 1;
	return r;
}
int main()
{
	int a = 12;
	int b = add1(a);
	cout << a << "   "<<b << endl;//13  13
	return 0;
}

將引用作為函數(shù)返回值時不能返回局部數(shù)據(jù)的引用,，因為當函數(shù)調(diào)用完成后局部數(shù)據(jù)就會被銷毀,。
函數(shù)在棧上運行，函數(shù)掉用完,，后面的函數(shù)調(diào)用會覆蓋之前函數(shù)的局部數(shù)據(jù),。

int &add1(int &r) {
	r += 1;
	int res = r;
	return res;
}
void test()
{
	int xx = 123;
	int yy = 66;
}
int main()
{
	int a = 12;
	int &b = add1(a);
	int &c = add1(a);
	test();//函數(shù)調(diào)用，覆蓋之前函數(shù)的局部數(shù)據(jù)
	cout << a << "   "<<b <<" "<< c<<endl;//14   -858993460 -858993460
	return 0;
}

七,、函數(shù)

1,、函數(shù)聲明與定義

• 函數(shù)類型-函數(shù)的返回值類型；函數(shù)名-必須符合C++標識符命名規(guī)則,，后面必須跟一對括號,；函數(shù)體-實現(xiàn)函數(shù)功能的主題部分；參數(shù)列表-函數(shù)名后面的括號內(nèi),，用于向函數(shù)傳遞數(shù)值或帶回數(shù)值,。
• 函數(shù)聲明中，參數(shù)名可以省略,，參數(shù)類型和函數(shù)的類型不能省略,。
• 函數(shù)聲明可以放在主調(diào)函數(shù)內(nèi)部，放在調(diào)用語句之前,；也可以放在主調(diào)函數(shù)外，如果位于所有定義函數(shù)之前,，后面函數(shù)定義順序任意,，各個主調(diào)函數(shù)調(diào)用也不必再做聲明
• 當函數(shù)定義在前，函數(shù)調(diào)用災后,，可以不用函數(shù)聲明,。

后兩條總結(jié)一下就是：調(diào)用函數(shù)前，程序得知道有這個函數(shù),，聲明就是提前讓程序知道有這么的玩意

函數(shù)聲明：

函數(shù)類型 函數(shù)名(參數(shù)列表);
eg:
int max(int a,int b);//聲明函數(shù)時,，a,b可以省略
int max(int,int);
void show();

函數(shù)定義：

函數(shù)類型 函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
eg:
int max(int a,int b)
{
	int z;
	z = a>b?a:b;
	return z;
}

2、函數(shù)參數(shù)以及返回值

• 形參：函數(shù)定義后面括號里的參數(shù),，函數(shù)調(diào)用前不占內(nèi)存,。
• 實參：函數(shù)調(diào)用括號里的參數(shù)，可以是常量,，變量或表達式等,。

形參和實參必須個數(shù)相同,、類型一致，順序一致,，函數(shù)傳遞方式：傳值,，指針，引用

 3,、函數(shù)調(diào)用

• 函數(shù)可以單獨作為一個語句使用,。有返回值的函數(shù)，可將函數(shù)調(diào)用作為語句的一部分,，利用返回值參與運算,。
  函數(shù)調(diào)用形式：參數(shù)傳遞–>函數(shù)體執(zhí)行–>返回主調(diào)函數(shù)

函數(shù)名(實參列表);
show();

 函數(shù)的嵌套調(diào)用：

int a()
{
	return 666;
}
int b(int sum)
{
	return sum+a()
}
int main()
{
	cout<<b(222)<<endl;//888
	return 0;
}

 函數(shù)的遞歸調(diào)用：直接遞歸調(diào)用和間接遞歸調(diào)用

• 一個函數(shù)直接或間接遞歸調(diào)用該函數(shù)本身，稱為函數(shù)的遞歸調(diào)用
• 遞歸和回歸：原問題=>子問題 子問題的解=>原問題的解

//直接遞歸調(diào)用：求1+...n的值
int total(int sum)
{
	if (sum == 1)
	{
		return 1;
	}
	return sum + total(sum - 1);
}
int main()
{
	cout << "total = " << total(10) << endl;//total = 55
	system("pause");
	return 0;
}
//間接遞歸調(diào)用
int f2();
int f1()
{
...
  f2()
}
int f2()
{
	f1();
}

4,、重載函數(shù)

5,、內(nèi)聯(lián)函數(shù)

八、字符串(string)

1,、字符串的定義和初始化

//定義
string 變量;
string str1;
//賦值
string str2 = "ShangHai";
string str3 = str2;
str3[3] = '2';//對某個字符賦值
//字符串數(shù)組
string 數(shù)組名[常量表達式]
string arr[3];

2,、字符串的處理函數(shù)

#include <iostream>
#include <algorithm>
#include <string>
string str;//生成空字符串
string s(str);//生成字符串為str的復制品
string s(str, strbegin,strlen);//將字符串str中從下標strbegin開始、長度為strlen的部分作為字符串初值
string s(cstr, char_len);//以C_string類型cstr的前char_len個字符串作為字符串s的初值
string s(num ,c);//生成num個c字符的字符串
string s(str, stridx);//將字符串str中從下標stridx開始到字符串結(jié)束的位置作為字符串初值
size()和length();//返回string對象的字符個數(shù)
max_size();//返回string對象最多包含的字符數(shù),，超出會拋出length_error異常
capacity();//重新分配內(nèi)存之前,，string對象能包含的最大字符數(shù)
>,>=,<,<=,==,!=//支持string與C-string的比較(如 str<”hello”)。  使用>,>=,<,<=這些操作符的時候是根據(jù)“當前字符特性”將字符按字典順序進行逐一得 比較,，string (“aaaa”) <string(aaaaa),。    
compare();//支持多參數(shù)處理，支持用索引值和長度定位子串來進行比較,。返回一個整數(shù)來表示比較結(jié)果,，返回值意義如下：0：相等 1：大于 -1：
push_back() 
insert( size_type index, size_type count, CharT ch );//在index位置插入count個字符ch
insert( size_type index, const CharT* s );//index位置插入一個常量字符串
insert( size_type index, const CharT* s, size_type n);//index位置插入常量字符串
insert( size_type index, const basic_string& str );//index位置插入常量string中的n個字符
insert( size_type index, const basic_string& str, size_type index_str, size_type n);//index位置插入常量str的從index_str開始的n個字符
insert( size_type index, const basic_string& str,size_type index_str, size_type count = npos);//index位置插入常量str從index_str開始的count個字符，count可以表示的最大值為npos.這個函數(shù)不構(gòu)成重載 npos表示一個常數(shù),，表示size_t的最大值,，string的find函數(shù)如果未找到指定字符，返回的就是一個npos
iterator insert( iterator pos, CharT ch );
iterator insert( const_iterator pos, CharT ch );
void insert( iterator pos, size_type n, CharT ch );//迭代器指向的pos位置插入n個字符ch
iterator insert( const_iterator pos, size_type count, CharT ch );//迭代器指向的pos位置插入count個字符ch
void insert( iterator pos, InputIt first, InputIt last );
iterator insert( const_iterator pos, InputIt first, InputIt last );
append() 和 + 操作符
//訪問string每個字符串
string s1("yuanrui"); // 調(diào)用一次構(gòu)造函數(shù)
// 方法一： 下標法
for( int i = 0; i < s1.size() ; i++ )
     cout<<s1[i];
// 方法二：正向迭代器
for( string::iterator iter = s1.begin();; iter < s1.end() ; iter++)
     cout<<*iter;
 // 方法三：反向迭代器
for(string::reverse_iterator riter = s1.rbegin(); ; riter < s1.rend() ; riter++)
     cout<<*riter;
 iterator erase(iterator p);//刪除字符串中p所指的字符
iterator erase(iterator first, iterator last);//刪除字符串中迭代器區(qū)間[first,last)上所有字符
string& erase(size_t pos = 0, size_t len = npos);//刪除字符串中從索引位置pos開始的len個字符
void clear();//刪除字符串中所有字符
string& replace(size_t pos, size_t n, const char *s);//將當前字符串從pos索引開始的n個字符,，替換成字符串s
string& replace(size_t pos, size_t n, size_t n1, char c); //將當前字符串從pos索引開始的n個字符,，替換成n1個字符c
string& replace(iterator i1, iterator i2, const char* s);//將當前字符串[i1,i2)區(qū)間中的字符串替換為字符串s
//tolower()和toupper()函數(shù) 或者 STL中的transform算法
string s = "ABCDEFG";
for( int i = 0; i < s.size(); i++ )
     s[i] = tolower(s[i]);
transform(s.begin(),s.end(),s.begin(),::tolower);
size_t find (constchar* s, size_t pos = 0) const;//在當前字符串的pos索引位置開始，查找子串s,，返回找到的位置索引,，-1表示查找不到子串
size_t find (charc, size_t pos = 0) const;//在當前字符串的pos索引位置開始，查找字符c,，返回找到的位置索引,，-1表示查找不到字符
size_t rfind (constchar* s, size_t pos = npos) const;//在當前字符串的pos索引位置開始，反向查找子串s,，返回找到的位置索引,，-1表示查找不到子串
size_t rfind (charc, size_t pos = npos) const;//在當前字符串的pos索引位置開始,，反向查找字符c，返回找到的位置索引,，-1表示查找不到字符
size_tfind_first_of (const char* s, size_t pos = 0) const;//在當前字符串的pos索引位置開始,，查找子串s的字符，返回找到的位置索引,，-1表示查找不到字符
size_tfind_first_not_of (const char* s, size_t pos = 0) const;//在當前字符串的pos索引位置開始,，查找第一個不位于子串s的字符，返回找到的位置索引,，-1表示查找不到字符
size_t find_last_of(const char* s, size_t pos = npos) const;//在當前字符串的pos索引位置開始,，查找最后一個位于子串s的字符，返回找到的位置索引,，-1表示查找不到字符
size_tfind_last_not_of (const char* s, size_t pos = npos) const;//在當前字符串的pos索引位置開始,，查找最后一個不位于子串s的字符，返回找到的位置索引,，-1表示查找不到子串
sort(s.begin(),s.end());
substr(pos,n);//返回字符串從下標pos開始n個字符
strtok()
char str[] = "I,am,a,student; hello world!";
const char *split = ",; !";
char *p2 = strtok(str,split);
while( p2 != NULL )
{
    cout<<p2<<endl;
    p2 = strtok(NULL,split);
}

九,、面向?qū)ο蠛皖?/strong>

class 類名
{
	public:
		公有數(shù)據(jù)成員;
		公有成員函數(shù);
	private:
		私有數(shù)據(jù)成員;
		私有成員函數(shù);
	protected:
		保護數(shù)據(jù)成員;
		保護成員函數(shù);
};

//類外
返回類型 類名:成員函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
//內(nèi)聯(lián)函數(shù)：類外
inline 返回類型 類名:成員函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}

//1.聲明類同時定義對象
class 類名
{
	類體;
}對象名列表;
//2.先聲明類，再定義對象
類名 對象名(參數(shù)列表);//參數(shù)列表為空時,，()可以不寫
//3. 不出現(xiàn)類名,，直接定義對象
class 
{
	類體;
}對象名列表;
//4.在堆上創(chuàng)建對象
Person p(123, "yar");//在棧上創(chuàng)建對象
Person *pp = new Person(234,"yar");//在堆上創(chuàng)建對象

//1.類中定義 2.類中聲明,，類外定義
[類名::]構(gòu)造函數(shù)名(參數(shù)列表)
{
	函數(shù)體
}

類名 對象名(參數(shù)列表);//參數(shù)列表為空時，()可以不寫

class Person
{
public:
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(int a, string s)
{
	cout<<a<<" "<<s<<endl;
	age = a;
	name = s;
}
void Person::show()
{
	cout << "age="<<age << endl;
	cout << "name=" <<name << endl;
}
int main()
{
     Person p; //0 張三
	Person p2(12);//12 張三
	Person p3(123, "yar");//123 yar
	return 0;
}

類名::構(gòu)造函數(shù)名(參數(shù)列表):參數(shù)初始化表
{
	函數(shù)體;
}
參數(shù)初始化列表的一般形式：
參數(shù)名1(初值1),參數(shù)名2(初值2),...,參數(shù)名n(初值n)
class Person
{
public:
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}

類名::類名(類名&對象名)
{
	函數(shù)體;
}
class Person
{
public:
	Person(Person &p);//聲明拷貝構(gòu)造函數(shù)
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(Person &p)//定義拷貝構(gòu)造函數(shù)
{
	cout << "拷貝構(gòu)造函數(shù)" << endl;
	age = 0;
	name = "ABC";
}
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
int main()
{
	Person p(123, "yar");
	Person p2(p);
	p2.show();
	return 0;
}
//輸出
123 yar
拷貝構(gòu)造函數(shù)
age=0
name=ABC

類名 *對象指針名;
對象指針 = &對象名;
//訪問對象成員
對象指針->數(shù)據(jù)成員名
對象指針->成員函數(shù)名(參數(shù)列表)
Person p(123, "yar");
Person* pp = &p;
Person* pp2 = new Person(234,"yar")
pp->show();

數(shù)據(jù)成員類型 *指針變量名 = &對象名.數(shù)據(jù)成員名;
函數(shù)類型 (類名::*指針變量名)(參數(shù)列表);
指針變量名=&類名::成員函數(shù)名;
(對象名.*指針變量名)(參數(shù)列表);
Person p(123, "yar");
void(Person::*pfun)();
pfun = &Person::show;
(p.*pfun)();

class Person
{
public:
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
void Person::show()
{
	cout << "age="<<this->age << endl;
	cout << "name=" <<this->name << endl;
}

//類內(nèi)聲明,，類外定義
class xxx
{
	static 數(shù)據(jù)類型 靜態(tài)數(shù)據(jù)成員名;
}
數(shù)據(jù)類型 類名::靜態(tài)數(shù)據(jù)成員名=初值
//訪問
類名::靜態(tài)數(shù)據(jù)成員名;
對象名.靜態(tài)數(shù)據(jù)成員名;
對象指針名->靜態(tài)數(shù)據(jù)成員名;

//1.將非成員函數(shù)聲明為友元函數(shù)
class Person
{
public:
	Person(int = 0,string = "張三");
	friend void show(Person *pper);//將show聲明為友元函數(shù)
private:
	int age;
	string name;
};
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
void show(Person *pper)
{
	cout << "age="<< pper->age << endl;
	cout << "name=" << pper->name << endl;
}
int main()
{;
	Person *pp = new Person(234,"yar");
	show(pp);
	system("pause");
	return 0;
}
//2.將其他類的成員函數(shù)聲明為友元函數(shù)
//person中的成員函數(shù)可以訪問MobilePhone中的私有成員變量
class MobilePhone;//提前聲明
//聲明Person類
class Person
{
public:
	Person(int = 0,string = "張三");
	void show(MobilePhone *mp);
private:
	int age;
	string name;
};
//聲明MobilePhone類
class MobilePhone
{
public:
	MobilePhone();
	friend void Person::show(MobilePhone *mp);
private:
	int year;
	int memory;
	string name;
};
MobilePhone::MobilePhone()
{
	year = 1;
	memory = 4;
	name = "iphone 6s";
}
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
void Person::show(MobilePhone *mp)
{
	cout << mp->year << "年  " << mp->memory << "G " << mp->name << endl;
}
int main()
{
	Person *pp = new Person(234,"yar");
	MobilePhone *mp = new MobilePhone;
	pp->show(mp);
	system("pause");
	return 0;
}

class Base
{
public:
	void show();
protected:
	int aa;
	double dd;
};
void Base::show(){
}
class Person:public Base
{
public:
	using Base::aa;//將基類的protected成員變成public
	using Base::dd;//將基類的protected成員變成public
private:
	using Base::show;//將基類的public成員變成private
	string name;
};
int main()
{
	Person *p = new Person();
	p->aa = 12;
	p->dd = 12.3;
	p->show();//出錯
	delete p;
	return 0;
}

class Base
{
public:
	Base(int, double);
	~Base();
private:
	int aa;
	double dd;
};
Base::Base(int a, double d) :aa(a), dd(d)
{
	cout << "Base Class 構(gòu)造函數(shù)!!!" << endl;
}
Base::~Base()
{
	cout << "Base Class 析構(gòu)函數(shù)!!!" << endl;
}
class Person:public Base
{
public:
	Person(int,double,string);
	~Person();
private:
	string name;
};
Person::Person(int a,double d,string str):Base(a,d),name(str)
{
	cout << "Person Class 構(gòu)造函數(shù)!!!" << endl;
}
Person::~Person()
{
	cout << "Person Class 析構(gòu)函數(shù)!!!" << endl;
}
int main()
{
	cout << "創(chuàng)建Person對象..." << endl;
	Person *p = new Person(1,2,"yar");
	cout << "刪除Person對象...." << endl;
	delete p;
	system("pause");
	return 0;
}

class  A//虛基類
{
protected:
	int a;
};
class B: virtual public A
{
protected:
	int b;
};
class C:virtual public A
{
protected:
	int c;
};
class D:public B,public C
{
protected:
	int d;
	void show()
	{
		b = 123;
		c = 23;
		a = 1;
	}
};

class  A
{
public:
	virtual void show()
	{
		cout << "A show" << endl;
	}
};
class B:  public A
{
public:
	void show()
	{
		cout << "B show" << endl;
	}
};
int main()
{
	B b;
	b.show();//B show
	A *pA = &b;
	pA->show();//B show 如果show方法前沒用virtual聲明為虛函數(shù),，這里會輸出A show
	system("pause");
	return 0;
}

int  x;
double y;
cin>>x>>y;
//輸入 22 66.0  兩個數(shù)之間可以用空格,、制表符和回車分隔數(shù)據(jù)
char str[10];
cin>>str;//hei ren  字符串中只有hei\0

ostream & seekp (int offset, int mode);
istream & seekg (int offset, int mode);
//mode有三種：ios::beg-開頭往后offset(>=0)字節(jié) ios::cur-當前往前(<=0)/后(>=0)offset字節(jié) ios::end-末尾往前(<=0)offect字節(jié)
int tellg();
int tellp();
//seekg 函數(shù)將文件讀指針定位到文件尾部,，再用 tellg 函數(shù)獲取文件讀指針的位置,，此位置即為文件長度