构造函数和析构函数

1、构造函数

　　a、C++中与类名相同的成员函数叫构造函数

　　b、定义时可以有参数

　　c、没有任何返回类型的声明（void也没有）

　　d、自动调用和手动调用

 

2、析构函数

　　a、清理对象的特殊成员函数，语法：~ClassName()

　　 b、没有参数，没有任何类型的返回类型的声明

　　 c、对象被销毁时自动被调用

 

3、构造函数的分类

 

//有参数构造函数的三种调用方法
class Test
{
private:
    int a;
    int b;

public:
    
    //无参数构造函数  --》调用：Test t1;
    Test()
    {
        ;
    }
    
    //带参数的构造函数  -->调用：Test t1(1,2)
    Test(int a, int b)
    {
        ;
    }
    //赋值构造函数  -->手动调用：Test t1 = Test(1, 2) 匿名对象
    Test(const Test &obj)
    {
        ;
    }

public:
    void init(int _a, int _b)
    {
        a = _a;
        b = _b;
    }
};

 

 

4、copy构造函数4种调用场景

 

       
//第一种：
         AA a1; //变量定义
    
    //赋值构造函数的第一个应用场景
    //用对象1 初始化 对象2 
    AA a2 = a1; //定义变量并初始化 //初始化法     

第二种：

    AA a1(10); //变量定义

    //赋值构造函数的第一个应用场景
    //用对象1 初始化 对象2 
    AA a2(a1); //定义变量并初始化 //括号法


第三种：

#include "iostream"
using namespace std;

class Location 
{ 
public:
    Location( int xx = 0 , int yy = 0 ) 
    { 
        X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ; 
    }
    Location( const Location & p )         //复制构造函数
    { 
        X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;  
    }
    ~Location() 
    { 
        cout << X << "," << Y << " Object destroyed." << endl ; 
    }
    int  GetX () { return X ; }        int GetY () { return Y ; }
private :   int  X , Y ;
} ;

//
void f ( Location  p )   
{ 
    cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ; 
}

void mainobjplay()
{  
    Location A ( 1, 2 ) ;  //形参是一个元素，函数调用，会执行实参变量初始化形参变量
    f ( A ) ;
} 

void main()
{  
    mainobjplay();
    system("pause");
}

第四种：

第四个应用场景
#include "iostream"
using namespace std;
class Location 
{ 
public:
    Location( int xx = 0 , int yy = 0 ) 
    { 
        X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ; 
    }
    Location( const Location & p )         //复制构造函数
    { 
        X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;  
    }
    ~Location() 
    { 
        cout << X << "," << Y << " Object destroyed." << endl ; 
    }
    int  GetX () { return X ; }        int GetY () { return Y ; }
private :   int  X , Y ;
} ;

//alt + f8 排版
void f ( Location  p )   
{ 
    cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ; 
}

Location g()
{
    Location A(1, 2);
    return A;
}

//对象初始化操作 和 =等号操作 是两个不同的概念
//匿名对象的去和留，关键看，返回时如何接
void mainobjplay()
{  
    //若返回的匿名对象，赋值给另外一个同类型的对象，那么匿名对象会被析构
    //Location B;
    //B = g();  //用匿名对象 赋值 给B对象，然后匿名对象析构

    //若返回的匿名对象，来初始化另外一个同类型的对象，那么匿名对象会直接转成新的对象
    Location B = g();
    
} 

void main()
{  
    mainobjplay();
    system("pause");
}

   

 

 

 

　　

 

 

 

 5、对象初始化列表

　　a、原因：如果我们有一个类成员，它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，

　　　　没有默认构造函数。这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，

　　　　如果没有初始化列表，那么他将无法完成第一步，就会报错。

 

#include "iostream"
using namespace std;

class ABC
{
public:
    ABC(int a, int b, int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
        printf("a:%d,b:%d,c:%d \n", a, b, c);
        printf("ABC construct ..\n");
    }
    ~ABC()
    {
        printf("a:%d,b:%d,c:%d \n", a, b, c);
        printf("~ABC() ..\n");
    }
protected:
private:
    int a;
    int b;
    int c;
};


class MyD
{
public:
    MyD():abc1(1,2,3),abc2(4,5,6),m(100)//调用的顺序与定义时的顺序有关系
    //MyD()
    {
        cout<<"MyD()"<<endl;
    }
    ~MyD()
    {
        cout<<"~MyD()"<<endl;
    }

protected:
private:
    ABC abc1; //c++编译器不知道如何构造abc1
    ABC abc2;
    const int m;
};


int run()
{
    MyD myD;
    return 0;
}

int main_dem03()
{
    
    run();
    system("pause");
    return 0;
}