一.const成員函式

const int a=10;
int b=a;

我知道const修飾的變數具有隻讀屬性，a具有隻讀屬性，不能修改直接通過a修改a，而b則可讀可寫。

int a=30;
const int*p=&a;

這裡的const修飾的是指標變數*p，限定定義指標所指向位置的內容*p，不允許*p=50，可以改變的是指標所指向的位置p。允許p=&b

int a=30;
int*const p=&a;

此時，const修飾p，即就是指標變數p只讀，指標指向位置被限定不允許p=&b，指標所指向的位置的內容可以改變允許*p=50

也就是p對比你會發現，僅僅是const和*的前後位置不同了而已。

上述複習了const修飾變數的用法，接下來我們看一下這段程式碼：

Time operator+(const Time &t) const
	{
		Time t1 = (*this);
		Time t2 = t;
		t1._minute += t2._minute;
		t1._minute += t2._minute;
		t1._second += t2._second;
		while (!(t1._second < 60))
		{
			t1._second -= 60;
			t1._minute += 1;
		}
		while (!(t1._minute <
 
 60))
		{
			t1._minute -= 60;
			t1._hour += 1;
		}
		while (!(t1._hour < 24))
			t1._hour -= 24;
		return t1;
	}
	void Show()const
	{
		cout << _hour << ':' << \
		_minute << ':' << _second << ':' << endl;
	}

在成員函式後面加const，const修飾this指標所修飾的物件，也就是保證這個const成員函式的物件在函式體內不會被改變。
重點思考：

二.行內函數

以inline修飾的函式叫做行內函數,編譯時C++編譯器會在呼叫行內函數的地方展開行內函數。省去函式壓棧的開銷，以空間換時間的做法。
1、**inline必須和函式定義放在一起才能成為行內函數，**僅將inline放在宣告前不起作用。
2、inline對編譯器來說只是建議，並非指令，編譯器會自行優化。
3、定義在類內的成員函式，預設為行內函數。
4、程式碼很長或者有迴圈或者遞迴不適宜使用行內函數。

inline void Show()
	{
		cout << _hour << ':' << \
		_minute << ':' << _second << ':' << endl;
	}

三.友元

友元類
整個類是另一個類的友元。友元類的每一個成員函式都是另一個類的友元函式，都可以訪問另一個類的保護或者私有資料成員。

class Time{
	friend class Date;
private:
	int _hour;
	int _minute;
	int _second;
};
class Date{
public:
	void Display()
	{
		cout << _year << ":" <<\
		 _month << ":"\
		  << _day << ":" \
		  << _t._hour << ":" \
		  << _t._minute << ":" \
		  << _t._second << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

友元類在一定程度上破壞了C++的封裝性，應該儘量少用。

友元函式

友元函式允許類外訪問該類的任何成員，就像成員函式一樣，友元函式用關鍵字friend說明。
1、友元函式不是類的成員函式。
2、友元函式可以通過訪問所有成員，私有和保護也一樣。

#include<iostream>
#include<assert.h>
using namespace std;

class Time{
public:
	friend void Show(const Time&d);

	Time(const int hour = 23, const int minute = 59, const int second = 59)
		:_hour(hour)
		, _minute(minute)
		, _second(second)
	{
		if (!Islegal(_hour, _minute, _second))
			assert(0);
	}
	Time(const Time&t)
		:_hour(t._hour)
		, _minute(t._minute)
		, _second(t._second)
	{
	}
	
	~Time()
	{}
private:
	bool Islegal(int&hour, int&minute, int&second)
	{
		if (hour >= 0 && hour < 24 && minute >= 0 && minute < 60 && second >= 0 && second < 60)
			return true;
		else
			return false;
	}
	int _hour;
	int _minute;
	int _second;
};

void Show(const Time&d)
{
	cout << d._hour << ':' << 
		d._minute << ':' << 
		d._second << ':' << endl;
}
int main()
{
	Time t1;
	Show(t1);
	system("pause");
	return 0;
}

這裡我們試著過載一下Time類的cin、cout

#include<iostream>

using namespace std;

class Time{
	int _hour;
	int _minute;
	int _second;
	
public:
	
	friend ostream& operator<<(ostream&out, const Time&t)
	{
		out << t._hour<<":" << t._minute <<":"<< t._second << endl;
		return out;
	}
	friend istream& operator>>(istream&in, Time&t)
	{
		cout << "請輸入年月日：" << endl;
		in >> t._hour;
		in >> t._minute;
		in >> t._second;
		return in;
	}
};

int main()
{
	Time t1;
	cin >> t1; 
	cout << t1;
	system("pause");
	return 0;
}

四.static成員

類的靜態成員
1、類裡邊static修飾的成員，稱為靜態成員。
2、類的靜態成員是該類的所有物件所共享。

靜態成員函式
靜態成員函式與普通成員函式的區別：
1、靜態成員函式沒有 this 指標，只能訪問靜態成員（包括靜態成員變數和靜態成員函式）。
2、普通成員函式有 this 指標，可以訪問類中的任意成員；而靜態成員函式沒有 this 指標。

#include <iostream>
using namespace std;

class Cpoint{
    public:
        static int value;
        static int num;
    Cpoint(int x,int y){
        xp=x;yp=y;
        value++;
        cout << "呼叫構造:" << value << endl;
    }

    ~Cpoint(){num++; cout << "呼叫析構:" << num << endl;}

    private:
    int xp,yp;
};

int Cpoint::value=0;
int Cpoint::num=0;
class CRect{
    public:
        CRect(int x1,int x2):mpt1(x1,x2),mpt2(x1,x2) {cout << "呼叫構造\n";}
        ~CRect(){cout << "呼叫析構\n";}
    private:
        Cpoint mpt1,mpt2;
};

int main()
{
    CRect p(10,20);
    cout << "Hello, world!" << endl;
    return 0;
}

五.N中構造拷貝構造的優化

#include<iostream>  
using namespace std;  
  
class Date  
{   
public :  
    Date()  
    {  
        cout<<"Date()" <<endl;  
    }  
  
    Date(const Date& d)  
    {  
        cout<<"Date(const Date& d)" <<endl;  
    }  
  
    Date& operator =(const Date& d )  
    {  
        cout<<"Date& operator=(const Date& d)"<< endl;  
        return *this ;  
    }  
  
    ~Date()  
    {  
        cout<<"~Date()" <<endl;  
    }  
};  
  
// 1.Date 物件做引數傳值 & 傳引用  
void fun1 (Date d)   
{}  
  
//void fun1(Date& d)  
//{}  
  
// 2.Date 物件做返回值傳值 & 傳引用  
Date fun2 ()   
{  
    Date d ;  
    return d ;  
}   
  
//Date& fun2()  
//{  
//  Date d ;  
//  return d ;  
//}  
  
// 3.Date 物件做臨時返回值傳值 &傳引用(編譯器優化問題)  
Date fun3 ()   
{  
    return Date ();  
}  
  
//Date& fun3()  
//{  
//  return Date ();  
//}  
  
void Test1()  
{  
    Date d1;  
    fun1(d1);  
}  
  
void Test2()  
{  
    Date d2 = fun2();  
}  
  
void Test3()  
{  
    Date d3;  
    d3 = fun3();  
}  

Test1

Test2

Test3

題目：

Test1中呼叫了___次AA的拷貝建構函式,___次AA的賦值運算子函式
的過載。 
Test2中呼叫了___次AA的拷貝建構函式,___次AA的賦值運算子函式
的過載。 
Test3中呼叫了___次AA的拷貝建構函式,___次AA的賦值運算子函式
的過載。 
class AA 
{}; 
AA f (AA a) 
{ 
 return a ; 
} 
void Test1 () 
{ 
 AA a1 ; 
 a1 = f(a1); 
} 
void Test2 () 
{ 
 AA a1 ; 
 AA a2 = f(a1); 
} 

void Test3 () 
{ 
 AA a1 ; 
 AA a2 = f(f(a1)); 
}