第一章
1.cin與count的應用<iostream>
例：
cin>>a;
cout<<"hello"<<endl;
cout<<he<<15<<endl;
cout.wtdth(10);//cout.fill("*")；
調整字段寬度的函數int width()：
a、控制符int width()將用來調整字段的寬度，因為width是成員函數，所以要通過對象來調用，比如cout.width()將顯示當前的字段寬度，默認為0，而cout.width(3)將把字段寬度設定為3。
注意C容納字段的方式為給字段分配剛好合適的寬度來容納字段，所以C中默認的字段寬度為0，以適合於所有的字段。
b、width的默認對齊方式為右對齊，即如果cout.width(12)如果字段沒有這么寬，則將在字段的左邊填以空格來達到12個字段的寬度。
c、還要注意的是width只影響他設置后的下一個輸出，再下一個字段輸出后，后繼的字段被恢復為默認值，比如cout.width(12); cout<<2<<3;則輸出2時會以12字段的寬度顯示，但顯示3時就會以默認的方式顯示了。
d、int width()調用他時將會反回上一次的字段寬度的值。
填充字符：成員函數fill()可以用來改變填充的字符，比如cout.fill(‘’)，使用填充空白部分。fill函數在設置后將一直有效，除非被重新設定。
cout<<setfill("*")<<20<<endl;
setw設置輸出長度，setfill設置如果輸出的整型不夠長用什么填充
2.注釋：
2.1
/* 這是注釋 */
/* C++ 注釋也可以
* 跨行
*/
2.2 //
3.main函數
main函數是C程序的入口函數，C標准要求main()函數的返回值類型為int。
3.1.函數內並可以不出現return語句
當main()函數的返回值為int，而函數內並沒有出現return語句時，同樣可以通過編譯並正常運行。這是因為編譯器在main()函數的末尾自動添加了return 0;的語句。所以，main()函數是C++程序經過特殊處理的函數。其他的返回值類型不是void的函數，如果沒有使用return語句，編譯器將報錯。
3.2.main()函數被稱為“入口函數”，那main()函數一定是程序中的第一個被執行的函數嗎？
考察如下程序。
#include <iostream> using namespace std; class A{ public: A(){ cout<<"In default A constructor"<<endl; } }; A b; int main() { cout<<"In main()"<<endl; return 0; } 編譯運行以上代碼輸出：
在這個程序中，先輸出的“In default constructor”，然后輸出的是“In main()”。可見，對象a的構造函數是先於main()函數執行的。實際上，所有的外部對象的構造函數都是先於main()函數執行的。如果要對類中的成員對象進行初始化，那么這些對象的構造函數也是在main()函數之前執行的。如果在這些構造函數中還調用了其他函數的話，就可以是更多的函數先於main()函數之前運行。因此main()函數不一定是C++程序的第一個被執行的函數。
3.3.main()函數可以帶參數
main()函數帶參數是用來提供用戶向程序輸入參數。main()所帶的參數有固定格式，即int main(int argc,char* argv[])，其中argc代表參數的個數，argv數組中的每一個元素則保存命令行參數內容的字符串。考察如下程序。
#include <iostream> using namespace std; int main(int argc,char* argv[]) { if(argc>1) cout<<"Hello "<<argv[1]<<endl; return 0; } 假設此程序經過編譯之后生成的main.exe，那么在控制台輸入”main.exe LVLV”，會輸出“Hello LVLV”。使用命令行參數時注意以下幾個問題。
（1）命令行輸入的程序名稱為程序的第一個參數，以上程序中argv[0]保存的是main.exe，盡管輸入的只有一個參數”LVLV”，但是參數數量argc包含了程序名稱，因此argc等於2。在其他編程語言（如C#）中，命令行參數並不包含執行文件的名字。
（2）在命令行中，空格被認為是命令行參數的分割符。也就是說，也就是說同一個參數內部不允許出現空格。如果在一個參數中出現空格，可以使用雙引號括起來。如輸入main.exe “LVLV and JF”。
4.標識符的命名規則
*一個合法的標識符只能由數字、字母、下划線、美元符號$組成，不能含有其他符號（不能有空格）
*不能以數字開頭
*嚴格區分大小寫
*關鍵字不能做標識符
第二章
1.C++數據類型
1.1基本類型（Byte ,short ，int ，long ，double float ，char ，Boolean）
整型：短整型，整型，長整型
字符型：
布爾型：
實型：浮點型，精度型
1.2指針
1.3構造類型
數組
枚舉型
結構體
共用體
類
2.bool
*只有 true,false
在底層儲存的時候Boolean類型占據一個字節，因為實際存儲的時候FALSE的底層是0，true底層是1.
布爾類型在實際開發當中非常重要，經常使用在邏輯運算和條件控制語句中。
實際上，所有非0的整數值都被編譯系統認為是true
Boolean A= false; if(A) { }
3.變量的初始化:
int a=3; int a(3); 4.++ --
"++""--"都為單目運算符
作為運算符來說"++""--"的優先級較高，高於所有算數運算符和邏輯運算符，但是使用這兩個運算符時要注意它們的運算對象只能是變量，不能是其他表達式
例:(i+j)++就是一個錯誤的表達式
5.const
const <類型說明符><常量名>=<常量值>
const int maix=255;
注意：使用const修飾的變量實際上是常量，不能被程序改變，因此在聲明時一定要進行初始化賦值。常量變量一經生成，其值不能改變，如果在以后的執行語句對常量變量進行賦值就會導致編譯錯誤！！！！！
const還可以用於修飾函數的參數，同樣也不允許出現對它們的賦值操作
6./是除，%整除取余
第三章
1.C++的控制結構p47
1.1順序結構
1.2選擇結構
if switch
1.3循環結構
for while do..while
2.p68
a.編寫計算n!的程序
#include<iostream> using namespace std; int main() { int n,i,m; cin>>n; for(i=1;i<=n;i++) m=m*i; cout<<m<<endl; return 0; } b.求1+2+3+4······+99+100的和
#include<iostream> using namespace std; int main() { int t=1; int n; for(n=1;n<=100;n++) { t=t+n; } cout<<"1到100的累加和為："<<t<<endl; return 0; } 第四章
1.數組的定義
1.1下標從0開始
int a[2][3];
例如，要聲明一個類型為 double 的包含 10 個元素的數組 balance，聲明語句如下：
double balance[10];
1.2初始化數組
在 C++ 中，您可以逐個初始化數組，也可以使用一個初始化語句，如下所示：
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0}; 大括號 { } 之間的值的數目不能大於我們在數組聲明時在方括號 [ ] 中指定的元素數目。
如果您省略掉了數組的大小，數組的大小則為初始化時元素的個數。因此，如果：
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0}; 您將創建一個數組，它與前一個實例中所創建的數組是完全相同的。下面是一個為數組中某個元素賦值的實例：
balance[4] = 50.0; 上述的語句把數組中第五個元素的值賦為 50.0。所有的數組都是以 0 作為它們第一個元素的索引，也被稱為基索引，數組的最后一個索引是數組的總大小減去 1。
以下是上面所討論的數組的的圖形表示：
2.P76 字符串處理庫函數<cstring>
1* strcpy(s1, s2);
復制字符串 s2 到字符串 s1。
2* strcat(s1, s2);
連接字符串 s2 到字符串 s1 的末尾。
3* strlen(s1);
返回字符串 s1 的長度。
4 strcmp(s1, s2);
如果 s1 和 s2 是相同的，則返回 0；如果 s1<s2 則返回值小於 0；如果 s1>s2 則返回值大於 0。
5 strchr(s1, ch);
返回一個指針，指向字符串 s1 中字符 ch 的第一次出現的位置。
6 strstr(s1, s2);
返回一個指針，指向字符串 s1 中字符串 s2 的第一次出現的位置。
eg:
#include <iostream> #include <cstring> using namespace std; int main () { char str1[11] = "Hello"; char str2[11] = "World"; char str3[11]; int len ; // 復制 str1 到 str3 strcpy( str3, str1); cout << "strcpy( str3, str1) : " << str3 << endl; // 連接 str1 和 str2 strcat( str1, str2); cout << "strcat( str1, str2): " << str1 << endl; // 連接后，str1 的總長度 len = strlen(str1); cout << "strlen(str1) : " << len << endl; return 0; } 編譯執行后結果:
strcpy( str3, str1) : Hello strcat( str1, str2): HelloWorld strlen(str1) : 10 3.編程實現兩個字符串的連接（數組，類string）
#include <iostream> #include <string> using namespace std; int main() { char *cat(char *a,char *b); char s1[50] = "please ",*s2 = "let me in."; puts(cat(s1,s2)); return 0; } char *cat(char *a,char *b) { char *p = a,*q = b; while(*p++); p--; while(*p++ = *q++); *p = '\0'; return a; } 第五章*
1.函數的定義
函數必須先定義后才能使用
<函數值類型> 函數名（<形式參數表>）
2.函數的參數傳遞
2.1傳值
2.1.1傳地址值（指針）
該方法把參數的引用復制給形式參數。在函數內，該引用用於訪問調用中要用到的實際參數。這意味着，修改形式參數會影響實際參數。
2.1.2傳變量值
該方法把參數的實際值復制給函數的形式參數。在這種情況下，修改函數內的形式參數對實際參數沒有影響。2.2傳引用[P97例5-4]
該方法把參數的引用（小名）復制給形式參數。在函數內，該引用用於訪問調用中要用到的實際參數。這意味着，修改形式參數會影響實際參數。 [P97例5-4]利用引用編寫交換函數swap（） 程序代碼如下：
#include<iostream> using namespace std; void swap(int &x,int&y) { int tmp=x; x=y; y=tmp; } int main() { int a=2,b=3; cout<<"Before exchange:a="<<a<<",b="<<b<<endl; swap(a,b); cout<<"After exchange:a="<<a<<",b="<<b<<endl; return 0; } 編譯執行后結果:
Before exchange:a=2,b=3 After exchange:a=3,b=2 3.P102 帶有默認參數的函數的聲明
（1）所有的默認參數均需放在參數表的最后
eg:
void func(int x,int n1=1,int n2=2); 若使用func（5，4）；的方式調用該函數，則X的值為5，n1的值為4，n2的值為2。
（2）默認參數的聲明必須出現在函數調用前
第六章
1.*與& p119【再看看書上】
1.1“&”稱為取地址運算符
返回變量的地址。例如 &a; 將給出變量的實際地址。
1.2“*”稱為指針運算符（取內容運算符）
指向一個變量。例如，*var; 將指向變量 var。
2*. new與delete 學會靈活運用p125
2.1new
<指針> = new <類型>
<指針> = new <類型>（<初值>）；
2.2delete
delete <指針>
3.數組
new運算符也可以為數組申請內存，其用法如下：
<指針> = new <類型> [<元素數>]；
若釋放數組的空間，必須放一個空的方括號“[]”在操作符delete和指向該類對象數組的指針之間
eg；
int *p =new int[size]; delete []p; 第七章
1.函數重載的特點P145
a.通過重載，可以將語義、功能相似的幾個函數用同一個名字表示，這樣便於記憶，且提高了函數的易用性；
b.面向對象理論中的類的構造函數需要重載機制。因為構造函數與類名相同，所以如果想用幾種不同的方法創建對象，其對應的構造函數缺被限制只有一個名字，這時只能靠重載來實現，所以累可以有多個重名的構造函數
2.內聯函數p150
將函數體的代碼直接插入到函數調用處來節省調用函數的時間開銷【用空間換時間】
被頻繁調用，語句少，無循環語句
2.1關鍵字 inline
2.2注意事項 p151
（1）在C++程序中，除了在函數體中含有循環、switch分支和復雜的嵌套的if語句的函數外，所有函數均可被說明為內聯函數
【內聯函數不包含循環語句】
（2）內聯函數大多都是小函數，其函數體不宜過大，一般宜在1到5行之間。
（3）關鍵字inline與函數定義放在一起才能使函數成為內聯，內聯函數的定義必須出現在對該函數的調用之前。這是因為編譯器在對函數調用語句進行代換時，必須事先知道代換該語句的代碼是什么。不然即使在函數的聲明和函數的定義處均加上關鍵字inline都不行。
（4）由於計算機的資源有限，使用內聯函數雖然節省了程序運行的時間開銷，但卻增大了代碼占用內存的空間開銷。因此具體編程時，應仔細的權衡時間開銷與空間開銷之間的矛盾，以確定是否采用內聯函數。
第九章
1.面向對象的4個特征
抽象，封裝，繼承，多態
2.類的聲明【聲明時不能初始化】
class { ······ y; } 3.類的成員有數據成員 和成員函數 ++ ；訪問權限有私有（private），公有（public）， 保護（protected）
4.成員函數在類外如何定義（作用域）
<類型><類名>::<函數名>(<參數表>) {<函數體>}
5*.定義一個Dog類，包含name，age，sex，weight等屬性以及對這些屬性的操作方法。實現並測試這個類。P210 習題1
#include <iostream> #include <cstring> using namespace std; class Dog { char name[20]; char sex; int age; float weight; public: void Register(char * Name,int Age,char Sex,float Weight); char * GetName() { return name; } int GetAge() { return age; } char GetSex() { return sex; } float GetWeight() { return weight; } void Speak() { cout<<"Arf!Arf!"<<endl;} }; void Dog::Register(char * Name,int Age,char Sex,float Weight) { strcpy(name,Name); age=Age; sex=Sex; weight=Weight; } int main() { char name[20]; char sex; int age; float weight; Dog dog1; cin>>name>>age>>sex>>weight; dog1.Register(name,age,sex,weight); cout<<"Dog ’ s name:"<<dog1.GetName() <<endl; cout<<"Dog ’ s age:"<<dog1.GetAge()<<endl; cout<<"Dog ’ s sex:"<<dog1.GetSex()<<endl; cout<<"Dog ’ s weight:"<<dog1.GetWeight()<<endl; cout<<"Dog speak:"; dog1.Speak(); return 0; } 第十章
1*.構造函數的定義
類的一個特殊的成員函數，用來處理對象的初始化，每次生成類對象（實例化）時自動被調用
格式：<類名>（<參數表>）；
2*.構造函數的特點
2.1構造函數與類同名，且沒有返回值類型 2.2構造函數既可以在類外定義，也可以作為內聯函數在類內定義 2.3構造函數允許重載
3.拷貝構造函數 p217
構造函數的形參還可以是本類的對象的引用，其作用是用一個已經存在的對象去初始化一個新的同類對象，也稱為拷貝構造函數 格式
classname (const classname &obj) { // 構造函數的主體 } 4.析構函數的定義及特點
4.1作用：對象消亡時，自動被調用，用來釋放對象占用的空間【先析構再delete】
4.2特點:
(1) 析構函數的名字與類名相同，只需在前面需要加上波浪號"~"以與構造函數分開
(2) 構造函數不帶有任何參數，因此不能重載
(3) 無析構函數沒有返回值
(4) 一個類最多只有一個析構函數
5*.p236 習題1
#include＜iostream> #include＜string> using namespace std; class Dog { string name; char sex; int age,weight; public: Dog():name("dog2"),sex('f'),age(2),weight(50) {} // 無參數初始化表 Dog(string Name,char Sex='m',int Age=3,int Weight=40); //帶默認值的構造 void print(); }; Dog::Dog(string Name,char Sex,int Age,int Weight):name(Name),sex(Sex),age(Age),weight(Weight) { } void Dog::print()//輸出信息 { cout＜＜"name is:"＜＜name＜＜endl; cout＜＜"sex is:"＜＜sex＜＜endl; cout＜＜"age is:"＜＜age＜＜endl; cout＜＜"weight is:"＜＜weight＜＜endl; } int main() { string N="dog1"; char S; int A,W; /************************************** 有默認參數的構造函數 **************************************/ cout＜＜"使用有默認值的初始化:"＜＜endl; cout＜＜"沒有輸入前的默認參數為:"＜＜endl; Dog dog1(N); dog1.print(); //輸入數據 cout＜＜"輸入狗名,年齡,性別,體重"＜＜endl; cin>>N>>A>>S>>W; Dog dog(N,S,A,W); cout＜＜"輸入數據后:"＜＜endl; dog.print(); /********************************************** 使用初始化表 **********************************************/ Dog dog2; cout＜＜"調用系統無參數初始化表:"＜＜endl; dog2.print(); return 0; } 第十一章
1.派生類的聲明 P239
聲明格式：
class 派生類名：繼承方式 基類名1，繼承方式 基類名2 { 新增加的成員聲明； } 2.繼承方式公有繼承（public），私有繼承（private），++保護繼承（protected）++p239
3.公有繼承 p249 表11-1
public（公用的）：既可以被本類中的成員函數所引用，也可以被類的作用域內的其他函數（即類外）引用。【在派生類內和外部都可以訪問】 private（私有的）：只能被本類中的成員函數引用，類外不能調用（友元類除外） protected（受保護的）：不能被類外訪問，但可以在派生類的成員函數訪問。 可以這么簡單的認為：
1、凡是基類中私有的，派生類都不可訪問。 2、基類中除了私有的成員，在派生類中的訪問屬性總是 以安全性高{ 繼承方式，基類的訪問屬性 } 的方式呈現。（安全性級別：私有>保護>公有） 4.
派生類構造函數執行的順序
（1）調用基類構造函數，調用順序按照它們被繼承時聲明的基類名順序執行。
（2)調用內嵌對象構造函數，調用次序按各個對象在派生類內聲明的順序
（3）執行派生類構造函數體中的內容
派生類析構函數執行的順序【與構造函數相反】
（1）執行派生類析構函數
（2）執行內嵌對象的析構函數
（3）執行基類的析構函數
p250 參考例11-3
#include<iostream> #include<cstring> using namespace std; class Person { cahr Name[10]; //姓名 int Age； public: Person(char*name,int age) { strcpy(Name,name); Age=age; cout<<"constructor of person"<<Name<<endl; } ~Person() { cout<<"deconstructor of person"<<Name<<endl; }; class Student:public Person { char ClassName[10]； //班級 Person Monitor; //班長 內嵌對象 public: Student(char*name,int age,char *classname,char *name1,int age1):Person(name,age),Monitor(name1,age1) { strcpy(ClassName,classname); cout<<"constructor of Student"<<endl; } ~Student() { cout<<"deconstructor of Student"<<endl; } }; int main() { Student stu("張弓長"，18，"計算機51"，"李木子"，20)； return 0； } 5.編程題：由一個圓類派生圓柱類，圓由半徑，構造函數，面積函數圓柱由高，構造函數，體積函數
#include<iostream> #include<cmath> using namespace std; const double PI=3.1415926; class Circle { protected: double c_r; public: Circle(double r) { c_r=r; } }; class Circular:public Circle { double c_h; public: Circular(double r,double h):Circle(r) { c_h=h; } double GetCircular_t() { return PI*c_r*c_r*c_h; } double GetCircular_b() { return (2*PI*c_r*c_h)+(2*PI*c_r*c_r); } void ShowCircular() { cout<<"圓柱體的體積 ="<<GetCircular_t()<<endl; cout<<"圓柱體的表面積 ="<<GetCircular_b()<<endl; } }; int main() { Circular b(10,10); b.ShowCircular(); return 0; } 第十二章
1.多態性的兩種不同形式：編譯時多態性與運行時多態性P265
2.虛函數
關鍵字 virtual 格式：
virtual 函數返回類型 函數名（） {函數體} 定義p269
實現多態性，通過指向派生類的基類指針或引用，訪問派生類中同名覆蓋成員函數
3.
3.1純虛函數的定義
基類中的虛函數是為了派生類中的使用而聲明定義的，其在基類中沒有任何意義。此類函數我們叫做純虛函數，不需要寫成空函數的形式，只需要聲明成：
virtual 函數類型 函數名（形參表列）=0;注意：純虛函數沒有函數體；
最后面的“=0“並不代表函數返回值為0，只是形式上的作用，告訴編譯系統”這是純虛函數”；
這是一個聲明語句，最后應有分號。
純虛函數只有函數的名字但不具備函數的功能，不能被調用。在派生類中對此函數提供定義后，才能具備函數的功能，可以被調用。
3.2 抽象類的概念p272
在面向對象的編程過程中，有些類的創建是毫無意義的，它的概念是抽象的，比如動物，電器，人這樣類，比如到商店給店員說我要買一台電器。編程過程中可以將這些類設置為抽象類，以防止它們創建對象。
只要一個類中出現純虛函數，那么這個類就是抽象類。
Class Animal{
Public:
virtual void show() = 0;//純虛函數的表達 }; 抽象類除了不能實例化之外，和其他類沒有任何區別。
4.
C++提供的兩種重載方式為函數重載和運算符重載
不適合重載的運算符是那五個p275
. （成員訪問運算符）
.* （成員指針訪問運算符）
:: （域運算符）
sizeof （長度運算符）
?: （條件運算符）
5.常成員函數p277
用const修飾的聲明聲明成員函數稱為常成員函數
聲明：<類型標志符>函數名（參數表）const；
說明：
1. const是函數類型的一部分，在實現部分也要帶該關鍵字。 2. const關鍵字可以用於對重載函數的區分。 3. 常成員函數不能更新任何數據成員，也不能調用該類中沒有用const修飾的成員函數，只能調用常成員函數和常數據成員。 第十三章
1.函數模板的定義及使用p291 函數模板：是一種抽象通用的函數，用它可生成一批具體的函數。這些由函數模板實例化生成的具體函數稱為模板函數。
template<typename T> <類型><函數名>(<參數表>) { ··· }2.友元函數p297
2.1定義
類的友元函數是定義在類外部，但有權訪問類的所有私有（private）成員和保護（protected）成員。盡管友元函數的原型有在類的定義中出現過，但是友元函數並不是成員函數。
友元可以是一個函數，該函數被稱為友元函數；友元也可以是一個類，該類被稱為友元類，在這種情況下，整個類及其所有成員都是友元。
2.2關鍵字 friend
使用友元函數聲明的一般形式：
friend <返回類型> <函數名> (<參數列表>); 2.3使用友元函數注意的要點：
- 類中通過使用關鍵字friend 來修飾友元函數，但該函數並不是類的成員函數，其聲明可以放在類的私有部分，也可放在共有部分。友元函數的定義在類體外實現，不需要加類限定。
- 一個類中的成員函數可以是另外一個類的友元函數，而且一個函數可以是多個類友元函數。
- 友元函數可以訪問類中的私有成員和其他數據，但是訪問不可直接使用數據成員，需要通過對對象進行引用。
- 友元函數在調用上同一般函數一樣，不必通過對對象進行引用。