C++學習

• 1、類和對象
• • P109 析構函數調用規則
  • p110 深拷貝與淺拷貝
  • p111 初始化列表
  • p112 類對象作為類成員
  • p113 靜態成員
  • p114 成員變量與成員函數分開存儲
  • p115 this指針（沒太聽懂￥￥￥￥￥￥￥）
  • **按引用返回，返回是對象本身。。。按值方式返回，返回的不是對象本體，而是調用拷貝（負責）構造函數新建的一個對象，見復習1文檔的最后內容**
  • **按引用返回，返回是對象本身。。。按值方式返回，返回的不是對象本體，而是調用拷貝（負責）構造函數新建的一個對象，見復習1文檔的最后內容**
  • **按引用返回，返回是對象本身。。。按值方式返回，返回的不是對象本體，而是調用拷貝（負責）構造函數新建的一個對象，見復習1文檔的最后內容**
  • p116 空指針訪問成員函數
  • p117 Const修飾成員函數
  • p118 全局函數 做友元
  • p119 讓類做友元
  • p120 成員函數做友元
  • p121 加法運算符重載
  • p122 左移運算符重載
  • p123 遞增運算符重載
  • p124 賦值運算法重載
  • p125 關系運算符重載
  • p126函數調用運算符重載
  • p127 繼承-基本語法（重點）
  • p128繼承方式
  • p129 繼承中的對象模型
  • p130 構造和析構順序
  • p131 繼承中同名函數處理方式
  • p132 繼承同名靜態成員函數處理方式
  • p133 多繼承語法
  • p134 菱形繼承或者鉆石繼承
  • p135 多態的基本語法
  • p136
  • p137 多態案例
  • p138 純虛函數和抽象類
  • p139 多態 案例
  • p140 虛析構 純虛析構
  • p142 案例
  • p143文件操作-文本文件-寫文件
  • p144文件操作-文本文件-讀文件
  • p145 p146 二進制文件的讀取和寫入

---

1、類和對象

P109 析構函數調用規則

因為默認構造函數對其屬性進行了拷貝

---

p110 深拷貝與淺拷貝

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

復制（拷貝）構造函數，形參必須是本類對象的引用。若類中沒有定義復制構造函數，系統會定義一個默認的復制構造函數，完成將一個對象的所有數據成員復制（拷貝）到另一個對象的相應數據成員中。也就是淺拷貝。

---

深拷貝與淺拷貝

淺拷貝：編譯器做的簡單賦值操作叫做淺拷貝

堆區開辟的數據由程序員手動開辟，也需要程序員手動釋放
test01() 執行完 對象p1p2就被銷毀了
在對象p1p2銷毀前需要將堆區數據釋放，p1p2對象銷毀前會調用 析構函數
因此可以使用析構函數釋放堆區數據

因為p1p2是局部變量（對象），所以在棧上，棧上的規則就是先進后出
因為p1p2是局部變量（對象），所以在棧上，棧上的規則就是先進后出
因為p1p2是局部變量（對象），所以在棧上，棧上的規則就是先進后出
因為p1p2是局部變量（對象），所以在棧上，棧上的規則就是先進后出
因為p1p2是局部變量（對象），所以在棧上，棧上的規則就是先進后出
因為p1p2是局部變量（對象），所以在棧上，棧上的規則就是先進后出

所以對象p2先被釋放，先執行p2的析構函數

編譯的會出現問題，出現問題的原因如下：：

---

tips:vscode可能對于這個例子不會蹦

---

存放的數據一樣，但是指針指向的內存不一樣
重新在堆區找塊內存存放，也就是說存放的內容（160）一樣，但是內存也就是地址不一樣
這就叫深拷貝

---

自定義編寫拷貝構造函數，完成深拷貝。
自定義編寫拷貝構造函數，完成深拷貝。
自定義編寫拷貝構造函數，完成深拷貝。
自定義編寫拷貝構造函數，完成深拷貝。
自定義編寫拷貝構造函數，完成深拷貝。

---

#include <iostream>using namespace std;class Person {public://無參（默認）構造函數Person(){cout << "無參構造函數，也就是默認構造函數" << endl;}//有參構造函數Person(int age,int height){m_Age = age;m_Height = new int(height);cout << "有參構造函數" << endl;}//拷貝構造函數 深拷貝解決淺拷貝的問題Person(const Person &p){cout << "Person的拷貝構造函數使用" << endl;m_Age = p.m_Age;m_Height = new int(*p.m_Height);//深拷貝解決淺拷貝的問題}//析構函數~Person(){//析構代碼，將堆區開辟的數據做釋放操作if(m_Height != NULL){delete m_Height;m_Height = NULL;cout << "Person的析構函數調用" << endl;}}int m_Age;int *m_Height; };void test01() {Person p1(10, 160);cout << p1.m_Age << "\t" << *p1.m_Height << endl;Person p2(p1);cout << p2.m_Age << "\t" << *p2.m_Height << endl;}int main() {test01();return 0; }

這樣的話，析構的時候，各自釋放各自的堆區內存，因為內存不一樣了。所以肯定不會出現重復釋放內存(也就是地址）的問題

淺拷貝是編譯器根據默認拷貝構造函數自動完成的

---

---

p111 初始化列表

#include <iostream>using namespace std;class Person {public:// //傳統的初始化方式// //也就是有參構造函數// Person(int a, int b, int c)// {// m_a = a;// m_b = b;// m_c = c;// }// //初始化列表進行初始化屬性// Person() : m_a(20), m_b(2574), m_c(199)// {// }//更加靈活 初始化列表進行初始化屬性Person(int a, int b, int c) : m_a(a), m_b(b), m_c(c){}int m_a;int m_b;int m_c; };void test01() {Person p1(3,2,41);cout << p1.m_a << "\t" << p1.m_b << "\t" << p1.m_c << endl; }int main() {test01();return 0; }

p112 類對象作為類成員

A是類（也就是自定義的數據類型）
a是對象成員，數據類型為A

對象成員也可以使用初始化列表的方式進行初始化，可能會使用到構造函數調用中的 隱世轉換法

#include <iostream>using namespace std; #include <string>//手機類 class Phone {public:Phone(string name) :m_pName(name){cout << "手機類構造函數的調用" << endl;}~Phone(){cout << "Phone的析構函數" << endl;}string m_pName; };//人類 class Person {public://后面那個初始化相當于Phone m_phone = pname 也就是隱世轉換調用Person(string name, string pname) :m_name(name), m_phone(pname){cout << "人類構造函數的調用" << endl;}~Person(){cout << "Person的析構函數" << endl;}//姓名string m_name;//手機Phone m_phone; };void test01() {Person p1("張帥", "華為");cout << p1.m_name << "使用" << p1.m_phone.m_pName << endl; }int main() {test01();return 0; }

當其他類對象作為本類成員時，構造時先構造其他類對象，再構造本類對象，析構的順序與構造的順序相反

p113 靜態成員

1、所有對象共享一份數據，對象a的這個數據變化后，對象b調用這個數據時也變化了。
2、在編譯階段分配內存：也就是指：程序還沒有運行之前，（程序編譯后，）生成exe還沒有雙擊之前就已經分配好內存了，放在全局區里面

靜態成員變量，不屬于某個對象上，所有的對象都共享同一份數據
靜態成員變量，不屬于某個對象上，所有的對象都共享同一份數據
靜態成員變量，不屬于某個對象上，所有的對象都共享同一份數據
教程連接

#include <iostream>using namespace std; #include <string>class Person {public:static int m_a; };int Person::m_a = 10;void test01() {Person p1;cout << p1.m_a << endl;Person p2;p2.m_a = 200;cout << p1.m_a << endl;}void test02() {//1、通過對象進行訪問Person p3;cout << p3.m_a << endl;//2、通過類名進行訪問cout << Person::m_a << endl; } int main() {test02();return 0; }

p114 成員變量與成員函數分開存儲

p115 this指針（沒太聽懂￥￥￥￥￥￥￥）

this指針指向 被調用的成員函數所屬的對象
this指針指向 被調用的成員函數所屬的對象
this指針指向 被調用的成員函數所屬的對象
this指針指向 被調用的成員函數所屬的對象
this指針指向 被調用的成員函數所屬的對象
this指針指向 被調用的成員函數所屬的對象
this指針指向 被調用的成員函數所屬的對象

1、解決名稱沖突

2、返回對象本身用*this

按引用返回，返回是對象本身。。。按值方式返回，返回的不是對象本體，而是調用拷貝（負責）構造函數新建的一個對象，見復習1文檔的最后內容

按引用返回，返回是對象本身。。。按值方式返回，返回的不是對象本體，而是調用拷貝（負責）構造函數新建的一個對象，見復習1文檔的最后內容

按引用返回，返回是對象本身。。。按值方式返回，返回的不是對象本體，而是調用拷貝（負責）構造函數新建的一個對象，見復習1文檔的最后內容

我明白了

之所以用引用返回的方式，是因為疊加是在原數據（也就是p2）改變的基礎上遞增，所以用引用。

---

如果去掉引用返回，也就是去掉&后，每一次調用都會返回一個新的對象（因為值方式返回的原因，每一次調用后返回的都是一個新的對象，調用了拷貝構造函數，最后也就不是p2了，而是p2\\）

---

如下：

所以最后輸出的時候，p2.age只加了一次而不是三次。

總結：此例子中，如果值方式返回則：會創建新的對象。如果引用方式返回，則：不會創建新的對象，一直都是p2。

---

有了*this 就可以使用連式編程思想進行編程
有了*this 就可以使用連式編程思想進行編程
有了*this 就可以使用連式編程思想進行編程
有了*this 就可以使用連式編程思想進行編程

#include <iostream>using namespace std;class Person {public:Person(int age){cout << "有參構造函數" << endl;//**this指針指向 被調用的成員函數所屬的對象** //解決名稱沖突 this指針的作用之一this->age = age;}//引用的方式返回Person & PersonAddage(Person &p){this->age += p.age;return *this;}~Person(){cout << "析構函數" << endl;}int age; };void test01() {Person p1(10);Person p2(25);p2.PersonAddage(p1).PersonAddage(p1).PersonAddage(p1);cout << p2.age << endl; }int main() {test01();return 0; } void test01() {Person p1(10);Person p2(25);Person &p3 = p2;p3=p2.PersonAddage(p1);p3.PersonAddage(p1).PersonAddage(p1);cout << p2.age << endl;cout << p3.age << endl;}

p116 空指針訪問成員函數

p117 Const修飾成員函數

下圖的函數即為常函數：

p118 全局函數 做友元

第一種情況：用全局函數作為好朋友

只要上面的那條語句寫到類中最上面就可以了，也不需要public啥的

#include <iostream>#include <string>using namespace std;class Building {//放在類中最前面，這個全局函數是Building類的好朋友，可以訪問其私有成員friend void goodGay(Building *build);public://無參構造函數Building(){m_SittingRoom = "客廳";m_BedRoom = "臥室";}string m_SittingRoom;private:string m_BedRoom; };//全局函數 void goodGay(Building *build) {cout << build->m_SittingRoom << endl;cout << build->m_BedRoom << endl; }void test01() {Building build1;goodGay(&build1); } int main() {test01();return 0; }

p119 讓類做友元

第二中情況，讓類做友元

#include <iostream>#include <string>using namespace std;class Building;//先聲明類Building class GoodGay//定義類 {public:GoodGay();void visit();Building *building; };class Building {//GoodGay類是本類的好朋友，//其函數可以訪問Building類的私有成員 公有成員本來就可以訪問friend class GoodGay;public:Building();string m_SittingRoom;private:string m_BedRoom; }; //類外寫成員函數 GoodGay::GoodGay() {//創建建筑物對象building = new Building; } //類外寫成員函數 void GoodGay::visit() {cout << "正在訪問" << building->m_SittingRoom << endl;cout << "正在訪問" << building->m_BedRoom << endl;} //類外寫成員函數 Building::Building() {m_BedRoom = "臥室";m_SittingRoom = "客廳"; }void test01() {GoodGay gg;gg.visit();}int main() {test01();return 0; }

p120 成員函數做友元

第三種情況： 讓成員函數做友元

成員函數類外實現或類內實現都可以

#include <iostream>#include <string>using namespace std;class Building;//先聲明類Building class GoodGay//定義類 {public:GoodGay();void visit1(); //讓visit函數可以訪問Building中的私有成員void visit2();//讓visit2函數不可以訪問Building中的私有成員Building *building; };class Building {friend void GoodGay::visit1();public:Building();string m_SittingRoom;private:string m_BedRoom; }; //類外寫成員函數 GoodGay::GoodGay() {//創建建筑物對 創建一個Building對象在堆區building = new Building; } //類外寫成員函數 void GoodGay::visit1() {cout << "visit1正在訪問" << building->m_SittingRoom << endl;cout << "visit1正在訪問" << building->m_BedRoom << endl;}void GoodGay::visit2() {cout << "visit2正在訪問" << building->m_SittingRoom << endl;// cout << "正在訪問" << building->m_BedRoom << endl;} //類外寫成員函數 Building::Building() {m_BedRoom = "臥室";m_SittingRoom = "客廳"; }void test01() {GoodGay gg;gg.visit1();gg.visit2(); }int main() {test01();return 0; }

如果不是友元，那么只能訪問公共屬性

p121 加法運算符重載

兩種重載方式，一種是成員函數，另一種是全局函數

#include <iostream>using namespace std;class Person {public:// //在public下// //方式1：通過成員函數重載+號// Person operator+(Person &p)// {// Person temp;// temp.m_A = this->m_A + p.m_A;// temp.m_B = this->m_B + p.m_B;// return temp;// }int m_A;int m_B; }; //方式2：通過全局函數重載+號 Person operator+(Person &p1, Person &p2) {Person temp;temp.m_A = p1.m_A + p2.m_A;temp.m_B = p1.m_B + p2.m_B;return temp; }//函數重載的版本 Person operator+(Person &p1,int num) {Person temp;temp.m_A = p1.m_A + num;temp.m_B = p1.m_B + num;return temp; }void test01() {Person p1, p2;p1.m_A = 11;p1.m_B = 22;p2.m_A = 11;p2.m_B = 22;Person p3;p3 = p1 + p2;cout << p3.m_A << "\t" << p3.m_B << endl;Person p4 = p1 + 10;cout << p4.m_A << "\t" << p4.m_B << endl;}int main() {test01();return 0; }

兩種方式的重載本質調用

運算符也可以發生函數重載
函數重載的概念回憶一下：：

p122 左移運算符重載

一般不使用第一種方式，也就是成員函數實現重載，原因如下：

cout:標準的輸出流對象 類：ostream
cin: 標準的輸入流對象 類：istream

因為cout對象全局只有一個，所以需要引用的方式傳遞進來，值傳遞的話，就會創建（復制一個副本）一個新的對象。

輸出流不能拷貝，也就是說要傳入輸出流對象參數只能地址傳遞，不能值傳遞。
流對象不能復制只能引用，記住就好了

輸出流不能拷貝，也就是說要傳入輸出流對象參數只能地址傳遞，不能值傳遞。
流對象不能復制只能引用，記住就好了

輸出流不能拷貝，也就是說要傳入輸出流對象參數只能地址傳遞，不能值傳遞。
流對象不能復制只能引用，記住就好了

輸出流不能拷貝，也就是說要傳入輸出流對象參數只能地址傳遞，不能值傳遞。
流對象不能復制只能引用，記住就好了

輸出流不能拷貝，也就是說要傳入輸出流對象參數只能地址傳遞，不能值傳遞。
流對象不能復制只能引用，記住就好了

輸出流不能拷貝，也就是說要傳入輸出流對象參數只能地址傳遞，不能值傳遞。
流對象不能復制只能引用，記住就好了

#include <iostream>using namespace std;class Person {public:int m_A;int m_B; };//使用全局函數的方式重載左移運算符 //輸出流對象 cout使用引用的方式傳遞 //注意這里的ostream & 返回類型可以確保返回的是cout本體 ostream & operator<<(ostream & cout,Person &p) {cout << "p.m_A:" << p.m_A << " "<< "p.m_B:" << p.m_B << endl;return cout; }void test01() {Person p1;p1.m_A = 15;p1.m_B = 25;cout << p1 << endl;; }int main() {test01();return 0; }

#include <iostream>using namespace std;class Person {friend ostream &operator<<(ostream &cout, Person &p);private:int m_A;int m_B; };//使用全局函數的方式重載左移運算符 //輸出流對象 cout使用引用的方式傳遞 //注意這里的ostream & 返回類型可以確保返回的是cout本體 ostream & operator<<(ostream & cout,Person &p) {p.m_A = 15;p.m_B = 25;cout << "p.m_A:" << p.m_A << " "<< "p.m_B:" << p.m_B << endl;return cout;}void test01() {Person p1;cout << p1 << endl;}int main() {test01();return 0; }

p123 遞增運算符重載

內置的遞增++運算符：

前置遞增 先對變量進行遞增，再進行其他操作。
后置遞增，先對變量進行完其他操作，再進行變量遞增。

1、前置遞增

返回引用是為了一直對一個對象進行遞增操作，否則的話，如果不是返回引用，而是返回值，則每次遞增后返回一個新的對象（調用拷貝構造函數，如果沒有自己定義的，會進行淺拷貝）。

返回引用是為了一直對一個對象進行遞增操作，否則的話，如果不是返回引用，而是返回值，則每次遞增后返回一個新的對象（調用拷貝構造函數，如果沒有自己定義的，會進行淺拷貝）。

返回引用是為了一直對一個對象進行遞增操作，否則的話，如果不是返回引用，而是返回值，則每次遞增后返回一個新的對象（調用拷貝構造函數，如果沒有自己定義的，會進行淺拷貝）。

嗶哩嗶哩鏈接

對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數
對象作為返回值不加引用就會調用拷貝構造函數

復習知識點：拷貝構造函數的調用時機

值返回是相當于對一個新的返回，再操作又繼續開個新的重復

2、后置遞增

返回值不可以作為函數重載的條件

函數占位參數

此例中的移位與上一節課中的不太一樣
后置++使用移位運算符重載 不能定義引用 ，因為返回的臨時對象temp已被編譯器釋放,因此只能值傳遞

#include <iostream>using namespace std;class MyInteger {friend ostream &operator<<(ostream &cout, MyInteger p);public:MyInteger(){m_int = 0;}//前置++ 通過成員函數重載//返回的本體對象MyInteger & operator++(){++m_int;return *this;}//后置遞增 通過成員函數重載實現//返回的是局部對象 不能使用引用返回，因為temp為局部對象，后置遞增執行完就銷毀了tempMyInteger operator++(int){MyInteger temp=*this;m_int++;return temp;}private:int m_int; };//使用全局函數的方式重載左移運算符 //形參中輸出流對象 cout使用引用的方式傳遞 //注意這里的ostream & 返回類型可以確保返回的是cout本體 //MyInteger p //后置++使用移位運算符重載 不能定義引用 ，因為返回的臨時對象temp已被編譯器釋放,因此只能值傳遞 ostream & operator<<(ostream & cout,MyInteger p) {cout << p.m_int << endl;return cout; }void test01() {MyInteger m_int1;cout << ++(++m_int1) << endl;cout << m_int1 << endl;} void test02() {MyInteger m_int2;cout << m_int2++ << endl;cout << m_int2 << endl; }int main() {test01();test02();return 0; }

p124 賦值運算法重載

一般來說，只要是值拷貝，都會引發深淺拷貝問題
回憶：拷貝構造函數

---

讓p2=p1之后，再把p2這個對象傳給p3，也就是函數operator=調用完之后還能返回自身（使用return *this返回自身）

返回本體需要時引用返回，而不是值返回

此例中若返回值的話，那就是按照自身調用一個拷貝構造函數（默認淺拷貝），創建一個新的對象（副本），而不是對象自身了。我們要返回其引用才是其真正的自身。

#include <iostream>using namespace std;class Person {public://默認構造函數Person(int age){m_Age = new int(age);}//析構函數~Person(){if(m_Age!=NULL){delete m_Age;m_Age = NULL;}}//重載賦值運算符Person & operator=(Person &p){if (m_Age!=NULL){delete m_Age;m_Age = NULL;}m_Age = new int(*p.m_Age);//指向自身的指針是this指針，*解引用return *this;//函數調用之后還能返回對象的自身}int *m_Age;//這個變量因為是指針，所以被開辟到堆區，而不是棧區 };void test01() {Person p1(18);Person p2(22);Person p3(33);p3=p2 = p1;cout << "p1的年齡"<<*p1.m_Age<<endl;cout << "p2的年齡"<<*p2.m_Age<<endl;cout << "p3的年齡"<<*p3.m_Age<<endl;}int main() {int a = 10, b = 20, c = 30;c = b = a;cout << "a=" << a << endl;cout << "b=" << b << endl;cout << "c=" << c << endl;test01();return 0; }

p125 關系運算符重載

#include <iostream> #include <string>using namespace std;class Person {public:Person(string name,int age){m_Age = age;m_Name = name;}bool operator==(Person &p){if (this->m_Age==p.m_Age && this->m_Name==p.m_Name){return true;}else{return false;}}string m_Name;int m_Age; };void test01() {Person p1("tom1", 22);Person p2("tom", 22);if(p1==p2){cout << "yes" << endl;}else{cout << "no" << endl;} }int main() {test01();return 0; }

p126函數調用運算符重載

仿函數
十分靈活

匿名函數對象

#include <iostream> #include <string>using namespace std;class Myprint {public://重載函數調用運算符void operator()(string test){cout << test << endl;} };void test01() {Myprint myprint;myprint("helloworld"); }class Add {public:void operator()(int num1,int num2){cout << num1 + num2 << endl;} };void test02() {Add add;add(1, 1);Add()(100, 125);//匿名函數對象，Add()相當于匿名對象 }int main() {// test01();test02();return 0; }

p127 繼承-基本語法（重點）

繼承的技術

#include <iostream>using namespace std; //父類 也就是基類 class Base {public:void header(){cout << "首頁、公開課、登錄（公共頭部）" << endl;}void footer(){cout << "幫助中心、聯系方式（公共底部）" << endl;}void leftlist(){cout << "C++、Python、Java（公共左側）" << endl;} };//Java繼承Base類 class Java : public Base {public:void content(){cout << "Java 視頻資料" << endl;} };//cpp繼承Base類 class Cpp : public Base {public:void content(){cout << "cpp 視頻資料" << endl;} };void test01(Java &p) {cout << "java下載視頻的頁面" << endl;p.header();p.footer();p.leftlist();p.content(); }void test02(Cpp &p) {cout << "cpp下載視頻的頁面" << endl;p.header();p.footer();p.leftlist();p.content(); }int main() {Java java1;Cpp cpp1;test01(java1);cout << "-----------------" << endl;test02(cpp1);return 0; }

p128繼承方式

p129 繼承中的對象模型

開發人員命令提示工具

#include <iostream>using namespace std;class Base {public:int m_A;protected:int m_B;private:int m_C; };class Son1 : public Base {public:int m_D; };int main() {int a = 10;Base base;Son1 son1;cout << sizeof(a) << endl;cout << sizeof(base) << endl;cout << sizeof(son1) << endl;}

p130 構造和析構順序

p131 繼承中同名函數處理方式

注意是所有的同名函數（包括重載的 都給隱藏掉了）

#include <iostream>using namespace std;class Base {public:Base(){m_A = 10;}void func(){cout << "Base func" << endl;}void func(int a){cout << "Son int a func" << endl;}int m_A; };class Son: public Base {public:Son(){m_A = 100;}void func(){cout << "Son func" << endl;}int m_A; };//調用同名成員數據 void test01() {Son son1;cout << "son的m_A "<< son1.m_A << endl;cout << "父類的m_A " << son1.Base::m_A << endl; }//調用同名成員函數 void test02() {Son son2;son2.func();//同名情況下，調用子類的，加類作用域才調用父類的son2.Base::func();//錯誤，因為子類和父類的成員函數重名后，父類的所以這個名稱的成員函數被隱藏掉//找不到第二個父類的func（int a）函數// son2.func(10);//加上類作用域就可以啦son2.Base::func(10);}int main() {test02();return 0; }

p132 繼承同名靜態成員函數處理方式

復習 類與對象中的靜態成員

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。

靜態成員的訪問有兩種方式：通過對象訪問或者通過類名。
1、通過對象訪問

2、通過類名訪問

#include <iostream>using namespace std;class Base {public:static int m_A;static void fun(){cout << "base func" << endl;}static void fun(int a){cout << "base func int a" << endl;} };int Base::m_A = 10;class Son :public Base {public:static int m_A;static void fun(){cout << "son fun" << endl;} };int Son::m_A = 100;void test01() {Son son;//方式一通過對象來訪問靜態成員數據cout << "通過對象訪問" << endl;cout << "son :" << son.m_A << endl;cout << "base ：" << son.Base::m_A << endl;//方式二 通過類名訪問靜態成員數據cout << "通過類名訪問靜態成員數據" << endl;cout << "son :" << Son::m_A << endl;cout << "Base :" << Base::m_A << endl;//通過訪問son中的父類作用下的m_Acout << "Base ::" << Son::Base::m_A << endl; }void test02() {//1.Son son;son.fun();son.Base::fun();//2.Son::fun();Son::Base::fun();Son::Base::fun(10255); }int main() {test02();return 0; }

p133 多繼承語法

作用域：：

p134 菱形繼承或者鉆石繼承

【暫時沒學習，用到的時候再學習】

p135 多態的基本語法

父類引用指向子類對象
c++中運行父子類之間類型轉換
靜態多態

這樣就可以實現地址晚綁定 也就是動態多態

函數重寫的意思：（子類的virtual可寫可不寫）

總結：

#include <iostream>using namespace std;//父類或者基類 class Animal {public://虛函數 可以實現地址的晚綁定 也就是動態多態virtual void speak(){cout << "動物在說話" << endl;} };//子類或者派生類 class Cat : public Animal {public://子類重寫父類中的虛函數void speak(){cout << "小貓在說話" << endl;} }; //子類或者派生類class Dog : public Animal {public:void speak(){cout << "小狗在說話" << endl;} };void DoSpeak(Animal &p)//父類指針或者引用指向子類對象 {p.speak();//現在speak等于是多種形態了 }void test01() {Cat cat1;DoSpeak(cat1);Dog dog1;DoSpeak(dog1); }int main() {test01();return 0; }

p136

四個字節一般是整形變量 指針等

當用父類指針或者引用指向子類對象，調用speak時會調用小貓會說話。

p137 多態案例

#include <iostream>using namespace std; //多態的使用//父類 抽象的一個類 class AbstractCalculator {public:virtual int GetResult(){return 0;}int m_Num1;int m_Num2; };//加法 class AddCalculator : public AbstractCalculator {public:int GetResult(){return m_Num1 + m_Num2;} };// 減法 class SubCalculator : public AbstractCalculator {public:int GetResult(){return m_Num1 - m_Num2;} };// 乘法 class MulCalculator : public AbstractCalculator {public:int GetResult(){return m_Num1 * m_Num2;} };void test01() {//實現加法AbstractCalculator *abc = new AddCalculator;abc->m_Num1 = 15;abc->m_Num2 = 35;cout << abc->GetResult() << endl;//用完后記得銷毀delete abc;abc = new SubCalculator;abc->m_Num1 = 100;abc->m_Num2 = 90;cout << abc->GetResult() << endl; }int main() {test01();return 0; }

p138 純虛函數和抽象類

p139 多態 案例

**
**

#include <iostream>using namespace std;//多態的使用 //多態案例2 制作飲品//基類 也就是父類，因為里面的成員函數有純虛函數，所以變成抽象類 class AbstractDrinking {public://成員函數寫成純虛函數 基類也就變成抽象類//煮水virtual void Boil() = 0;//沖泡virtual void Brew() = 0;//倒入杯子virtual void PourInCup() = 0;//加入輔料virtual void PutSomething() = 0;//制作飲品void MakeDrinking(){Boil();Brew();PourInCup();PutSomething();} };//制作咖啡 class MakeCoffee : public AbstractDrinking {public://成員函數寫成純虛函數 基類也就變成抽象類//煮水void Boil(){cout << "煮水" << endl;}//沖泡void Brew(){cout << "沖泡咖啡" << endl;}//倒入杯子void PourInCup(){cout << "將咖啡倒入杯中" << endl;}//加入輔料void PutSomething(){cout << "將輔料加入到咖啡中" << endl;}};//制作茶水 class MakeTea : public AbstractDrinking {public://成員函數寫成純虛函數 基類也就變成抽象類//煮水void Boil(){cout << "煮水" << endl;}//沖泡void Brew(){cout << "沖泡茶葉" << endl;}//倒入杯子void PourInCup(){cout << "將茶水倒入杯中" << endl;}//加入輔料void PutSomething(){cout << "將輔料加入到茶水中" << endl;}};void DoWork(AbstractDrinking *abs) {abs->MakeDrinking(); }void test01() {AbstractDrinking *abs1 = new MakeCoffee;DoWork(abs1);// DoWork(new MakeCoffee);delete abs1;abs1 = new MakeTea;DoWork(abs1);// DoWork(new MakeTea);delete abs1;}int main() {test01();return 0; }

p140 虛析構 純虛析構

純虛析構函數需要注意的問題

在多態使用中:
不管是虛析構還是純虛析構 都是為了解決子類中析構代碼調用不到的問題

p142 案例

#include <iostream>using namespace std;//多態的使用 //多態案例//三個抽象類//cpu抽象類 class Cpu {public:virtual void Calculator() = 0; }; //顯卡抽象類 class VideoCard {public:virtual void display() = 0; }; //存儲抽象類 class Memory {public:virtual void storage() = 0; };//電腦類 class Computer {public://構造函數Computer(Cpu *cpu, VideoCard *vc, Memory *mem){cout << "Computer的構造" << endl;m_cpu = cpu;m_vc = vc;m_mem = mem;}void Work(){m_cpu->Calculator();m_mem->storage();m_vc->display();}//析構函數~Computer(){cout << "Computer的析構" << endl;if(m_cpu!=NULL){delete m_cpu;m_cpu = NULL;}if(m_vc!=NULL){delete m_vc;m_vc = NULL;}if(m_mem!=NULL){delete m_mem;m_mem = NULL;}}private : Cpu *m_cpu;VideoCard *m_vc;Memory *m_mem; };//Intel廠商 class IntelCpu : public Cpu {public://派生類重寫函數void Calculator(){cout << "Intel的cpu開始計算了" << endl;} }; class IntelVideoCard : public VideoCard {public:void display(){cout << "Intel的顯卡開始工作了" << endl;} }; class IntelMemory : public Memory {public:void storage(){cout << "Intel的內存開始工作了" << endl;} };//Lenovo廠商 class LenovoCpu : public Cpu {public:void Calculator(){cout << "Lenovo的cpu開始計算了" << endl;} }; class LenovoVideoCard : public VideoCard {public:void display(){cout << "Lenovo的顯卡開始工作了" << endl;} }; class LenovoMemory : public Memory {public:void storage(){cout << "Lenovo的內存開始工作了" << endl;} };void test01() {//第一臺電腦零件//多態的條件之一，父類指針指向子類對象//堆區的數據手動開啟 需要手動釋放！！！！！！Cpu *intelCpu = new IntelCpu;VideoCard *videoCard = new IntelVideoCard;Memory *memory = new IntelMemory;//創建第一臺電腦Computer *computer = new Computer(intelCpu, videoCard, memory);computer->Work();//釋放下面這個對象時 執行器析構函數delete computer;//創建第二臺電腦 換了個寫法 直接在實參出new ，，，Computer *computer2 = new Computer(new LenovoCpu, new LenovoVideoCard, new LenovoMemory);computer2->Work();delete computer2; }int main() {test01();return 0; }

p143文件操作-文本文件-寫文件

五步法寫文件

#include <iostream> using namespace std;#include <fstream>//練習寫文件void test01() {//1.包含頭文件//2.創建流對象ofstream ofs;//3.指定打開方式ofs.open("text.txt", ios::out);//4.寫內容 換行照樣好使ofs << "sdawsd" << endl;ofs << "張帥克拉拉啊" << endl;//5.關閉文件ofs.close(); }int main() {test01();return 0; }

p144文件操作-文本文件-讀文件

讀文件共有四種方式，第四種如下：

#include <iostream> using namespace std;#include <fstream> #include <string> //練習讀文件void test01() {//1.包含頭文件//2.創建流對象ifstream ifs;//3.指定打開方式ifs.open("text.txt", ios::in);//判斷文件是否打開成功if(!ifs.is_open()){cout << "文件打開失敗" << endl;return;}//4.讀文件//第一種// char buf[1024] = {0};// while (ifs>>buf)// {// cout << buf << endl;// }cout << "---------" << endl;//第二種方式// char buf[1024] = {0};// while(ifs.getline(buf,sizeof(buf)))// {// cout << buf << endl;// }//第三種string buf;//字符串變量while(getline((ifs),buf)){cout << buf << endl;}//5.關閉文件ifs.close(); }int main() {test01();return 0; }

p145 p146 二進制文件的讀取和寫入

=暫時未學習

總結

以上是生活随笔為你收集整理的C++语法知识复习2（黑马程序员教程P109-p146）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。