以C++ Primer Plus為參考書籍，自身歸納知識點，加深記憶。

對象和類

• 過程性編程與面向對象編程
• 對象和類
• • 類
  • • 類聲明
    • 實現類成員函數
    • 方法與對象
• 類的構造函數與析構函數
• • 聲明和定義構造函數
  • 使用構造函數
  • 默認構造函數（defult constructor）
  • 析構函數（destructor）
  • const成員函數
  • C++11列表初始化
• this指針
• 對象數組

過程性編程與面向對象編程

過程性編程：首先考慮要遵循的步驟，然后考慮如何表示這些數據
面向對象編程：首先從用戶的角度考慮對象，描述對象所需的數據以及描述用戶與數據交互所需的操作，完成對接口的描述后，需要確定如何實現接口與數據儲存，最后使用新的設計方案創建出程序。

對象和類

類

類是一種將抽象轉化為用戶定義類型的C++工具，將數據表示和數據操作的方法組合成一個整合包。
一般來說，類規范由兩個部分組成：
①類聲明：以數據成員的方式描述數據部分，以成員函數（方法）的方式描述公有接口
②類方法定義：描述如何實現類成員函數
簡單地說，類聲明提供藍圖，類方法定義提供細節。

類聲明

//類聲明 //stock00.h #include<iostream>class Stock//class不同于模板參數的typename，不能代替，Stock為新類型名 { private://私有部分，一般是數據通項std::string company;long shares;double share_val;double total_val;void set_tot(){total_val = shares*share_val;} public://公有部分，一般是組成類成員函數聲明void acquire(const std::string &co,long n, double pr);void buy(long num,double price);void sell(long num,double price);void update(double price);void show(); };

使用類對象的程序都可以使用公有部分，但只能通過公有成員函數訪問對象的私有成員。將實現細節放在一起并將它們與抽象分開被稱為封裝。

實現類成員函數

成員函數的定義與常規函數定義非常相似，它們有函數頭和函數體，也可以有返回類型和參數，但還有兩個特殊的特征：
①定義成員函數，使用作用域解析符::來表示函數所屬的類
②類方法可以訪問類的private組件

void Stock::update(double price)//update是Stock類的成員函數，還可以將另一個類的成員函數聲明為update //標識符update()具有類作用域 // stock00.cpp -- implementing the Stock class // version 00 #include <iostream> #include "stock00.h"void Stock::acquire(const std::string & co, long n, double pr) {company = co;if (n < 0){std::cout << "Number of shares can't be negative; "<< company << " shares set to 0.\n";shares = 0;}elseshares = n;share_val = pr;set_tot(); }void Stock::buy(long num, double price) {if (num < 0){std::cout << "Number of shares purchased can't be negative. "<< "Transaction is aborted.\n";}else{shares += num;share_val = price;set_tot();} }void Stock::sell(long num, double price) {using std::cout;if (num < 0){cout << "Number of shares sold can't be negative. "<< "Transaction is aborted.\n";}else if (num > shares){cout << "You can't sell more than you have! "<< "Transaction is aborted.\n";}else{shares -= num;share_val = price;set_tot();} }void Stock::update(double price) {share_val = price;set_tot(); }void Stock::show() {std::cout << "Company: " << company<< " Shares: " << shares << '\n'<< " Share Price: $" << share_val<< " Total Worth: $" << total_val << '\n'; }

方法與對象

創建對象：

Stock kate,joe;

使用成員函數：

kate.show(); joe.show();

創建的每一個對象都有自己的存儲空間，用于存儲其內部的變量和類成員，但同一個類的所有對象共享同一組類的方法，即每種方法只有一個副本，在OOP中，調用成員函數被稱為發送消息，因此將同樣的消息發送給兩個不同的對象將調用同一個方法，但該方法被用于兩個不同的對象

// usestok0.cpp -- the client program // compile with stock.cpp #include <iostream> #include "stock00.h"int main() {Stock fluffy_the_cat;fluffy_the_cat.acquire("NanoSmart", 20, 12.50);fluffy_the_cat.show();fluffy_the_cat.buy(15, 18.125);fluffy_the_cat.show();fluffy_the_cat.sell(400, 20.00);fluffy_the_cat.show();fluffy_the_cat.buy(300000,40.125);fluffy_the_cat.show();fluffy_the_cat.sell(300000,0.125);fluffy_the_cat.show();// std::cin.get();return 0; }

類的構造函數與析構函數

聲明和定義構造函數

Stock (const string &co,long n =0, double pr = 0.0);//沒有返回類型，構造函數聲明 //定義構造函數 Stock::Stock(const std::string & co, long n, double pr) {company = co;if (n < 0){std::cout << "Number of shares can't be negative; "<< company << " shares set to 0.\n";shares = 0;}elseshares = n;share_val = pr;set_tot(); }

使用構造函數

構造函數初始化對象有兩種方式：

Stock food = Stock("World Cabbage",250,2.5);//顯示調用構造函數 Stock garmer("Furry Mason",50,1.25);//隱式調用構造函數 Stock *pstock = new Stock("Electroshock Games",18,20.5);//對象指針

無法使用對象調用構造函數，因為在構造函數構造出對象之前，對象是不存在的，因此構造函數創建對象但不能通過對象調用

默認構造函數（defult constructor）

默認構造函數實在未提供顯示初始值時，用來創建對象的構造函數。如果沒有提供任何構造函數，C++將自動提供默認構造函數，它是默認構造函數的隱式版本，不做任何工作。默認構造函數沒有參數，因為沒有聲明中不包含值

定義默認構造函數的方式有兩種：

Stock(const string &co="ERROR",int n=0,double pr=0);//給已有構造函數的所有參數提供默認值 Stock();//函數重載，一個沒有任何參數的構造函數。 //只有能有一種默認構造函數，不要同時采用

析構函數（destructor）

用構造函數創建一個對象后，程序負責跟蹤該對象，直到其過期為止。對象過期時，程序將自動調用一個特殊的成員函數完成清理工作。
和構造函數一樣，析構函數的名稱很特殊。在類名前加上~，沒有返回值和聲明類型，并且沒有參數：

~Stock();

①如果創建的是靜態存儲類對象，析構函數將在程序結束時自動調用
②如果創建的是自動存儲類對象，析構函數將在程序運行完代碼塊時自動被調用
③如果對象是通過new創建，析構函數將駐留在棧內存或者自由存儲區中，當使用delete釋放內存時，析構函數將會自動被調用
④程序創建臨時對象來完成特定操作，在這種情況下，程序將結束該對象的使用時自動調用其析構函數。

// stock10.h ?Stock class declaration with constructors, destructor added #ifndef STOCK1_H_ #define STOCK1_H_ #include <string> class Stock { private:std::string company;long shares;double share_val;double total_val;void set_tot() { total_val = shares * share_val; } public:Stock(); // default constructorStock(const std::string & co, long n = 0, double pr = 0.0);~Stock(); // noisy destructorvoid buy(long num, double price);void sell(long num, double price);void update(double price);void show(); };#endif // stock1.cpp ?Stock class implementation with constructors, destructor added #include <iostream> #include "stock10.h"// constructors (verbose versions) Stock::Stock() // default constructor {std::cout << "Default constructor called\n";company = "no name";shares = 0;share_val = 0.0;total_val = 0.0; }Stock::Stock(const std::string & co, long n, double pr) {std::cout << "Constructor using " << co << " called\n";company = co;if (n < 0){std::cout << "Number of shares can't be negative; "<< company << " shares set to 0.\n";shares = 0;}elseshares = n;share_val = pr;set_tot(); } // class destructor Stock::~Stock() // verbose class destructor {std::cout << "Bye, " << company << "!\n"; }// other methods void Stock::buy(long num, double price) {if (num < 0){std::cout << "Number of shares purchased can't be negative. "<< "Transaction is aborted.\n";}else{shares += num;share_val = price;set_tot();} }void Stock::sell(long num, double price) {using std::cout;if (num < 0){cout << "Number of shares sold can't be negative. "<< "Transaction is aborted.\n";}else if (num > shares){cout << "You can't sell more than you have! "<< "Transaction is aborted.\n";}else{shares -= num;share_val = price;set_tot();} }void Stock::update(double price) {share_val = price;set_tot(); }void Stock::show() {using std::cout;using std::ios_base;// set format to #.###ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield); std::streamsize prec = cout.precision(3);cout << "Company: " << company<< " Shares: " << shares << '\n';cout << " Share Price: $" << share_val;// set format to #.##cout.precision(2);cout << " Total Worth: $" << total_val << '\n';// restore original formatcout.setf(orig, ios_base::floatfield);cout.precision(prec); } // usestok1.cpp -- using the Stock class // compile with stock10.cpp #include <iostream> #include "stock10.h"int main() {{using std::cout;cout << "Using constructors to create new objects\n";Stock stock1("NanoSmart", 12, 20.0); // syntax 1stock1.show();Stock stock2 = Stock ("Boffo Objects", 2, 2.0); // syntax 2stock2.show();cout << "Assigning stock1 to stock2:\n";stock2 = stock1;//可以將一個對象賦給同類型的另一個對象cout << "Listing stock1 and stock2:\n";stock1.show();stock2.show();cout << "Using a constructor to reset an object\n";stock1 = Stock("Nifty Foods", 10, 50.0); // temp objectcout << "Revised stock1:\n";stock1.show();cout << "Done\n";}// std::cin.get();return 0; }

const成員函數

void show()const;//將const放在函數括號后面

C++11列表初始化

Stock hot = {"Dedwadd dfwf fw",110,23.2}; Stock dw {"sdded dad",121,2.1};//與構造函數匹配 Stock temp {};//與默認構造函數匹配

this指針

this指針指向用來調用成員函數的對象。

stock1.topval(stock2)//this設置為stock1的地址

每個成員函數包括構造函數和析構函數都有一個this指針，this指針指向調用對象，在函數括號后面使用const限定符將this限定為const，這樣不能使用this修改對象的值。

對象數組

聲明對象數組的方法與聲明標準類型數組相同

Stock mystuff[4];

可以用構造函數來初始化數組元素，在這個情況下必須為每個元素調用構造函數：

Stock stocks[4] = {Stock("dqguydi dfwq",12.5,20),//也可以交叉使用默認構造函數Stock("dswd",12.2,21),Stock("dedes ded"12.6,78),Stock("dsve fgte"32.9,89)};

總結

以上是生活随笔為你收集整理的2020 我的C++的学习之路 第十章 对象和类的全部內容，希望文章能夠幫你解決所遇到的問題。

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