构造函数&&函数重载&&复合类&&析构函数

认识构造函数

构造函数特点：

• 构造函数是一种比较特殊的成员函数，用于创建并初始化对象。声明对象是构造函数会被编译器自动调用；
• 构造函数访问权限必须为共有；
• 构造函数名和类名相同；
• 构造函数没有返回值；
• 构造函数可以带参数，用于初始成员变量；

注意：如果不标明public里面的，程序默认为私有成员变量；

默认构造函数分两种：1.构造函数不带参数；2.构造函数带参数但参数都有默认值；
eg：

Circle();												//默认构造函数
Circle(float a=0,float b=0,float c=0);					//默认构造函数带参数有默认值
Circle(float a，float b,floay c);						//普通的构造函数

默认构造函数是指在声明对象时可以不传递参数，使用空值或默认值对对象进行初始化，而普通构造函数在声明对象时必须传递参数，否则普通构造函数的参数 （形参）没有值，编译出错；
注意：如果程序中无构造函数，那么编译器会提供一个空的默认构造函数，它不会对数据成员初始化；

在使用c++编程过程中，在构造函数进行类的初始化有两种方式：
1.

Ting(int a,int b,int c)
{
	x=a;
	y=b;
	z=c;	
}

Ting(int a,int b,int c):x(a),y(b),z(c){}

对类的成员函数进行初始化：1》效率更高，对类的成员函数来说；2》有些类型的成员变量必须使用初始化列表的形式初始化，如const成员、引用成员；3》在继承时，子类的构造函数初始化父类的成员时；

什么是函数重载？

在同一作用域中，可以有一组相同的函数名，不同参数列表的函数，这个函数被称为函数重载；不同的参数列表是指参数不同或参数的类型不同。

eg：

void fun();
void fun(int x);
void fun(int x,float y);

注意：如果只是函数的返回值类型不同，不能被称为函数重载
eg：

void fun();
int fun();

注意：
1.类中也能定义多个构造函数，但是必须勾成重载函数的条件；
2.声明对象的参数类型和个数要与构造函数的参数相匹配；

什么是复合类？

复合类也被称为组合类，是指将一个类的对象作为另一个类的成员变量；
eg：

#include <iostream>

using namespace std;

class Point
{
public:
	Point();
	Point(float _x,float _y);
	void print();
private:
	float x;
	float y;
};
Point::Point(){}
Point::Point(float _x,float _y)
{
	x=_x;
	y=_y;
}
void Point::print()
{
	cout<<"("<<x<<","<<y<<")"<<endl;
}
class Circle//复合类：一个类中包含另一个类的成员变量
{
public:
	Circle();
	Circle(float x,float y,float r);

	void setCircle(float r,Point p);//修改半径和圆心点
	void print();
private:
	//由一个点的对象+一个半径
	Point Center;//Center.x Center.y
	float radius;
};
Circle::Circle(){}
Circle::Circle(float x,float y,float r):Center(x,y),radius(r){}
void Circle::setCircle(float r,Point p)//修改半径和圆心点
{
	radius=r;
	Center=p;
}
void Circle::print()
{
	cout<<"radius:"<<radius<<endl;
	Center.print();
}
int main()
{
	Point p(5,7);
	p.print();
	Circle c;
	c.setCircle(1,p);
	c.print();
	return 0;
}

什么是析构函数？

创建对象时，系统会自动调用构造函数进行初始化工作，同样，在销毁对象时也会自动调用一个函数进行清洗工作（回收对象占用的内存空间）；这个函数就是性析构函数

虚构函数是一种特殊的成员函数，没有返回值，不用进行用户调用，而是在销毁对象的过程中自动调用；与构造函数不同的是eg：~Circle（）

特点：1》无返回值 2》不能有参数 3》不能被重载 4》必须共有
eg：

class Test
{
public:
	Test()
	{
		p=new int[5];
		for(int i=0;i<5;i++)
		{
			p[i]=i;
		}
	}
	~Test()
	{
		delete []p;
	}
	void print();
private:
	int *p;
};
void Test::print()
{
	for(int i=0;i<5;i++)
	{
		cout<<p[i]<<" ";
	}
	cout<<endl;
}
int main()
{
	Test t;
	t.print();
	return 0;
}

如果类中有指针成员变量，并且指针指向堆内存，必须显式的声明析构函数，释放指针指向的堆内存，否则会造成内存泄漏；