八、this指针、静态成员、成员对象和封闭类

1、this指针

1)this指针的作用

其作用就是指向成员函数所作用 的对象

非静态成员函数中可以直接使用this来代表指向该函数作用的对象的指针。

2）this指针和静态成员函数

静态成员函数中不能使用 this 指针！

因为静态成员函数并不具体作用与某个对象!

因此，静态成员函数的真实的参数的个数，就是程 序中写出的参数个数！

 

非静态成员函数的参数个数=所写参数个数+1；

2、静态成员

1）基本概念

 　　　　静态成员：在说明前面加了static关键字的成员。

例如：

class CRectangle
{
private:
int w, h;
static int nTotalArea; //静态成员变量
static int nTotalNumber;
public:
CRectangle(int w_,int h_);
~CRectangle();
static void PrintTotal(); //静态成员函数
};

　　　　普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。

注意：sizeof 运算符不会计算静态成员变量。

　　　　普通成员函数必须具体作用于某个对象，而静态成员 函数并不具体作用于某个对象。

　　　　因此静态成员不需要通过对象就能访问。

　　　　静态成员变量本质上是全局变量，哪怕一个对象都不存在，类 的静态成员变量也存在。

　　　　静态成员函数本质上是全局函数。

    　　　设置静态成员这种机制的目的是将和某些类紧密相关的全局变 量和函数写到类里面，看上去像一个整体，易于维护和理解。

2)如何访问静态成员

方法1：类名::成员名

方法2：对象名.成员名

方法3：指针->成员名

方法4：引用名.成员名

3）静态成员示例

考虑一个需要随时知道矩形总数和总面积的图形处理程序,可以用全局变量来记录总数和总面积

用静态成员将这两个变量封装进类中，就更容易 理解和维护

class CRectangle
{
　private:
　　int w, h;
　　static int nTotalArea;
　　static int nTotalNumber;
public:
　　CRectangle(int w_,int h_);
　　~CRectangle();
　　static void PrintTotal(); 
};

CRectangle::CRectangle(int w_,int h_)
{
　　w = w_;
　　h = h_;
　　nTotalNumber ++;
　　nTotalArea += w * h; 
}
CRectangle::~CRectangle()
{
　　nTotalNumber --;
　　nTotalArea -= w * h;
}
void CRectangle::PrintTotal()
{
　　cout << nTotalNumber << "," << nTotalArea << endl; 
}

int CRectangle::nTotalNumber = 0;
int CRectangle::nTotalArea = 0;
// 必须在定义类的文件中对静态成员变量进行一次说明
//或初始化。否则编译能通过，链接不能通过。
int main()
{
　　CRectangle r1(3,3), r2(2,2);
　　//cout << CRectangle::nTotalNumber; // Wrong , 私有
　　CRectangle::PrintTotal();
　　r1.PrintTotal();
　　return 0;
}
输出结果：
2，13
2，13

4）注意事项

• 在静态成员函数中，不能访问非静态成员变量， 也不能调用非静态成员函数。
• 在使用CRectangle类时，有时会调用复制构造函数 生成临时的隐藏的CRectangle对象

　　　　用一个以CRectangle类对象作为参数的函数时， 调用一个以CRectangle类对象作为返回值的函数时

临时对象在消亡时会调用析构函数，减少nTotalNumber 和 nTotalArea的值，可是这些临时对象在生成时却没有增加 nTotalNumber 和 nTotalArea的值。

解决办法：为CRectangle类写一个复制构造函数。

CRectangle :: CRectangle(CRectangle & r )

{ w = r.w; h = r.h; nTotalNumber ++; nTotalArea += w * h; }

 3、成员对象和封闭类

1）基本概念

成员对象：当一个类的成员是另一个类的对象时，这个对象就叫成员对象。概括的说，就是一个类的成员是一个对象，即成员对象。

有成员对象的类叫封闭（enclosing)类。

class CTyre //轮胎类
{
private:
    int radius; //半径
    int width; //宽度
public:
    CTyre(int r,int w):radius(r),width(w) { }
};

class CEngine //引擎类
{
};
 
class CCar { //汽车类
private:
    int price; //价格
    CTyre tyre;
    CEngine engine;
public:
    CCar(int p,int tr,int tw );
};

CCar::CCar(int p,int tr,int w):price(p),tyre(tr, w)
{
};

int main()
{
    CCar car(20000,17,225); 
    return 0;
}

上例中，如果 CCar类不定义构造函数， 则下面的语句会编译出错：

　　 CCar car;

因为编译器不明白 car.tyre该如何初始化。car.engine 的初始化没问题，用默认构造函数即可。

任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何初始化的。

具体的做法就是：通过封闭类的构造函数的初始化列表。

成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量 ，只要表达式中的函数或变量有定义就行。

2)封闭类构造函数和析构函数的执行顺序

　　封闭类对象生成时，先执行所有对象成员的构造函数，然后才执行封闭类的构造函数。

　　对象成员的构造函数调用次序和对象成员在类中的说明次序一致 ，与它们在成员初始化列表中出现的次序无关。

　　当封闭类的对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。

class CTyre {
public:
    CTyre() { cout << "CTyre contructor" << endl; }
    ~CTyre() { cout << "CTyre destructor" << endl; }
};

class CEngine {
public:
    CEngine() { cout << "CEngine contructor" << endl; }
    ~CEngine() { cout << "CEngine destructor" << endl; }
};

class CCar {
private:
    CEngine engine; 
    CTyre tyre;
public:
    CCar( ) { cout << “CCar contructor” << endl; }
    ~CCar() { cout << "CCar destructor" << endl; }
};
 
int main(){
    CCar car; 
    return 0;
}
输出结果：
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor

3）封闭类的复制构造函数

封闭类的对象，如果是用默认复制构造函数初始化的，那么它里面包含的成员对象， 也会用复制构造函数初始化。

class A
{
public:
    A() { cout << "default" << endl; }
    A(A & a) { cout << "copy" << endl;}
};
class B {
    A a; 
};
int main()
{
    B b1,b2(b1);
    return 0;
}