类的构造函数与析构函数
#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();
}