C++-06-构造函数_析构函数_拷贝构造函数

构造函数

//构造函数和析构函数都是在类体中说明的2种特殊成员函数。
//构造函数是在创建对象时，使用给定的值将对象初始化
//析构函数是在系统释放对象前，做一些善后工作
#include <iostream>
using namespace std;
class CTestA
{
public:
	CTestA(int a, int b)//定义构造函数的函数名必须与类名相同，主要作用是完成初始化对象的数据成员及其它的初始化工作不能指定函数返回值类型
	{
		x = a;
		y = b;
		cout << "x=" << x << ",y=" << y << endl << endl;
	}
	CTestA(int a)//定义多个构造函数，必须满足函数重载的原则
	{
		cout << "a=" << a << endl;
	}
	int sumxy()
	{
		return (x + y);
	}
private:
	double x, y;
};
int main()
{
	CTestA obja(56, 90);//只要程序运行，自动会初始化构造函数（自己会找到带有两个参数的构造函数）
	cout << "x+y=" << obja.sumxy() << endl;
	CTestA objb(30000);
	return 0;
}

//局部静态对象，全局对象，局部对象
//局部对象，每次定义对象时，都要调用构造函数
//静态对象，首次定义对象，调用构造函数（只调用一次构造函数）
//全局对象，在main函数执行之前调用构造函数
#include <iostream>
using namespace std;

class CTestA
{
public:
	CTestA()
	{
		x = 0, y = 0;
		cout << "\n初始化局部静态对象." << endl;
	}
	CTestA(double a)
	{
		x = a;
		y = 0;
		cout << "初始化全局对象." << endl;
	}
	CTestA(double a,double b)
	{
		x = a;
		y = b;
		cout << "初始化局部对象." << endl;
	}
private:
	double x, y;
};

CTestA objb(88.8);//定义全局对象，初始化优先级最高
void FuncTest()
{
	cout << "\n程序开始进入FuncTest()函数.\n\n";
	CTestA objc(10, 20);
	static CTestA objd;//初始化局部静态对象
}
int main()
{
	cout << "\n程序开始执行-->main()函数\n\n";
	CTestA obja(4.5, 6.5);//定义局部对象
	FuncTest();
	return 0;
}

//缺省的构造函数
#include <iostream>
using namespace std;
class CTestA
{
public:
    CTestA()
    {
        cout << "调用缺省构造函数.\n\n";
    }
    void setxy(int a, int b)
    {
        x = a;
        y = b;
    }
    void disp()
    {
        cout << "x=" << x << ",y=" << y << endl;
    }
private:
    double x, y;
};
int main()
{
    CTestA obja, objb;//产生对象时候，自动调用缺省的构造函数，不赋值
    obja.setxy(40, 90);
    cout << "obja对象结果为:\n";
    obja.disp();

    cout << "objb对象结果为:\n";
    objb.disp();//产生随机值
    return 0;
}

//构造函数与new运算符
//使用new运算符动态地建立对象
#include <iostream>
using namespace std;
class CTestA
{
public:
    CTestA()//缺省构造函数
    {
        x = 0;
        y = 0;
        cout << "调用缺省构造函数" << endl;
    }
    CTestA(double a, double b)//带参的构造函数
    {
        x = a;
        y = b;
        cout << "调用带参构造函数" << endl;
    }
    void dispxy()
    {
        cout << "x=" << x << ",y=" << y << endl << endl;
    }
private:
    double x, y;
};
int main()
{
    CTestA* pobja, * pobjb;//创建两个对象指针
    pobja = new CTestA;//用new动态开辟存储空间，调用缺省构造函数
    pobjb = new CTestA(200, 800);//用动态开辟对象存储空间，调用带参构造函数

    pobja->dispxy();
    pobjb->dispxy();

    delete pobja;
    delete pobjb;//用delete释放动态开辟存储空间
    return 0;
}

析构函数

//析构函数也是类的成员函数
//在对象的生命周期结束时，释放系统为对象分配的空间
#include <iostream>
using namespace std;
class CTestA
{
public:
    CTestA()
    {
        cout << "调用缺省构造函数" << endl;
    }
    CTestA(double a, double b)
    {
        x = a;
        y = b;
        cout << "调用带参构造函数" << endl;
    }
    ~CTestA()
    {
        cout << "调用析构函数" << endl;
    }
 
private:
    double x, y;
};
int main()
{
    CTestA obj1;
    CTestA obj2(5.6,70.8);
    CTestA obj3(10, 20);

    return 0;
}

//缺省的析构函数
#include <iostream>
using namespace std;
class CTestA
{
public:
    CTestA()
    {
        cout << "\n调用构造函数CTestA::CTestA()." << endl;
        pc = new int(10000);
        cout << *pc << endl;
    }

    ~CTestA()
    {
        delete pc;
        cout << "调用析构函数~CTestA::CTestA()." << endl;
    }

private:
    int* pc;
};
int main()
{
    CTestA* p1 = new CTestA;
    CTestA* p2 = (CTestA*)malloc(sizeof(CTestA));

    delete p1;//动态归还堆的空间
    free(p2);
    return 0;
}

//实现类型转换的构造函数
//同类型的对象可以相互赋值，相当于类中的数据成员相互赋值
//如果直接将数据赋给对象，所赋入的数据需要强制类型转换，这种转换需要调用构造函数
#include <iostream>
using namespace std;
class CTestA
{
public:
    CTestA(double a, double b)
    {
        x = a;
        y = b;
        cout << "调用带参构造函数" << endl;
    }
    ~CTestA()
    {
        cout << "调用析构函数" << endl;
    }
    void dispxy()
    {
        cout << x << "," << y << endl << endl;
    }
private:
    double x, y;
};
int main()
{
    CTestA obj1(2, 3);
    obj1.dispxy();
    obj1 = CTestA(90, 20);//通过类名强制转换
    obj1.dispxy();
   

    return 0;
}

拷贝构造函数

//拷贝构造函数
#include <iostream>
using namespace std;
class CTestA
{
private:
    int* ptr;

public:
    CTestA(int a);//构造函数
    CTestA(const CTestA& obj);//拷贝构造函数
    ~CTestA();//析构函数
    int getptr()
    {
        return *ptr;
    }
};
CTestA::CTestA(int a)
{
    cout << "调用构造函数." << endl;
    //为指针分配内存空间
    ptr = new int;
    *ptr = a;
}

CTestA::CTestA(const CTestA& obj)
{
    cout << "调用拷贝构造函数并为指针ptr分配内存空间" << endl;
    ptr = new int;
    *ptr = *obj.ptr;//拷贝值
}

CTestA::~CTestA()
{
    cout << "释放内存空间." << endl;
    delete ptr;
}
void disptr(CTestA obj)
{
    cout << "ptr的值为:" << obj.getptr() << endl;
}
int main()
{
    CTestA obj(5600);
    disptr(obj);
    return 0;
}