【c++】内联成员函数和重载成员函数｜构造函数

内联成员函数

• inline+成员函数
• 整个函数体出现在类定义内部

class B{
	//inline+成员函数
	inline void func1();
	//整个函数体出现在类定义内部
	void func2(){
	};
};
void B::func1(){}

成员函数的重载以及参数缺省

重载成员函数
成员函数带缺省参数

class Location{
	private:
		int x, y;
	public:
		void init(int x = 0, int y = 0);
		void valueX(int val){x = val;}
		int valueX(return x;)
};
void Location::init(int X, int Y){
	x = X;
	y = Y;
}
int main(){
	Location A;
	A.init(5);
	A.valueX(5);
	cout<<A.valueX();
	return 0;
}

使用缺省参数要注意避免有函数重载时的二义性

class Location{
	private:
		int x, y;
	public:
		void init(int x = 0, int y = 0);
		void valueX(int val = 0){x = val;}
		int valueX(return x;)
};
Location A;
A.valueX();//error，编译器无法判断调用哪个valueX

构造函数

成员函数的一种

• 名字和类名相同，可以有参数，不能有返回值（void也不行）
• 作用是对对象进行初始化，如给成员变量赋初值
• 如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数。默认构造函数无参数，不做任何操作。
• 如果定义了构造函数，则编译器不生成默认的无参数的构造函数。
• 对象生成时构造函数自动被调用，对象一旦生成，就再也不能在其上执行构造函数。
• 一个类可以有多个构造函数。

为什么需要构造函数：

1. 构造函数执行必要的初始化工作，有了构造函数就不必专门再写初始化函数，也不用担心忘记调用初始化函数。
2. 有时对象没被初始化就使用，会导致程序出错。

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

Complex c1;//默认构造函数被调用
Complex *pc = new Complex;//默认构造函数被调用

class Complex{
	private:
		double real, imag;
	public:
		void Complex(double r, double i = 0);
}
Complex::Complex(double r, double i){
	real = r;
	imag = i;
}
Complex c1;//error 缺少构造函数的参数
Complex *pc = new Complex;//error 缺少构造函数的参数
Complex c1(2);//ok
Complex c1(2, 4), c2(3, 5);
Complex *pc = new Complex(3,4);

可以有多个构造函数，参数个数或类型不同

class Complex{
	private:
		double real, imag;
	public:
		void Set(double r, double i = 0);
		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(3), c2(1, 0), c3(c1, c2);

构造函数在数组中的使用

class CSample{
	int x;
public:
	CSample(){
		cout<<"Constructor 1 Called"<<endl;
	}
	CSample(){
		x = n;
		cout<<"Constructor 2 Called"<<endl;
	}
}
int main(){
	CSample array1[2];
	//"Constructor 1 Called"
	//"Constructor 1 Called"
	CSample array2[2] = {4, 5};
	//"Constructor 2 Called"
	//"Constructor 2 Called"
	CSample array3[2] = {3};
	//"Constructor 2 Called"
	//"Constructor 1 Called"
	CSample *array4 = new CSample[2];
	//"Constructor 1 Called"
	//"Constructor 1 Called"
	delete []array4;
	return 0;
}

class Test{
	public:
		Test(int n){};
		Test(int n, int m){};
		Test(){};
};
Test array1[3] = {1, Test(1, 2)};
//三个元素分别用(1)(2)(3)
Test array2[3] = {Test(2, 3), Test(1, 2), 1};
//三个元素分别用(2)(2)(1)
Test *pArray[3] = {new Test(4), new Test(1, 2)};
//如果不进行初始化，没有等号右边的部分，pArray就是个指针数组，啥都没有
//有了等号右边的部分后，用new出来的元素的地址去初始化pArray这个指针数组
//所以前两个元素都被初始化了，指针指向了new出来的元素
//所以这条语句只生成了2个对象，最后一个指针是个未经初始化的指针