构造函数与析构函数

 

一、构造函数

名字与类名相同,可以有参数,不能有返回值(void也不行)

作用:对对象进行初始化,给成员变量赋值。默认的构造函数无参数,不进行任何操作。

对象生成时构造函数自动被调用,一旦对象生成,再也不能在其上执行构造函数。

// 默认的构造函数
 Sale() {}
// 后面补充函数体,注意最后的;
 Sale();
// 最常见:初始值列表,起到给数据成员赋值作用
// 这样就初始化了,否则只有定义是不够的
 Sale(string& s): bookNo(s) {}

 例子

frame.h内:!!!注意没出现函数定义{}时()后面要加;
Frame();
Frame(long id, double time_stamp,SE3 T_c_w=SE3(), Camera::Ptr camera=null, Mat color=Mat() );

frame.cpp内:!!!注意形参不能直接复制声明,只要参数即可无须具体的数值。
Frame::Frame():id_(-1),time_stamp_(-1),camera_(null) {}
Frame::Frame(long id, double time_stamp,SE3 T_c_w, Camera::Ptr camera, Mat color):id_(id),time_stamp_(time_stamp),T_c_w_(T_c_w),camera_(camera),color_(color) {}

默认构造函数 

//默认的构造函数
class complex
{
private:
	double real, imag;
pbulic:
	void set(double r, double i);
};//编译器自动生成默认构造函数

complex c1;//生成对象时,默认构造函数被调用;
complex *pc = new complex;//默认构造函数被调用

有参数的构造函数

class complex
{
private:
	double real, imag;
pbulic:
	complex(double r, double i=0);
};

complex::complex(double r, double i)
{
	real = r; imag = i;
}

complex c1;//error,缺少构造函数的参数,没法对对象c1初始化
complex c1(2)//OK,第二个参数可以缺省,r=2,i=0

一个类有多个构造函数,形成重载的关系

class complex
{
private:
	double real, imag;
public:
	void set(double r, double i);
	complex(double r, double i);//声明构造函数
	complex(double r);
	complex(complex c1, complex c2);
};

//定义构造函数
complex::complex(double r, double i)
{
	real = r; imag = i;
}
complex::complex(double r)
{
	real = r; imag = 0;
}
complex::complex(complex c1, complex c2);
{
	real = c1.real + c2.real;
	imag = c1.imag + c2.imag;
}
complex c1(2), c2(1, 0), c3(c1,c2)
//c1(2)选择第二个,整型可以自动转成double

注意:(1)每建立一个对象,就调用一次构造函数;

(2)构造函数没有返回值,因此也没有类型,作用只是对对象进行初始化;

(3)构造函数不需要被用户调用,也不能被用户调用。

三、复制构造函数(copy constructor)

定义:只有一个参数,即对同类对象的引用。X::X ( X &)或者 X::X( const X &);

//如果定义自己的复制构造函数,默认的复制构造函数将不存在
class complex
{
public:
	double real, imag;
	complex(){}
	complex(const complex &c)//定义复制构造函数
	{
		real = c.real;//被初始化对象的实部和参数的实部一样
		imag = c.imag;
		cout << "copy constructor called";//复制构造函数内部不一定只有复制,可以自己加
	}
};
complex c1;
complex c2(c1);

复制构造函数起作用三种情况

//一个对象去初始化同类的另一个对象
complex c2(c1);
complex c2 = c1;//初始化语句,非赋值语句

//某函数一个参数是类A的对象,那么这个函数被调用时,类A的复制构造函数将被调用
class A
{
public:
	A(){};
	A(A &a)
	{
		cout << "copy constructor called" << endl;//没有做复制的工作
	}
};

void func(A a1){}//形参a1是类A的对象,形参a1是由复制构造函数初始化的
int main()
{
	A a2;
	func(a2);
	return 0;
}

//函数的返回值是类A的对象,函数返回时,A的复制构造函数被调用
class A
{
public:
	int v;
	A(int n){ v = n; };
	A(const A&a)
	{
		v = a.v;
		cout << "copy constructor called" << endl;
	}
};

A.func()//func函数返回值类型为A
{
	A b(4);
	return b;
}
int main()
{
	cout << func().v << endl;//要先生成这个对象,
	return 0;
}

四、类型转换构造函数

特点:只有一个参数;不是复制构造函数;建立一个临时变量/临时对象。

class complex
{
public:
	double real, imag;
	complex(int i)//类型转换构造函数,只有一个参数
	{
		cout << "int constructor called" << endl;
		real = i; imag = 0;
	}
	complex(double r,double i)//构造函数,初始化实部虚部
	{
		real = r;imag=i
	}
};

int main()
{
	complex c1(7, 8);//第二个简单的构造函数
	complex c2 = 12;//对c2进行初始化(不是赋值)
	c1 = 9;//赋值语句,=两边类型不同,9被自动转换为一个临时complex对象,调用了类型转换构造函数
	cout << c1.real << "." << c1.imag << endl;
	return 0;
}

/*
输出
int constructor called 
int constructor called
9 0
*/

 

五、析构函数(destructor)

特点:名字与类名相同,没有参数和返回值,一个类最多只有一个析构函数

在对象消亡时自动被调用,释放分配的空间

class string
{
private:
	char *p;
public:
	string()
	{
		p = new char[10];
	}
	~string();//声明析构函数
};

string::~string()//定义析构函数
{
	delete[]p;
}

 

对象数组生命周期结束时,对象数组每个元素的析构函数都会被调用。

delete运算导致析构函数调用

ctest *ptest;
ptest = new ctest;//构造函数调用
delete ptest;//析构函数调用

ptest = new ctest[3];//构造函数调用三次
delete [] ptest;//析构函数调用三次

 

总结:

class demo
{
	int id;//默认的private
public:
	demo(int i)//构造函数
	{
		id = i;
		cout << "id=" << id << "constructed" << endl;
	}
	~demo()//析构函数
	{
		cout << "id=" << id << "destructed" << endl;
	}
};

demo d1(1);//全局d1变量
/*
输出id=1 constructed
*/
void func()
{
	static demo d2(2);//静态的最终才被消亡
	demo d3(3);
	cout << "func" << endl;
	/*
	输出 id=2 constructed;
	     id=3 constructed临时变量需要被析构掉
	     func
	     id=3 destructed
	*/
}

int main()
{
	demo d4(4);//局部d4对象
	/*
	输出id=4 constructed
	*/
	d4 = 6;//d4.id=6;赋值语句,右边变量通过类型转换构造函数,生成临时变量
	/*
	输出 id=6 constructed;
	     id=6 destructed;临时变量需要被析构掉
	*/
	cout << "main" << endl;
	{demo d5(5); }//作用域
	/*
	输出 id=5 constructed;
	     id=5 destructed;临时变量需要被析构掉
	*/
	func();

	cout << "main ends" << endl;
	return 0;
}
/*
输出 id=6 destructed
     id=2 destructed
	 id=1 destructed
	 先构造的最后消亡
*/
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值