<<從0到1學C++>> 第3篇 從結構到類的演變

本篇要學習的內容和知識結構概覽

知識點逐條分析

結構的演化

C++中的類是從結構演變而來的, 因此咱們能夠稱C++爲」帶類的C」.

結構發生質的演變

C++結構中能夠定義函數, 稱之爲成員函數

結構定義格式, 像這樣:

struct 結構名 {

    數據成員;

    成員函數;

}; // 注意這裏的分號不要忘記

具體的代碼, 像這樣:

struct Point {
    private:
        // 數據成員
        double x;
        double y;
        
    public:
        // 成員函數: 從新設置數據成員
        void setXY(double a, double b) {
            x = a;
            y = b;
        }
        
        // 成員函數: 指定格式輸出數據成員
        void display() {
            cout << x << "\t" << y << endl;
        }
}; // 不要忘記分號複製代碼

模型圖是這樣的:

它代表: 我定義了一個結構體, 有兩個私有的數據成員x, y, 兩個公有的成員函數setXY(double, x, double y), display();

在定義結構體時, 將數據成員使用private關鍵字修飾, 則產生封裝性. 若是沒有沒定, 則默認爲public

private修飾的數據成員爲私有的數據成員, 必須公有的成員函數才能使用, 這就是數據的封裝性.

使用方式: 結構對象.成員函數

咱們在main函數中這樣使用:

// 建立結構對象
Point pointA;

// 調用成員函數
pointA.setXY(1.2, 3.4);

// 顯示pointA的數據成員
pointA.display();
複製代碼

注意: 

若是結構的數據成員用private關鍵字修飾

則不能這麼訪問: 

cout << pointA.x << endl; count << pointA.y << endl;

若是public修飾, 則能夠這麼訪問.

不過咱們通常爲了保證封裝性, 將數據成員聲明爲private, 保證只有成員函數才能訪問.

使用構造函數初始化結構對象

函數名與結構同名, 稱爲構造函數, 專門用於初始化結構對象

分爲有參構造函數和無參構造函數

像這樣:

#include <iostream>
using namespace std;

struct Point {
    private:
        // 數據成員
        double x;
        double y;
        
    public:
        // 無參構造函數
        Point(){}
        
        // 有參構造函數
        Point(double a, double b) {
            x = a;
            y = b;
        }
        
        // 成員函數: 從新設置數據成員
        void setXY(double a, double b) {
            x = a;
            y = b;
        }
        
        // 成員函數: 指定格式輸出數據成員
        void display() {
            cout << x << "\t" << y << endl;
        }
    };複製代碼

int main(int argc, const char * argv[]) {
    // insert code here...
   
    // 使用構造函數建立結構對象pointA
    Point pointA(20, 30);
    
    // 顯示pointA的數據成員
    pointA.display();
    return 0;
}複製代碼

模型圖是這樣的:

它代表: 我定義了一個結構體, 有兩個私有的數據成員x, y, 一個無參構造函數Point(), 一個有參構造函數Point(double x, double y), 兩個普通的成員函數setXY(double, x, double y), display();

從結構演變成一個簡單的類

使用關鍵字class代替stuct, 就將一個結構演變成一個標準的類啦! 是否是So easy!

像這樣:

class Point { // 這裏struct 變成 class, 就完成了從結構到類的演變
	private:
	    // 數據成員
	    double x;
	    double y;
	
	public:
	    // 無參構造函數
	    Point(){}
	
	    // 有參構造函數
	    Point(double a, double b) {
	        x = a;
	        y = b;
	    }
	
	    // 成員函數: 從新設置數據成員
	    void setXY(double a, double b) {
	        x = a;
	        y = b;
	    }
	
	    // 成員函數: 指定格式輸出數據成員
	    void display() {
	        cout << x << "\t" << y << endl;
	    }
};複製代碼

好的, 從如今開始把咱們的目光從struct移開吧, 讓咱們聚焦於class!

面向過程與面向對象

編程語言是咱們和計算機交流的橋樑, 編程技術在發展, 一樣的編程語言也在發展, 編程語言從最初的0和1, 到彙編語言, 再到面向過程的語言, 再到面向對象的語言, 反應出了咱們的編程思想也在不斷的進步, 面向過程只是關注解決問題的步驟, 而面向對象關注解決問題的對象, 也就是誰解決這個問題.

下面我用兩個經典的例子來詮釋面向過程和麪向對象的區別

第一個: 五子棋遊戲

面向過程是這樣的:

(1)開始遊戲 -> (2)黑子下棋 -> (3)繪製畫面 -> (4)判斷輸贏 -> (5)白子下棋 -> (6)繪製畫面 -> (7)判斷輸贏 -> (8)返回步驟(2)

面向對象是這樣的:

黑白雙方, 負責下棋這個操做

棋盤系統, 負責繪製畫面

規則系統, 負責判斷是否犯規, 輸贏等

第二個: 把大象裝進冰箱

面向過程是這樣的:

(1)把冰箱門打開 -> (2)把大象裝進去 -> (3)把冰箱門關上

面向對象是這樣的:

冰箱 -> 開門

冰箱 -> 裝大象

冰箱 -> 關門

冰箱是一個對象, 它有開門的操做, 裝大象的操做, 關門的操做, 大象也是一個對象

總結

面向過程就是關注解決問題的步驟, 像這樣: 第一步打開冰箱門, 第二步裝大象, 第三步關閉冰箱門

面向對象就是關注解決問題的對象, 像冰箱, 它有開門的方法, 裝大象的方法, 關門的方法

你們知道基本的區別和聯繫就能夠啦. 也能夠找我細聊哦!

面向對象程序設計的特色

面向對象的程序設計具備抽象, 封裝, 繼承和多態性的特色

對象

對象是系統描述客觀事物的一個實體, 是構成系統的基本單位

對象用對象名, 屬性(數據成員), 操做(功能函數)三要素來描述

對象名: 用來標識一個具體的對象. 如: zhangsan, lisi等

屬性: 這個對象的數據成員, 也就是特徵, 如: 姓名, 年齡, 性別等

操做: 這個對象所具備的行爲, 如: 吃飯, 睡覺, 打豆豆等

像這樣:

咱們有一個對象

對象名: zhangsan

數據成員: 姓名叫張三, 年齡18歲

成員函數: 會吃飯, 能睡覺, 還喜歡打豆豆

抽象和類

好比咱們還有一個學生對象叫李四

咱們如今有兩個學生對象一個叫張三, 年齡18, 一個叫李四, 年齡20, 好比咱們還有一個學生對象叫王五, 年齡22, 假如咱們還有好多個學生.

都有姓名, 年齡的基本屬性, 也有吃飯, 睡覺, 打豆豆的行爲,

咱們把這些對象的共同特徵進一步抽象出來, 就造成了類的概念

像這樣:

這是一個類,

類名: Student

數據成員: name, age

成員函數: eat(), sleep(), dadoudou()

咱們用代碼表示是這樣的:

// 定義學生類
class Student {
    private:
    
    // 姓名
    string name;
    
    // 年齡
    int age;
    
    public:
    
    // 構造方法
    Student(string aName, int anAge) {
        name = aName;
        age = anAge;
    }
    
    // 吃飯
    void eat() {
        cout << name << "吃飯" << endl;
    }
    
    // 睡覺
    void sleep() {
        cout << name << "睡覺" << endl;
    }
    
    // 打豆豆
    void dadoudou() {
        cout << name << "打豆豆" << endl;
    }
};

int main(int argc, const char * argv[]) {
    // insert code here...
    
    // 使用構造方法建立學生對象,
    Student zhangsan("張三", 18);
    
    // 對象方法
    zhangsan.eat();
    zhangsan.sleep();
    zhangsan.dadoudou();

    // 還能夠繼續建立其它學生對象, 好比李四, 王五, 趙六等
    return 0;
}複製代碼

類和對象的關係

類至關於模具

對象至關於用模具所製造出來的東西

類是具備相同的屬性和操做的一組對象的集合

對象是這些集合當中的一個個體

這樣理解:

李四是一個學生 // 正確, 由於李四是對象, 而學生是類

學生就是李四 // 錯誤, 學生是一個羣體, 怎麼多是單個個體呢

封裝

一個經典的例子來加深咱們的理解吧!

電視機把各類部件都裝在機箱裏, 遙控器的全部部件也都裝在遙控器裏, 咱們經過遙控器操做電視機, 而不是咱們本身擺弄電視機的各個組件! 好比音量+, 音量-, 而不是我們去電視機裏擺弄線圈!

封裝性就是要求一個對象應該具有明確的功能, 並具備接口以便和其它對象相互做用, 對象內部的數據和代碼是受保護的, 外界不能訪問它們, 只能對象對外提供的接口能夠訪問它們. 增長獨立, 本身的數據只能由本身來操做.

類的封裝是經過定義的存取權限實現的, 分爲private和public, 對象的外部只能訪問對象的公有部分, 也就是public修飾的, 不能訪問對象的私有部分, 也就是private修飾的.

繼承

繼承是一個類能夠得到另外一個類的特性的機制

像這樣:

好比咱們有」人」這個類, 它具備姓名, 年齡這兩個屬性, 吃飯這個行爲

咱們又有」老師」這個類, 繼承自」人」類, 因此它有繼承過來的"姓名", "年齡"屬性, 還有本身所獨有的"職工編號"屬性, 有繼承過來的"吃飯"行爲, 還有本身所獨有的"講課"行爲.

咱們又有」學生」這個類, 繼承自」人」類, 因此它有繼承過來的"姓名", "年齡"屬性, 還有本身所獨有的"學號"屬性, 有繼承過來的"吃飯"行爲, 還有本身所獨有的"聽課"行爲.

總結

子類只需定義它所特有的特徵, 而共享父類的特徵

多態性

不一樣的對象能夠調用相同名稱的函數, 但可致使徹底不一樣的行爲的現象稱爲多態性.

在C++中, 多態性分爲兩種, 一種稱爲編譯時多態, 另外一種爲運行時多態

編譯時多態

也就是函數重載. 是指同一個函數名能夠對應着多個函數的實現, 具體調用哪一個函數由參數個數, 參數類型等來決定

運行時多態

也就是虛函數. 在定義了虛函數後, 能夠在基類的派生類中對虛函數從新定義, 以實現所想要的功能

使用類和對象

使用string對象

必須包含該類的頭文件, #include <string>

 像這樣:

String str = 「RayLee」; // 等價於 String str(「RayLee」);
複製代碼

在字符串的末尾系統會加上’’\0」字符來表示字符串的結束, 可是在計算字符串長度的時候不包含'\0'

像這樣:

String str2 = ‘A’; // 錯誤, str2是字符串對象, 不能賦值爲字符

咱們能夠把字符串當作是字符數組

因此咱們能夠這麼使用

// 字符串對象
string str = "RayLee";

// 輸出字符串中的每一個字符, 其中size()爲string對象的成員函數, 返回字符串長度
for (int i = 0; i < str.size(); i++) {
    cout << str[i] << endl;
}
複製代碼

字符串鏈接符號 +

做用: 將兩個字符串或者字符串與字符拼接起來

像這樣:

// 兩個字符串拼接
string str = "RayLee";
string str2 = " is a student!";
string str3 = str + str2;
cout << str3 << endl;

// 字符串跟字符拼接
str3 = str + '!';
cout << str3 << endl;

// 現個字符相拼接是不行的
str3 = 'a' + '?'; // 錯誤, 這樣的話就不是拼接了, 就是加法運算啦複製代碼

使用string類的典型成員函數

string str = "Hello, World!";
cout << str << endl;

// size()函數: 給定字符串的長度
unsigned long size = str.size();
cout << "字符串長度: " << size << endl;

// find(要查找的字符串, 開始查找的起始位置)函數: 要查找的字符串在給定字符串的起始位置
unsigned long result = str.find("lll");
if (result >= size) {
    cout << "沒有查找到該字符串" << endl;
} else {
    cout << "字符串起始位置爲: " << result << endl;
}

// substr(起始位置, 截取長度)函數: 給定字符串的子串
string subStr = str.substr(2, 8);
cout << "截取的字符串: " <<  subStr << endl;

// getline()函數: 從cin對象中讀出一行給string對象
string inputStr;
getline(cin, inputStr, '\n');
cout << inputStr << endl;

// swap()交換函數: 將兩個string對象的內容進行交換
string str1 = "I am a student!";
string str2 = "You are a teacher!";
cout << "交換前: " << str1 << " " << str2 << endl;
str1.swap(str2);
cout << "交換後: " << str1 << " " << str2 << endl;複製代碼

面向過程和麪向對象不是對立的, 面向對象是創建在面向過程的基礎上的, 它們是相互依存的, 面向過程關注於解決問題的步驟, 而面向對象關注於解決問題中出現的對象, 而對象中則封裝瞭解決問題的步驟, 面向對象是更高級的語言, 但它是依賴於面向過程而存在的, 隨着計算機科學與技術的發展, 出現更高級的語言也說不定呢?

本系列文章會持續更新! 你們踊躍的留下本身的腳印吧!

👣👣👣👣👣👣👣👣