原创 C++ 学习之路（六） 类的指针与静态成员

类的指针(Pointers to classes)

类也是可以有指针的，要定义类的指针，我们只需要认识到，类一旦被定义就成为一种

有效的数据类型，因此只需要用类的名字作为指针的名字就可以了。例如：CRectangle * prect;

是一个指向 class CRectangle 类型的对象的指针。

就像数据机构中的情况一样，要想直接引用一个由指针指向的对象(object)中的成员，

需要使用操作符 ->。这里是一个例子，显示了几种可能出现的情况：

// pointer to classes example

#include

class CRectangle {

int width, height;

public:

void set_values (int, int);

int area (void)

{return (width *height);}

};

void CRectangle::set_values (int a, intb) {

width = a;

height = b;

}

int main () {

CRectangle a, *b, *c;

CRectangle * d = new CRectangle[2]; //定义类的指针D指向一个类数组

b= new CRectangle;

c= &a;

a.set_values (1,2);

b->set_values (3,4);

d->set_values (5,6);

d[1].set_values (7,8);

cout << "a area: " << a.area() << endl;

cout << "*b area: " << b->area() <;<>

cout << "*c area: " << c->area() <;<>

cout << "d[0] area: " << d[0].area()

<< endl;

cout << "d[1] area: " << d[1].area()

<< endl;

return 0;

}

结果：

a area: 2

*b area: 12

*c area: 2

d[0] area: 30

d[1] area: 56

以下是怎样读前面例子中出现的一些指针和类操作符 (*, &, ., ->, [ ])：

•    *x 读作: pointed by x （由 x 指向的）

•    &x 读作: address of x（x 的地址）

•    x.y 读作: member y of object x （对象 x 的成员 y）

•    (*x).y 读作: member y of object pointed by x（由 x 指向的对象的成员 y）

•    x->y 读作: member y of object pointed by x (同上一个等价)

•    x[0] 读作: first object pointed by x（由 x 指向的第一个对象）

•    x[1] 读作: second object pointed by x（由 x 指向的第二个对象）

•    x[n] 读作: (n+1)th object pointed by x（由 x 指向的第 n+1 个对象）

在继续向下阅读之前，一定要确定你明白所有这些的逻辑含义。

由关键字 struct 和 union 定义的类

类不仅可以用关键字 class 来定义，也可以用 struct 或 union 来定义。

因为在 C++中类和结构体的概念太相似了，所以这两个关键字 struct 和 class 的作用

几乎是一样的（也就是说在 C++中 struct 定义的类也可以有成员函数，而不仅仅有数据

成员)。两者定义的类的唯一区别在于由 class 定义的类所有成员的默认访问权限为

private，而 struct 定义的类所有成员默认访问权限为 public。除此之外，两个关键字

的作用是相同的。

union 的概念与 struct 和 class 定义的类不同， 因为 union 在同一时间只能存储一个数

据成员。但是由 union 定义的类也是可以有成员函数的。union 定义的类访问权限默

认为 public。

关键字 this

关键字 this 通常被用在一个 class 内部，指正在被执行的该 class 的对象(object)在

内存中的地址。它是一个指针，其值永远是自身 object 的地址

静态成员(Static members)

一个 class 可以包含静态成员(static members)，可以是数据，也可以是函数。

一个 class 的静态数据成员也被称作类变量"class variables"，因为它们的内容不

依赖于某个对象，对同一个 class 的所有 object 具有相同的值。

例如，它可以被用作计算一个 class 声明的 objects 的个数，见以下代码程序：

// static members in classes

#include

class CDummy

{

public:

static int n;

CDummy () { n++; };

~CDummy () { n--; };

};

int CDummy::n=0; // 类的静态成员  类似于全局变量 只是享有类的范围

int main () {

CDummy a;

CDummy b[5];

CDummy * c = new CDummy;

cout << a.n << endl;

delete c;

cout << CDummy::n << endl;

return 0;

}

结果：

7

6

      静态成员与全域变量(global variable)具有相同的属性，但它享有类(class)

的范围。因此，根据 ANSI-C++ 标准，为了避免它们被多次重复声明，在 class 的声明

中只能够包括 static member 的原型(声明)，而不能够包括其定义(初始化操作)。为了

初始化一个静态数据成员，我们必须在 class 之外(在全域范围内)，包括一个正式的定

义，就像上面例子中做法一样。

因为它对同一个 class 的所有 object 是同一个值，所以它可以被作为该 class 的任何

object 的成员所引用，或者直接被作为 class 的成员引用(当然这只适用于 static 成

员)：

cout << a.n;

cout << CDummy::n;

以上两个调用都指同一个变量：class CDummy 里的 static 变量 n 。

在提醒一次，它其实是一个全域变量。唯一的不同是它的名字跟在 class 的后面。

静态函数

    我们会在 class 中包含 static 数据一样，我们也可以使它包含 static 函数。它们

表示相同的含义：static 函数是全域函数(global functions)，但是像一个指定 class

的对象成员一样被调用。它们只能够引用 static 数据，永远不能引用 class 的非静态

(nonstatic)成员。它们也不能够使用关键字 this，因为 this 实际引用了一个对象指针，

但这些 static 函数却不是任何 object 的成员，而是 class 的直接成员。