友元函數<<的模板化

1、構造函數的一種使用

int main(void){
    //Test t1 = 10;// 在構造函數中尋找只有一個參數的
    
    //手動的調用構造函數;
    Test t2 = Test(1, 2);  //直接調用構造函數--->匿名對象;
    //直接調用Test的有參構造函數,初始化t2對象;  只會調用一次構造函數(直接把匿名對象轉成t2);
    
}

2、構造與賦值語句

Test g(){
    
    //返回為對象,我就給你返回一個新的對象(匿名對象);
}

int main(void){
    Test t1(1, 2); 
    Test t2; 

    Test t3 = t1; //用t1初始化t3,調用拷貝構造函數;
    Test t3(t1);
    t2 = t1; //利用t1給t2賦值,調用賦值語句;

    Test m = g(); //函數的返回值為對象,用匿名對象初始化m,此時C++編譯器將直接把匿名對象轉化為有名對象m;
    m = g();//此時匿名對象將沒有用,賦值完成,沒有轉正,將被析構

}

//在定義類時,只要你寫了構造函數,則必須要用你自己寫的,此時C++編譯器將不會給你提供默認的構造和拷貝構造函
數

3、構造函數的執行順序

  執行順序：先執行被組合對象的構造函數,如果有多個,按定義順序執行,而不是按初始化列表的順序執行;
  析構函數的調用順序相反;

  初始化列表用來給const屬性賦值;

代碼如下：

#include<iostream>
using namespace std;

class A{
    public:
        A(int a){ 
            m = a;
        }   
    private:
        int m;
};
    //在構造中調用構造函數是一種危險的行為,里面是一個匿名對象;用完立即調用析構,
    //參數列表也可以在拷貝構造函數上面使用;
class B{
    public:  //構造函數的初始化列表：解決,在B類中,組合了A類對象,
            //根據構造函數的規則,寫了A類的構造函數,必須要用;
        B(int q, int a, int b, int c) : a1(b), a2(c), c(0){
            x = q;
            y = a;
        }   
    //執行順序：先執行被組合對象的構造函數,如果有多個,按定義順序執行,而不是按初始化列表的順序執行;
    //析構函數的調用順序相反;
    //構造調用順序：a1、a2、b
    //初始化列表用來給const屬性賦值;
    private:
        int x;
        int y;
        A a1;
        A a2;
        const int c;  //常量c必須初始化(通過參數列表)
};

int main(void){
    B b(1, 2, 3, 4);
}

4、new和delete

  new能執行類的構造函數,delete能行類的析構函數；

  malloc free new delete可以互換使用,只不過new先開辟空間-->調用構造；delete--->先析構,在釋放空間;

5、static

  靜態成員不占這個類的字節的大小;------->不屬于這個實例的，相當于全局變量；

(1)、代碼如下：

#include<iostream>
using namespace std;

class A{
    public:
        A(){}
        int getD(){
            return d;
        }
        void Add(){
            d++;
        }   
        static void getC(){ //靜態成員函數;
            //靜態方法只能調用靜態的成員、函數;
            cout<<"d:"<<d<<endl;

        }   
    private:
        int a;
        int b;
        int c;
        static int d;  //靜態成員變量
};

int A::d = 10; 

int main(void){
    A a;
    cout<<a.getD()<<endl;
    A::getC();

    cout<<sizeof(a)<<endl; //靜態成員不占這個類的字節的大小;
}

(2)、運行結果：

6、賦值語句(重載=運算符難點)
  i>、先把舊的內存釋放掉；
  ii>、返回一個引用;  為了支持連等;
  iii>、根據大小分配內存;

7、繼承中的字節大小

  子類繼承父類,在訪問上有所限制,但是在內存空間上對屬性成員是全部的繼承了下來;靜態變量在全局區,所以對靜態變量不計入字節大小的計算;

  class M{};//空的類,占一個標示,1字節;

8、函數模板

  普通函數的調用：可以進行隱式的類型轉換
  函數模版的調用：將嚴格按照類型進行匹配,不會進行自動類型轉換;

9、友元函數的模板化

對友元函數實現<<運算符重載

(1)、代碼如下：

#include<iostream>
using namespace std;


//結論：友元函數的類模版比較復雜;

template<typename Type>
class Complex; //類的前置聲明
template<typename Type>
ostream& operator<<(ostream &out, const Complex<Type> &c);//友元函數的前置聲明


template<typename Type>
class Complex{
    public:
        friend ostream& operator<<<Type>(ostream &out, const Complex<Type> &c); //對<<的后面加上<Type>
;進行友元函數的模版化;
        Complex(Type a, Type b); 
        Complex(const Complex &c){}
        Complex& operator=(const Complex &c){}
        ~Complex(){}
    public:
        void printComplex();
        Complex operator+(const Complex &c);
    private:
        Type a;
        Type b;
};

//成員函數實現 + 
template<typename Type>
Complex<Type>::Complex(Type a, Type b){
    this->a = a;
    this->b = b;
}
template<typename Type>
void Complex<Type>::printComplex(){
    cout<<"a:"<<a<<" b:"<<b<<endl;

}
template<typename Type>
Complex<Type> Complex<Type>::operator+(const Complex<Type> &c){
    return Complex(a+c.a, b+c.b);
}

//友元函數實現<<運算符重載
template<typename Type>
ostream& operator<<(ostream &out, const Complex<Type> &c){
    out<<"("<<c.a<<", "<<c.b<<")";

    return out;   
}
int main(void){
    Complex<int> c1(1, 2);
    Complex<int> c2(3, 4);
    Complex<int> c3 = c1 + c2;
    cout<<c3<<endl;
    c3.printComplex();

    return 0;
}

(2)、運行結果