构造函数_析构函数_拷贝构造函数

一、构造函数

1、简单构造函数

        构造函数是在创建对象时，使用给定的值将对象初始化。

        构造函数是类的成员函数，必须与类名相同。

#include <iostream>

using namespace std;

class TestA
{
private:
    int a, b;
public:
    TestA(int x, int y)
    {
        a = x;
        b = y;
        cout << "我是构造函数" << endl;
    }
    void disp()
    {
        cout << "x=" << a << " y=" << b << endl;
    }
};

int main()
{
    TestA obja(10,20);
    obja.disp();


    return 0;
}

2、构造函数的重载

        在定义构造函数时，不能指定返回值类型（void、int等等）。

        一个类可以有多个构造函数（重载）。

        

#include <iostream>

using namespace std;

class TestA
{
private:
    int a, b;
public:
    TestA(int x)
    {
        a = x;
        b = 0;
        cout << "我是全局初始化构造函数" << endl<<endl;
    }
    TestA(int x, int y)
    {
        a = x;
        b = y;
        cout << "我是局部初始化构造函数" << endl;
    }
    void disp()
    {
        cout << "x=" << a << " y=" << b << endl;
    }
};

TestA obja(10);

int main()
{
    TestA objb(10, 20);

    return 0;
}

3、缺省的构造函数

        在定义类时，如果没有定义类的构造函数，编译器就自动生产一个缺省的构造函数

                为：ClassName：ClassName（）{ }

        其中缺省的构造函数对成名变量时没有赋值的。

#include <iostream>

using namespace std;

class TestA
{
private:
    int a, b;
public:
    TestA()
    {
        cout << "缺省的构造函数" << endl;
    }
    void setab(int x, int y)
    {
        a = x;
        b = y;
    }
    void disp()
    {
        cout << "x=" << a << " y=" << b << endl;
    }
};

int main()
{
    TestA obja, objb;

    obja.setab(10, 20);
    obja.disp();

    objb.disp();

    return 0;
}

4、构造函数与new

        可以与new来动态创建对象，但是要记得delete。

#include <iostream>

using namespace std;

class TestA
{
private:
    int a, b;
public:
    TestA(int x, int y)
    {
        a = x;
        b = y;
        cout << "我是构造函数" << endl;
    }
    void disp()
    {
        cout << "x=" << a << " y=" << b << endl;
    }
};

int main()
{
    TestA* pobja;
    pobja = new TestA(10, 20);
    pobja->disp();

    delete pobja;

    return 0;
}

二、析构函数

1、析构函数

        析构函数的作用与构造函数相反，在对象生命周期结束时，释放系统为对象分配的内存空间。

        格式为~ClassName（）{ }

        析构函数不能有任何参数以及返回值。且前面得加~。

#include <iostream>

using namespace std;

class TestA
{
private:
    int a, b;
public:
    TestA()
    {
        cout << "我是缺省的构造函数" << endl;
    }
    TestA(int x, int y)
    {
        a = x;
        b = y;
        cout << "我是构造函数" << endl;
    }
    ~TestA()
    {
        cout << "我是析构函数" << endl;
    }

};

int main()
{
    TestA obja(10, 20);

    TestA objb;


    return 0;
}

2、为啥用析构函数

        当我们在程序中，new了一个对象，就应该在类中定义析构函数。

       

#include <iostream>

using namespace std;

class TestA
{
private:
    int* pa;
public:
    TestA()
    {
        pa = new int(10);
        cout << "我是构造函数" << endl;
    }
    ~TestA() 
    {
        delete pa;
        cout << "我是析构函数" << endl;
    }
    void disp()
    {
        cout << "pa=" <<*pa<< endl;
    }

};

int main()
{
    TestA *pobja;
    pobja = new TestA();

    pobja->disp();

    delete pobja;

    return 0;
}

三、拷贝构造函数

1、拷贝构造函数

        拷贝构造函数是一种特殊的构造函数，通常用于：

                通过使用另一个同类型的对象来初始化新创建的对象；

                复制对象把它作为参数传递给函数；

                复制对象，并从函数返回这个函数。

        如果类中没有定义拷贝构造函数，编译器就自动定义一个。如果类中带有指针变量，并且有动态内存分配，则类中必须有一个拷贝构造函数。

#include <iostream>

using namespace std;

class TestA
{
private:
    int* ptr;
public:
    TestA(int a)
    {
        ptr = new int;
        *ptr = a;
        cout << "我是构造函数" << endl;
    }
    TestA(const TestA& obj)
    {
        ptr = new int;
        *ptr = *obj.ptr;
        cout << "我是拷贝构造函数" << endl;
    }
    ~TestA()
    {
        delete ptr;
        cout << "我是析构函数" << endl;
    }

    int getptr()
    {
        return *ptr;
    }

 
};

void disp(TestA obj)
{
    cout << "ptr = " << obj.getptr() << endl;
}

int main()
{
    TestA boj(19);
    
    disp(boj);

    return 0;
}