類和物件下篇

前言
一、建構式再理解
1.1建構式體內賦值
1.2初始化串列
1.3 只能在初始化串列初始化的變數
1.4explicit關鍵字
二、static C/C++
2.1static成員
2.2 特性
三、C++11成員初始化新用法
四、友元
五、內部類
六、有趣的面試題/知識點
- 6.1建構式和拷貝構造在一次程序中連續呼叫傳參的時候會被弄成一次建構式
6.2 下面函式誰先呼叫建構式
總結

前言

類和物件入門最后一篇啦！！！

一、建構式再理解

1.1建構式體內賦值

class Date
{
public:

	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
		//_year =1; 這就是重復賦值
	}
};

以日期類為例，我們在定義物件的時候會呼叫上述建構式，呼叫完建構式之后，物件中的成員變數都有一個初始值，但是不能將這個行為作為建構式的初始化，建構式體內的陳述句只能夠稱作為賦值，原因是因為：建構式體內是可以多次給一個成員變數賦值的，而初始化是只有一次的，

1.2初始化串列

看完上面就有一個問題了，那么我們的物件當中的成員變數初始化是在哪里完成的呢？答案：初始化串列

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
};

上面的代碼就是我們在初始化串列當中對成員變數進行初始化，使用方法就是以：作為開始，成員變數后加入括號，括號內部放初始值或者運算式 初始值可以是傳參的變數，運算式也可以是呼叫一個函式，如下：

class Stack
{
public:
	Stack()
		:a((int*)malloc(sizeof(int)))//這里的初始化！！！！
		,_size(0)
		,_capacity(1)
	{}
private:
	int* a;
	int _size;
	int _capacity;
};
int main()
{
	Stack s1;
	return 0;
}

上述的就是，但是其實我們并不推薦在建構式內部做有危險的事（malloc空間），因為如果malloc失敗之后，這個物件是否存在都是一個不知道的事，所以我們推薦再多一個InitStack()之類的函式
在這里插入圖片描述

1.3 只能在初始化串列初始化的變數

注意：有以下幾個成員變數只能在初始化串列當中初始化

1.參考成員變數
2.const成員變數
3.自定義型別成員（該類沒有默認建構式，即不傳參沒辦法創建該物件）

class B
{
public:
	B(int b)
	{
		cout << "B(int b)";
	}
};
class A
{
public:
	A(int a,int b)
	:_a(a)//& 需要一個變數，所以這里不能給常數喲 int& a = a
	,_b(b)//這個可以給變數和常數，const修飾的變數為常變數，const int _b=b
	,_bb(1)//這里可以理解為 B _bb(1)
	{}
private:
	int& _a;//我是參考物件
	const int _b;//我是const物件
	B _bb;//我是沒有默認建構式的物件
};
int main()
{
	A a(1,2);
	return 0;
}

以上就是幾種情況的說明，
說明：我們在c++當中，推薦使用用初始化串列對成員變數進行初始化，原因：不管你有沒有寫，都是會先走一遍初始化串列，自定義物件就是在這個程序呼叫建構式的，我們可以把這個地方當做成員變數的定義的地方，用類創建物件則為物件實體化的地方，

1.4explicit關鍵字

這個關鍵字的作用就是防止我們通過隱式型別轉換創建物件，
因為對于單引數的建構式，帶有型別轉換的功能，
我們通常在賦值的時候喜歡用一個值給一個物件賦值，編譯器在這個時候是會用我們的值先構造一個物件，再用這個構造出來的物件給原物件賦值，
explicit相當于打斷了用一個值構造物件這條路！

//}
class B
{
public:
	explicit B(int b)
	{
		cout << "B(int b)";
	}
};

int main()
{
	B b(1);
	B bb = 1;//error
	//若無explicit 則1會變成 B bb = B(1);類似這種形式

	return 0;
}

驗證上述是否正確，下述代碼進行驗證：
實驗現象為無法正常呼叫則成功，由于編譯器會將1進行構造后面拷貝構造給bb進行優化成一次建構式，所以我們將建構式不允許隱式型別轉換，若攔截成功則說明正確，
在這里插入圖片描述

class B
{
public:
	B(const B& b)
	{
		cout << "B(const B& b)\n";
	}
	explicit B(int b)
	{
		cout << "B(int b)\n";
	}
};

int main()
{
	B b(1);
	B bb = 1;

	return 0;
}

c++11支持的新語法：

class B
{
public:
	B(const B& b)
	{
		cout << "B(const B& b)\n";
	}
	explicit B(int b,int c)
	{
		cout << "B(int b,int c)\n";
	}
};

int main()
{
	B b(1,2);
	B bb = {1,2};//2個引數的隱式構造，若無explicit則正常運行

	return 0;
}

二、static C/C++

回憶一下C語言當中的static的多種用途

1.static修飾區域變數，改變了區域變數的生命周期（本質上是改變了變數的存盤型別），從堆疊到靜態區里面（全域變數和static修飾的靜態變數都在靜態區）
2.extern可以聲明外部符號，但被static修飾的全域變數在其他源檔案中extern也用不了（實質上是把鏈接改變了）并不是修改作用域，改變的是鏈接屬性，全域變數具有外部連接屬性，static修飾后就變成了內部連接屬性，其他源檔案就不能連接到這個靜態的全域變數了，
3.static修飾函式也是改變鏈接屬性，只能在自己的源檔案使用了 static限制了檔案域，static成員變數在物件生成之前生成 static可以修飾全域變數，區域變數，函式如果沒有被static修飾可以用 extern int Add（int，int）；

上面概括一下從全域變數，區域變數，函式來理解static的作用，那么c++同時具備上述特征的同時，又多了以下這些

2.1static成員

static修飾的成員變數稱之為靜態成員變數；用static修飾的成員函式，稱為靜態成員函式，注意：靜態的成員便來那個一定要在類外進行初始化，原因：靜態成員變數不是屬于某個具體的物件，是屬于類的，所以類內部的建構式不能對static的成員變數進行初始化，

class B
{
public:
	static int GetStatica()//靜態成員函式
	{
		return a;
	}
private:
	static int a;//私有靜態成員變數
};
int B::a = 1;

int main()
{
	//cout << B::a;//外部無法訪問，訪問時需要突破類域和訪問限定符
	cout << B::GetStatica();
	return 0;
}

2.2 特性

靜態成員為所有類物件所共享，不屬于某個具體的實體
靜態成員變數必須在類外定義，定義時不添加static關鍵字
類靜態成員即可用類名::靜態成員或者物件.靜態成員來訪問
靜態成員函式沒有隱藏的this指標，不能訪問任何非靜態成員
靜態成員和類的普通成員一樣，也有public、protected、private3種訪問級別，也可以具有回傳值，意味著有時候需要突破訪問限定符，

三、C++11成員初始化新用法

class Stack
{
public:
	Stack()
	{
		a = nullptr;
		_size = 1;
		_capacity = 1;
	}
private:
	int* a= (int*)malloc(sizeof(int));//在這里進行給預設引數
	int _size = 0;
	int _capacity = 0;
};
int main()
{
	Stack s;
	
	return 0;
}

在這里插入圖片描述
可以看到，在還沒有建構式體內，已經在初始化串列當中進行初始化，當然，建構式體內可以進行成員變數的再賦值，
再次說明了初始化只有一次，賦值可以多次，

四、友元

友元：友元函式和友元類
友元的作用是突破了封裝的方式，但是友元會增加耦合度，突破了封裝，不適宜多用，以下給出一個常用的使用場景，
就是一個列印類的運算子多載，放在類內部實作會被cout占住this指標位，放到類外面無法訪問類的私有成員變數，友元打破了限定符的作用！！

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& out,const Date& d)
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}
int main()
{
	Date d1;
	//cout << d1;我們常用的使用，想對一個物件進行它的列印但是這里cout占據了我們的this指標
	//所以我們只能夠使用全域operator<<，但是卻訪問不到私有的成員變數
	//兩種解決方案，Date內部提供訪問成員變數的函式，第二種就是用我們現在要的友元
	cout << d1;

	return 0;
}

一個函式可以是多個類的友元函式，但是記得前置宣告，

class B;
class A;
int Sub(const A& a, const B& b);

class A
{
	//注意把class B的宣告放在前面
	friend int Sub(const A& a, const B& b);
private:
	int a=1;
};
class B
{
	friend int Sub(const A& a, const B& b);
private:
	int b=1;
};
int Sub(const A& a,const B& b)
{
	return a.a - b.b;
}
int main()
{
	A a;
	B b;
	cout<<Sub(a,b);
	return 0;
}

1.友元不是類的成員函式，沒有this指標，所以也無法給this指標加上const
2.友元可以訪問類的保護變數和私有變數和公有變數
3.友元函式可以在類的任意地方宣告，不受到類的訪問限定符限制
4.一個函式可以是多個類的友元函式
5.友元函式的呼叫和普通函式的呼叫相同

五、內部類

當一個類A定義在另一個類B的內部，則將A稱之為內部類，注意此時這個內部類是一個獨立的類，他并不屬于外部類的，但是在外部類可以定義這個類的物件（默認已經突破類域了），但是不能通過定義外部類的物件來呼叫內部類的成員變數或者函式，
并且B類默認是A類的友元，B可以訪問A的所有變數和函式，但是B不能對A有操作，
比如家中的點時工，在你家做衛生作業，他可能會用到你家的拖把，抹布，但是你卻不會動他家的東西，內部類就是一個幫外部類干活的這樣一個存在，

特性：

內部類可以定義在外部類的public、protected、private都是可以的，
注意內部類可以直接訪問外部類中的static、列舉成員，不需要外部類的物件/類名，
sizeof(外部類)=外部類，和內部類沒有任何關系，

劍指offer64 求1+2+3+…+n
這道題就我們改成有類部類來解
在這里插入圖片描述

class Solution {
public:
    private:
    //這個類相當于成員函式
    class A
    {
        public:
        A()
        {
            ret += sub;
            sub++;
        }
      
    };
    public:
    static int sub;
    static int ret;
    
    int Sum_Solution(int n) {
        A a[n];
       return ret;
    }
};
int Solution::sub = 1;
int Solution::ret = 0;

題中，A類是幫我們進行累次加法運算的 工具類，當然只是一個說法，我們可以利用這個類，幫我們Solution類達到1+…+n的操作，其中A類可以直接訪問Solution的成員變數，

六、有趣的面試題/知識點

6.1建構式和拷貝構造在一次程序中連續呼叫傳參的時候會被弄成一次建構式

回傳值立馬當作引數傳遞，當成拷貝構造會優化
或者回傳值當作拷貝構造會優化

class Date
{
public:
	//d1(d2)
	Date(const Date& d)
	{
		cout << "Date(const Date& d)\n";
	}

	Date()
	{
		cout << "Date()\n";
	}
private:
};
Date func(Date d)
{
	Date d2(d);
	return d2;
}
int main()
{
	Date d2 = func(Date());
	return 0;
}

在這里插入圖片描述
一般人可能就會認為是以上幾種，但是我們程式一跑，卻要比我們想的少了兩個，
原因
注意，func物件return的時候不是用d2return，因為d2再func的堆疊幀，一般回傳值是4/8個位元組由暫存器回傳，大的就在main堆疊幀當中開辟一個新的空間，
在這里插入圖片描述

6.2 下面函式誰先呼叫建構式

class A
{
public:
	A()
	{
		cout << "A()\n";
	}
	~A()
	{
		cout << "~A()\n";
	}
};
class B
{
public:
	B()
	{
		cout << "B()\n";
	}
	~B()
	{
		cout << "~B()\n";
	}
};
class C
{
public:
	C()
	{
		cout << "C()\n";
	}
	~C()
	{
		cout << "~C()\n";
	}
};
class D
{
public:
	D()
	{
		cout << "D()\n";
	}
	~D()
	{
		cout << "~D()\n";
	}
};
class E
{
public:
	E()
	{
		cout << "E()\n";
	}
	~E()
	{
		cout << "~E()\n";
	}
};
void fun()
{
	B b;
	C c;
	static D d;
}
void fun2()
{
	static E e;
}
A aa;
int main()
{
	fun();
	fun2();
	return 0;
}

給定如上的一組函式，你能否快速判斷出誰先構造誰先析構呢，
在這里插入圖片描述

結論1：先構造的后析構
結論2：可以想象成每個域當中區域變數有一個堆疊，然后全部域的全域變數和靜態變數共享一個堆疊，先構造的后面才被拿出來析構，

區域域當中的都會比靜態的先析構，定義在靜態庫當中的也是先定義后析構，如同堆疊，在這里插入圖片描述

總結

下一章節講述c/c++當中的記憶體模型，看到這里還不給一個三連嗎?

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/335578.html

標籤：其他

上一篇：五萬字，快速讀完《圖解TCP/IP》核心內容！！！（建議收藏）

下一篇：奇怪的“json.decoder.JSONDecodeError：期望值：第1行第1列（字符0）”

【C++從0到1】新手都能看懂的C++入門（下篇）類入門，建議收藏！！！