C++中的类（构造、析构）

成员函数的访问权限

class Trade{
private:
	double a;
	static double b;
public:
	Trade(double a){this->a = a;}
	double geta(){return a;}
	static double getb(){return b;} //静态成员函数中没有this指针
	double getRes1(){return a*b;} //静态成员函数不能访问非静态成员
};
double Trade::b = 0.08; //静态数据成员必须在类的内部声明，在类的外部初始化

在访问静态成员时，可以通过对象访问，也可以通过类访问

Trade::getb(); //类：：静态成员
Trade tr;
tr.getb();    //对象.静态成员
Trade * ptr = new Trade;
ptr->getb();     //对象指针->静态成员

const在类中的用法

class Baby{
private:
	const char gender;
	double weight;
public:
	Baby(double wgt,char gen):gender(gen),weight(wgt){}
	double getWeight() const {return weight;}
	char getGender() const{return gender;}
	void setWeight(double wgt){weight = wgt;}
};

• const数据成员必须通过构造函数的初始化列表初始化，初始化之后的值不能修改
• const成员函数不能在函数中修改类的数据成员

友元

是类的外部函数，友元函数能访问类的非公有成员

class Father{
private:
	int salary;
	int age;
public:
	Father(int salary,int age){
		this->salary = salary;
		this->age = age;
	}
	int getage() const{return age;}
	friend int getFa(Father &f); //友元函数
};
int getFa(Father &f){return f.salary;}

• 友元关系是单向的
• 友元关系是不能继承的

构造函数和析构函数

构造函数

• 创建对象时自动调用
• 没有返回类型
• 构造函数名与类名相同
• 不能使用return
• 可以重载，析构函数不能重载

class Square{
private:
	int length;
public:
	Square(){length = 0;}                      //无参构造函数
	Square(int length){this->length = length;} //有参构造函数
	void setquare(int length){this->length = length;}
	int area(){return length * length;}
};

• 类中没有声明构造函数时，系统才会生成一个无参的构造函数
• 显式的声明了一个构造函数之后，系统不会在生成默认的无参构造函数
  拷贝构造函数

class Square{
private:
	int * length;
public:
	Square(int len){
		length = (int *)malloc(sizeof(int));
		*length = len;
	}
	Square(const Square &obj){  //深拷贝构造函数
		length = (int *)malloc(sizeof(int));
		* length = * (obj.length);
	}
	void setlength(int len){* length = len;}
	int area(){return (*length) * (* length);}
	~Square(){  //析构函数
		free(length);
		length = NULL;
	}
};
Square cub1(5);
Square cub2(cub1);

如果没有深拷贝构造函数，在执行“ Square cub2(cub1); ”时，会默认做浅拷贝，代码如下：

Square(const Square &obj){this.length = obj.length};

如果执行浅拷贝，cub1和cub2中的指针都会指向同一内容，最终free函数会执行两次，malloc函数只执行了一次