类的构造函数与析构函数

类的构造函数与析构函数

#include<iostream>

//所有的类默认都有一个构造函数，析构函数
//构造函数，重载，
//没有返回值，
class myclass
{
public:
	int num;
public:
	myclass()// :num(4)初始化第一种方式
	{
		//num = 10;初始化第二种方式
		std::cout << "class create";
	}
	myclass(int data) //构造函数可以重载
	{
		std::cout << "class create  by data";
		num = data;
	}
	~myclass()
	{
		std::cout << "class delete";
	}

}; 

void run()
{

	 myclass myclass1(10);//没有调用默认构造函数，调用重载的myclass(int data) 
	 myclass myclass2 = 101;//调用重载的myclass(int data) 

	myclass *p = new myclass(102);
	myclass *p2(new myclass(102));
	//p(new myclass(105)) × （）初始化的方式，只能进行初始化 不能再二次调用构造函数
	//p=new myclass(105);// √  =可以进行二次赋值

	std::cout << (*p).num << std::endl;//(*p).num 等价于p->num
	//std::cout << myclass1.num << std::endl;
}


void main1()
{

	run(); 
	int num = 4;//等价于int num(4);
	num = 4;
	int data(4);
	//data(5);
	std::cin.get();
}

explicit  关键字：控制函数不能采用类型转换

#include <iostream>
#include <array>


class  classobj
{
public:
	int num;
public:
	explicit  classobj(int data)  //explicit控制函数不能采用类型转换，同时不能使用()的方式进行类初始化。
	{
		this->num = data;
		std::cout << "被构造" << num << std::endl;
	}
	//classobj()
	//{
	//	std::cout << "被构造yuan" << num << std::endl;
	//}
	~classobj()
	{
		std::cout << "被销毁" << num << std::endl;
	}
protected:
private:
};


void main()
{
	//C 语言风格的数组，构造一个数组，销毁一个数组
	//classobj *p=new classobj[10];
    //delete []p;


	classobj obj(0);//单独独有构造函数
	classobj objx[3] = { classobj(0), classobj(1), classobj(2) };//C语言风格数组构造方式
	classobj(*ppobjA)[3] = &objx; //指向数组的指针
	classobj  *pobj ( new classobj(0)) ;


	classobj * ppobj[3];//数组，每一个元素都是指针
	ppobj[0] = new classobj(0);
	ppobj[1] = new classobj(1);
	ppobj[2] = new classobj(2);


	


	//classobj *p= new  classobj[10];
///	delete[]p;




	std::cin.get();


}


void main2222()
{
//	classobj  num = 5;//赋值号，类型转换
	//classobj  data(5);


	// classobj  obj;
	classobj obj(0);//创建对象必须调用合适的构造函数
	//classobj *p= new classobj;


	//C++ 风格数组的作用
	classobj * p = new classobj(5);
	std::array <classobj, 2 > myarray = { obj, *p };




	std::cin.get();








}

（）构造和=赋值的区别

#include<iostream>

//所有的类默认都有一个构造函数，析构函数
//构造函数，重载，
//没有返回值，
class myclass
{
public:
	int num;
public:
	myclass()// :num(4)初始化第一种方式
	{
		//num = 10;初始化第二种方式
		std::cout << "class create";
	}
	myclass(int data) //构造函数可以重载
	{
		std::cout << "class create  by data";
		num = data;
	}
	~myclass()
	{
		std::cout << "class delete";
	}

}; 

void run()
{

	 myclass myclass1(10);//没有调用默认构造函数，调用重载的myclass(int data) 
	 myclass myclass2 = 101;//调用重载的myclass(int data) 

	myclass *p = new myclass(102);
	myclass *p2(new myclass(102));
	//p(new myclass(105)) × （）初始化的方式，只能进行初始化 不能再二次调用构造函数
	//p=new myclass(105);// √  =可以进行二次赋值

	std::cout << (*p).num << std::endl;//(*p).num 等价于p->num
	//std::cout << myclass1.num << std::endl;
}


void main1()
{

	run(); 
	int num = 4;//等价于int num(4);
	num = 4;
	int data(4);
	//data(5);
	std::cin.get();
}