成员函数的访问权限
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函数只执行了一次