类的封装性

C++讲稿

1．输入、输出语句

输出语句

例输出10、16、8进制整数

//ex2_8.cpp

#include "iostream.h"

#include "iomanip.h"

void main()

{

int a=1508;

cout<

cout<

cout<

}

运行结果是：

Decimal ：1508

Hexadecimal ：5e4

Octal ：2744

表2.5 I/O流的常用控制符

例2.8从键盘输入三个实数，求其中的最大值，输出时要求10个有效位数。

//ex2_10.cpp

#include "iostream.h"

#include "iomanip.h"

void main()

{

double a,b,c;

cin>>a>>b>>c;

double d=a>b?a:b;

double e=c>d?c:d;

cout<<"max="<

}

运行结果是：

456.78476 23784.657648 99.5↓

max=23784.65765

2．函数重载

函数重载

同一个函数名可以用于多个函数的定义，即用于多个函数的实现，称函数重载。函数的函数名相同，它们的差别就在于参数的类型或个数不相同。编译系统能够唯一地确定调用哪个函数，就利用调用时所传递的实参类型和个数，以及它们的顺序是否跟该函数的定义和说明一致。因此实现同名函数重载，一定要在函数定义时函数参数的类型和个数或顺序上有所不同，否则实现不了同名函数的重载。

例函数重载举例

//ex5_4.cpp

#include "iostream.h"

int max(int,int);

int max(int,int,int);

double max(double,double);

double max(double,double,double);

void main()

{

cout<<"maxi2="<

cout<<"maxi3="<

cout<<"maxd2="<

cout<<"maxd3="<

}

int max(int x,int y)

{

return x>y? x:y;

}

int max(int x,int y,int z)

{

int c=max(x,y);

return z>c? z:c;

}

double max(double x,double y)

{

if(x>y)

return x;

else

return y;

}

double max(double x,double y,double z)

{

double c=max(x,y);

double d=max(c,z);

return d;

}

运行结果：

maxi2=6

maxi3=7

maxd2=6.3

maxd3=7.8

以上例题可见，4个函数的函数名都是max，但形参的类型和个数不同，编译系统根据实参的类型和个数可以区分出要调用的是哪个函数。

函数参数的默认值

调用函数时，若所用的实参有一个经常用的值，此时说明函数原型时，可以用该值作为函数参数的默认值，凡给过默认值的参数，在调用时可以给实参，也可以不给实参（此时实参为默认值）。下例是个延时函数，调用时给实参按实参延时，不给实参按默认值延时。

例函数默认值举例

//ex5_5.cpp

#include "iostream.h"

void delay(int t)

{

if(t==0)

return;

for(int i=0;i

cout<<"i="<

}

void main()

{

void delay(int=1000); // 声明默认值参数

delay(0);

delay(50);

delay(500);

delay();

delay(5000);

}

运行结果：

i=50

i=500

i=1000 (默认值参数得到的结果)

i=5000

如果函数参数有多个，可以全部声明为默认参数，也可以只有部分参数声明为默认值。部分参数有默认值时，默认参数应从右至左逐个给出。若有三个函数参数的add()函数，默认值有如下声明：

int add(int=5,int=7,int=8); // 正确，全部参数声明为默认值

int add(int,int=7,int=8); // 正确，两个参数声明为默认值

int add(int,int,int=8); // 正确，一个参数声明为默认值

int add(int=5,int=7,int)；// 错，违背了自右至左逐个给出的原则

int add(int,int=7,int); // 错，违背了自右至左逐个给出的原则

注意，带有默认参数的重载函数，可能会引起调用的歧义性，如有一组重载函数的原型说明如下：

int fu(int);

int fu(int, int=8);

int fu(int, int=8,int=9);

则调用时若用表达式fu(12)，编译系统就区分不出调用上面三个函数中的哪一个，因此在声明函数参数默认值时，应避免这种情况的发生，上面这样的重载函数，不声明默认值时，它们的重载仍然有效。

3．类

类的成员有二种，数据成员和成员函数，数据成员又称为属性，成员函数又称为方法、操作或实现。通常成员函数是处理数据成员的，如果成员函数与数据成员毫无关系，那么该成员函数就没有存在的必要了。类的定义格式一般分成二部分，一部分是说名部分，说明类中的数据成员和成员函数，另一部分是实现部分，就是定义成员函数。说明部分表明了该类有什么功能，实现部分是实现这些功能的详细过程，用户通常只关心说明部分，以便知道如何来使用该类的功能。

类的一般定义格式如下：

（1）说明部分

class 类名

{

public:

数据成员和成员函数

private:

数据成员和成员函数

protected:

数据成员和成员函数

}；

（2）成员函数的实现部分

简单复数运算类示例

//ex7_1.h

#include "iostream.h"

#include "math.h"

//类的说明部分

class CComplex

{

private:

double real;

double imag;

public:

void Init(double r,double i);

double GetReal();

double GetImag();

double GetAbs();

};

//类的实现部分

void CComplex::Init(double r,double i)

{

real=r;

imag=i;

}

inline double CComplex::GetReal()

{

return real;

}

inline double CComplex::GetImag()

{

return imag;

}

double CComplex::GetAbs()

{

double t;

t=real*real+imag*imag;

return sqrt(t);

}

4．对象

类是一种抽象的数据类型，编译系统并不为之分配可供使用的内存，用户只能使用类的“变量”。这好比C语言中的结构体，实际应用中只能使用结构体的变量而不能直接使用结构体类型一样。由类定义的“变量”通常称为“对象”或“实例”。属于同一类的对象，具有相同的属性和方法，属于不同类的对象，一般是不会具有完全相同的属性和方法。由类定义对象的方法与由结构体定义变量的方法极其相似。通常有二种方法定义对象。

（1）在声明类的同时，直接定义对象，格式为：

class 类名

{

声明类的成员

}对象名；

（2）声明类以后，在使用对象前定义，这时可以省略关键字class直接使用类名，格式为：类名对象名；

对象的使用

例7.2写出程序的运行结果

//ex7_2.cpp

#include "ex7_1.h"

void main()

{

CComplex A,*PA=&A;

A.Init(1.5,2.4);

cout<<"real of complex A="<GetReal()<

cout<<"image of complex A="<GetImag()<

cout<<"Abs of complex A="<GetAbs()<

}

程序运行结果为：

real of complex A=1.5 1.5

image of complex A=2.4 2.4

Abs of complex A=2.83019 2.83019

例7.3指出下面程序中的语法错误。

//ex7_3.cpp

#include "iostream.h"

#include "math.h"

class CPoint

{

int x;

int y;

public:

void SetX(int k){x=k;}

void SetY(int k){y=k;}

int GetX(){return x;}

int GetY(){return y;}

};

void main()

{

CPoint p1,p2;

p1.x=5; //错误:p1.x是私有成员.改用p1.SetX(5);

p1.y=10; //错误:p1.y是私有成员改用p1.SetY(10);

p2.SetX(15);

p2.SetY(20);

double d1=p1.x*p1.x+p1.y*p1.y;//错误:p1.x和p1.y 是私有成员改用:

//double d1=p1.GetX()*p1.GetX()+p1.GetY()*p1.GetY();

d1=sqrt(d1);

double d2=p2.GetX()*p2.GetX()+p2.GetY()*p2.GetY();

d2=sqrt(d2);

cout<<"p1到原点的距离为"<

cout<<"p2到原点的距离为"<

}

5．构造函数

定义

类是一种用户自定义的数据类型，它可能很简单，也可能很复杂。类定义一个对象时，编译系统将为对象分配内存，并进行必要的初始化工作。对象的初始化是由构造函数完成的，构造函数是类的成员函数，如果用户不定义构造函数，系统会自动生成一个缺省的构造函数。当对象的初始化较为复杂时，用户应该自定义构造函数。

构造函数是类的一个特殊的成员函数，它有如下一些特点：

（1）构造函数的名字必须和类的名字相同

（2）构造函数无类型说明，它不能有返回值，在构造函数内不能有return语句，构造函数可以被重载。

（3）在定义类时若没有定义构造函数，编译系统会在内部自动生成一个不带参数的缺省构造函数，其格式如下：

类名::缺省构造函数名（）{ }

（4）创建对象时，系统自动调用构造函数，一般不要在程序中显式调用构造函数。

例7.6 设计一个计时器，其初始化值可以是秒数，或分钟数和秒数，或小时数、分钟数和秒数，若无初始化值，缺省值取为0，输出为秒数。

//ex7_6.cpp

class CTimer

{

int seconds;

public:

CTimer(){seconds=0;}

CTimer(int i){seconds=i;}

CTimer(int i,int j){seconds=i*60+j;}

CTimer(int i,int j,int k){seconds=(i*60+j)*60+k;}

int GetTimer(){return seconds;}

};

#include "iostream.h"

void main()

{

CTimer t1,t2(30),t3(1,5),t4(1,20,6);

cout<<"t1: "<

cout<<"t2: "<

cout<<"t3: "<

cout<<"t4: "<

}

程序运行结果为：

t1：0

t2：30

t3：65

t4：4806

程序中采用重载构造函数的方法来适应各种形式的初始化。如果使用带缺省值参数的构造函数，则构造函数CTimer(){seconds=0;}和CTimer(int i){seconds=i;}可以合并写成：CTimer(int i=0) {seconds=i;}

需要注意的是重载没有参数和带缺省参数的构造函数时，有可能产生二义性。例如上例中若重载的构造函数写成：

CTimer( ) { } //不带参数的构造函数

CTimer(int i=0) {seconds=i;} //带缺省参数的构造函数

在定义以下对象时将发生语法错误。

CTimer t1; //存在二义性

由于在定义对象t1时系统将自动调用构造函数，这时系统将不能判断是调用构造函数CTimer()还是调用构造函数CTimer(int i=0)因而发生二义性错误。

6．析构函数

析构函数的功能是在释放对象之前做一些必要的清理工作。它的功能和构造函数相反，构造函数是在创建对象时做初始化工作，而析构函数是在删除或释放对象前做好清理准备工作，使对象所占的内存能正常地释放交还给系统。

析构函数是类的成员函数，它有以下几个特点：

（1）析构函数名是由“~”加上类名组成

（2）析构函数无类型说明，也没有参数，析构函数不可以重载

（3）如果在类中没有显式定义析构函数，编译系统会提供一个缺省的析构函数。其格式如下：

类名：：~缺省析构函数名（）{ }

（4）释放对象时，系统自动调用析构函数

例7-9写出程序运行结果.。

//ex7_9.cpp

#include "iostream.h"

class CDate

{

int year;

int month;

int day;

public:

CDate(int y,int m,int d)

{

year=y;

month=m;

day=d;

cout<<"Constructor called.\n";

}

~CDate() {cout<<"Destructor called.\n";}

void Print(){cout<

};

void main()

{

CDate today(2000,9,1),tomorrow(2000,9,2);

cout<<"Today is:";

today.Print();

cout<<"Tomorrow will be:";

tomorrow.Print();

}

程序运行结果为：

Constructor called.

Constructor called.

Today is: 2000.9.1

Tomorrow will be: 2000.9.2

Destructor called.

Destructor called.

该程序中定义二个对象today和tomorrow，在创建对象时系统自动调用构造函数，对对象的数据成员进行初始化，同时执行了构造函数中的输出语句。因而程序运行结果开始输出二个字符串“Constructor called”，中间二行是程序中的输出语句所致，程序执行完毕，在释放对象之前将自动调用析构函数，由于要释放二个对象，因而将分别调用它们的析构函数，从而构成了最后二句“Destructor called.”的输出。

7．对象初始化

本节通过一些具体例子，说明在对象初始化时要注意的问题，这些问题通常不被人们重视，但它们经常会导致理解上的错误，有时会导致语法错误。本节所举的例题主要想说明以下几点：

（1）对象可以作为类的成员，这时在构造函数中必须对对象成员进行初始化。

（2）有关显式调用构造函数的说明。

（3）在定义对象数组时，通常要存在一个无参数的构造函数或者存在一个所有参数带缺省值的构造函数。

（4）使用运算符new和delete处理对象时，编译系统会自动调用构造函数和析构函数。（5）单参数的构造函数具有类型转换功能。

例7.10对象作为类的成员示例

//ex7_10.cpp

#include "iostream.h"

class CMemberObject

{

int x;

public:

CMemberObject(int i){x=i;}

void Print()

{

cout<<"Member of class CMemberObject="<

}

};

class CContainer

{

int y;

CMemberObject X,R;

public:

CContainer(int i);

void Print()

{

cout<<"Member of class CContainer="<

}

void PrintX()

{

X.CMemberObject::Print(); //X.Print();

}

void PrintR()

{

R.CMemberObject::Print(); //R.Print();

}

};

CContainer::CContainer(int i):X(101),R(-55){y=i;}

void main()

{

CContainer A(72);

A.Print();

A.PrintX();

A.PrintR();

}

运行程序结果为：

Member of class CContainer=72

Member of class CMemberObject=101

Member of class CMemberObject=-55

在类的定义中，把另一个已定义的类的对象作为成员是常有的事，例如在本例中，类CMemberObject的对象X和R是类CContainer的成员。程序必须对内部对象成员进行初始化，初始化的工作在类的构造函数中进行。类CContainer的构造函数为：CContainer::CContainer(int i):X(101),R(-55)

{y=i;}

构造函数中的冒号“：”把构造函数名与其实现部分分开，冒号之后增加的部分称作为初始化表，对象成员的初始化在初始化表中进行，各个对象成员的初始化用逗号“，”分开，它们的次序可以是任意的。在例题中也可把数据成员y的初始化放入初始化表中，结果是一样的，这时构造函数变成：

CContainer::CContainer(int 0):x(101), R(-55) y(i){ }

例题中在使用对象成员的输出函数时，表达的方式如下：

X.CMemberObject::Print( );

类名CMemberObject作为成员函数Print()的限定符，这仅为了强调成员函数Print()是属于类CMemberObject而不是属于类CContainer，在例题中该语句也可写成X.Print( );

程序运行结果是一样的。

例7.11显式调用构造函数示例

//ex7_11.cpp

#include "iostream.h"

#include "string.h"

class CStudent

{

int num;

char name[20];

double average;

public:

CStudent(){cout<<"Constructor1 called.\n";}

CStudent(int n,char* p,double a)

{

num=n;

strcpy(name,p);

average=a;

cout<<"Constructor2 called.\n";

}

~CStudent(){ cout<<"Destructor called.\n";}

void Print(){cout<

};

void main()

{

CStudent S1(1220,"LiMing",82.5),S2;

S2=CStudent(1221,"Fang",89.1);

S1.Print();

S2.Print();

}

程序运行结果为：

Constructor2 called.

Constructor1 called.

Constructor2 called.

Destructor called.

1220, LiMing, 82.5

1221, Fang, 89.1

Destructor called.

Destructor called.

程序中定义了对象S1和S2，编译系统将二次调用构造函数和析构函数。由程序运行结果可知，程序在运行中，实际上是三次调用了构造函数和析构函数，多一次调用构造函数和析构函数是由赋值语句

S2=Student(1221,”Fang”,85.1);

引起的。从形式上看S2的值好象是等于构造函数的返回值，事实并非如此，因为构造函数中既无return语句，也无返回值。实际上该赋值语句显式调用了构造函数，这将产生一个临时对象。临时对象的生存期一般都很短暂，当赋值语句执行后，临时对象就消失了。与一般对象一样，在创建临时对象时将调用构造函数，在撤消临时对象前将调用析构函数。所以本例运行结果中的第三、四句就是由临时对象的建立和撤消所产生的。

如果把例7-11中的主程序改成如下：

void main()

{

CStudent S1(1220,"LiMing",82.5);

CStudent S2=CStudent(1221,"Fang",89.1);

S1.Print();

S2.Print();

}

这时的运行结果与原先相比少了第三、四句，其原因是语句

Student S2=CStudent(1221, “Fang”, 89.1);

定义了对象S2,虽然显式调用了构造函数进行初始化，但不是进行赋值运算，因而没有产生临时对象，所以在运行结果中比原先少调用了一次构造函数和析构函数。实际上语句CStudent S2=Cstudent(1221, “Fang”, 89.1);

与语句

CStudent S2(221, “Fang”, 89.1);

除了书写形式不同外，本质上是一样的，这是C++中初始化的两种不同写法。

例7.12对象数组的使用示例

//ex7_12.h

#include "iostream.h"

#include "string.h"

class CTeacher

{

int num;

char name[20];

double pay;

public:

CTeacher(){cout<<"Constructor1 called.\n";}

CTeacher(int n,char* m,double p)

{

num=n;

strcpy(name,m);

pay=p;

cout<<"Constructor2 called.\n";

}

~CTeacher(){ cout<<"Destructor called.\n";}

void Print(){cout<

};

//ex7_12.cpp

#include "Ex7_12.h"

void main()

{

CTeacher T1[2];

CTeacher T2[2]={CTeacher(416,"Wang",1248.9),CTeacher(418,"Cheng",2245.7)};

T1[0]=CTeacher(421,"Wu",1921.5);

T1[1]=CTeacher(425,"Zhou",1764.9);

for(int i=0;i<2;i++)

{

T1[i].Print();

T2[i].Print();

}

}

程序运行结果为：

Constructor1 called.

Constructor1 called.

Constructor2 called.

Constructor2 called.

Constructor2 called.

Destructor called.

Constructor2 called.

Destructor called.

421, Wu, 1921.5

416, Wang, 1248.9

425, Zhou, 1764.9

418, Cheng, 2245.7

Destructor called.

Destructor called.

Destructor called.

Destructor called.

程序中定义了二个对象数组，T1和T2，对象数组T1未给初始化值，以后再对数组成员赋值，对象数组T2通过调用构造函数使之初始化。在定义对象数组时，每个数组成员都将调用构造函数，这就是程序运行结果的前四句。数组T1经显式调用构造函数给数组成员赋值，这时将产生临时对象，赋值完毕，临时对象撤消之前将调用析构造函数，从而产生了程序运行结果中的第5到第8句输出语句。程序结束前所有对象数组成员都将撤消，编译系统将自动调用析构函数，从而产生程序运行结果中的最后四句。

如果在程序中，省略类的无参数构造函数，将会引起语法错误，原因是如果类中已有构造函数存在，系统不再提供缺省的无参构造函数，不带初始化值的对象数组T1将无法调用带参数构造函数。通常对于存在对象数组的类，总要要定义一个无参数或带缺省参数的构造函数，确保定义对象数组时不会发生语法错误。

例7.13运算符new和delete使用示例。

//ex7_13.cpp

#include "ex7_12.h"

void main()

{

CTeacher *p,*q;

p=new CTeacher[3];

q=new CTeacher(425,"Zhou",1764.9);

*p=CTeacher(416,"Wang",1248.9);

*(p+1)=CTeacher(418,"Cheng",2245.7);

*(p+2)=CTeacher(421,"Wu",1921.5);

for(int i=0;i<3;i++)

(p+i)->Print();

q->Print();

delete [] p;

delete q;

}

程序运行结果为：

Constructor1 called.

Constructor1 called.

Constructor1 called.

Constructor2 called.

Constructor2 called.

Destructor called.

Constructor2 called.

Destructor called.

Constructor2 called.

416, Wang, 1248.9

418, Cheng, 2245.7

421, Wu, 1921.5

425, Zhou, 1764.9

Destructor called.

Destructor called.

Destructor called.

Destructor called.

在程序中使用运算符new动态分配对象内存时，系统将自动调用构造函数，在使用运算符delete删除由new分配的对象内存时，系统将自动调用析构函数。本例题中使用new动态分配了一个对象数组和一个对象，共计动态分配了4个对象内存，因而将4次调用构造函数，同样在调用delete释放这些对象时，又将4次调用析构函数，从而形成输出结果中的前4句和最后4句。程序中3次显式调用构造函数对对象数组成员赋值，这将使系统3次建立临时对象，每次临时对象创建和撤消都将调用构造函数和析构函数，由于连续3次创建和撤消临时对象，程序执行时将连续三次调用构造函数和析构函数，这样在输出结果中将多了三组语句：

Constructor2 called.

Destructor called.

若在初始化时显式调用构造函数，将不会创建临时对象，因而也就不会调用析构函数了，这就是语句

q=new CTeacher(425, “Zhou”, 1764.9);

不会调用析构函数的原因。

例7.14 构造函数作数据类型转换示例。

//ex7_14.cpp

#include "iostream.h"

class CExample

{

double m;

public:

CExample(double i=0)

{

m=i;

cout<<"Constructor called.\n";

}

~CExample(){ cout<<"Destructor called.\n";}

void Print(){cout<<"m="<

};

void main()

{

CExample X(20);

X=15; //X=CExample(15);

X.Print();

}

程序运行结果为：

Constructor called.

Destructor called.

m=15

Destructor called.

主程序中语句

X=15；

有点特殊，等式左边是一个CExample的对象，等式右边是一个整数，若要把一个整数强制转换成同类对象，一般要使用类型强制转换函数，它是类的成员函数，其一般格式及使用方法见第9章。例7.14中由于存在单个参数的构造函数，因而该类提供一种将其它数据类型的数值或变量转换成该类对象的方法。例题中数据类型的转换过程如下：整型数15首先转换成双精度型数15.0，进而显式调用构造函数，产生临时对象完成赋值运算，使对象X的数据成员的值为15.0。由输出结果可以看到，对象X的数据成员X.m的值确实是15，在输出结果中有两组调用构造函数和析构函数的输出，其中一组是由定义对象X引起的，另一组是由于临时对象的创建和撤消引起的。

本节通过一些具体例子说明由于类这一数据结构的引入，在初始化方面引起许多新问题。在定义对象时要调用构造函数，撤消对象时要调用析构函数，编译系统将提供缺省的构造函数和析构函数。在简单情况下，用户使用缺省的构造函数和析构函数是不会有问题的，如果在较复杂的情况下，用户通常必须自定义构造函数、拷贝构造函数和析构函数或者重载构造函数，以免出错。

8．类和对象的进一步用法

this指针、静态成员、友元

1）this指针

类可以定义很多对象，当对象使用类中的成员时，编译系统必须分清类的成员正在被哪一个对象使用，这主要靠this指针。this指针是一种特殊的指针，它隐含于每一个类的成员函数中（静态函数除外），调用对象成员函数前，编译系统就把该对象地址赋给this指针，使this指针指向该对象，然后开始调用成员函数，并使用隐含的this指针。this指针也可以被显式调用，但很少这样使用。可以用下面三句话来理解this指针：this指针是一个指向对象的指针。

this指针是一个隐含于成员函数中的对象指针。

this指针是一个指向正在调用成员函数的对象的指针。

例7.15分析程序中this指针的作用

//ex7_15.cpp

#include "iostream.h"

class CPoint

{

int x,y;

public:

CPoint(int i=0,int j=0)

{

x=i; //this->x=i;

y=j; //this->y=j;

}

void Init(CPoint& k)

{

if(this==&k) return;

*this=k;

}

void Print(){cout<

};

void main()

{

CPoint a(5,8),b(12,56),c;

c.Init(b);

a.Print();

b.Print();

c.Print();

}

程序运行结果为：

5，8

12，56

12，56

程序中有二处出现this指针，它们都在成员函数Init( )中，函数Init( )的功能是用已知对象给另一对象赋值，显然已知对象对自身赋值是多余的，函数中的语句if(this==&k) return;

就是为了防止自身赋值而设置的。现在分析该语句的工作过程。由主函数中语句"c.Init(b);"知，成员函数Init( )是由对象c调用的，因而函数Init( )具有的this指针指向对象c，则this的值为&c，k是函数参数，函数实参为b，因而&k的值为&b，显然表达式this==&k不成立，程序执行赋值语句"*this=k;"。该语句的功能是把对象k中的成员值赋给this指针指向的对象，而k是对象b的引用，因而实现了对象b给对象c的赋值功能，程序运行结果也说明了这点。另外在程序中多处应用了隐含的this指针，例如构造函数为：CPoint(int i=0, int j=0)

{x=i; y=5;}

实际上构造函数已经使用了隐含的this指针，如果显式写出this指针，构造函数为：CPoint(int i=0, int j=0)

{this->x=i; this->y=j;}

由于this指针的功能，使各个对象可以正确调用类中的成员函数和数据成员。如果把例题中的构造函数的参数i和j改用x和y，就必须显式使用this指针，以免差错，修改后的构造函数如下：

CPoint(int x=0, int y=0)

{this->x=x; this->y=y;}

如果省略了this指针，编译系统将无法区分x、y是类的成员变量还是函数的参数，从而无法执行正确的操作了。

2）静态成员

在定义类的成员时，若使用了关键字static，该成员称为静态成员。其定义格式为：static 成员（变量或函数）；

静态成员最主要的特征是该成员属于类的全体对象，而不仅仅是归属于某一特定对象。静态成员在类的对象间是共享的，编译系统在定义类的第一个对象时为静态成员分配内存，以后

定义对象时不再为静态成员分配内存了，因而所有的对象共享静态成员。静态成员可以是数据成员也可以是成员函数，它们都有一些各自的特点，简述如下：

（1）静态数据成员

静态数据成员是属于类或类的对象全体，它不为某个对象所独享。假定类CWithStatic 是一个带有静态数据成员的类，静态数据成员为count，下面的程序段将说明静态数据成员的特点。

class CWithStatic

{

int k;

static int count;

……

};

int SWithStatic::Count=0;

void main( )

{

CWithStatic a(8),b[3];

……

}

图7.3说明了静态数据成员count被

定义的对象a和对象数组b所共享，实际

上不管定义了多少个对象，每个对象的静

态数据成员都使用一个共用的内存。从上

面的程序段还可以看到，静态数据成员的

图7.3对象共享静态数据成员

初始化在类的外部进行，其语句为：

int CWithStatic::Count=0;

注意在类外初始化静态数据成员时，不必再加上关键字static。使用静态数据成员应该注意以下二点：

1）静态数据成员属于类或属于对象全体，其表达式可用

类名::静态数据成员

或对象名.静态数据成员

建议读者使用前者，如果使用后者，容易造成一种错觉，使人误以为静态数据成员是属于某个对象的。

2）静态数据成员的初始化在类外进行。

例7.16分析程序中静态数据成员的作用

//ex7_16.cpp

#include "iostream.h"

class CWithStatic

{

public:

int k;

static int count;

CWithStatic(int i=0){k=i; count++;}

~CWithStatic(){count--;}

};

int CWithStatic::count=0;

void main()

{

CWithStatic a(8),b[3];

b[0]=7;

b[1]=9;

b[2]=11;

cout<<"a.k:"<

cout<<"a.count: "<

cout<<"b[0].k: "<

cout<<"b[0].count: "<

cout<<"b[1].k: "<

cout<<"b[1].count: "<

cout<<"b[2].k: "<

cout<<"b[2].count: "<

cout<<"CWithStatic::count: "<

}

程序运行结果为：

A.k: 8

A.count: 4

b[0].k: 7

b[0].count: 4

b[1].k: 9

b[1].count: 4

b[2].k: 11

b[2].count: 4

CWithStatic::count: 4

从运行结果可以看到静态数据成员count属于类，由于各个对象的数据成员count共用一个内存，它们的数值应该是一样的，均为4。建议使用形式CWithStatic::count，使人一目了然地知道count是属于类的静态变量。静态数据成员count作用是统计类CWithStatic的对象数目，在程序中使用了对象a和对象数组b，共计定义了4个对象，所以count值为4。仔细分析程序可以发现在给对象数组各元素赋值时，曾使用过3个临时对象，程序执行过程中实际上使用过7个对象，由于临时对象在赋值语句结束后就被撤消，程序中3次隐含调用析构函数，因而count的值为4，而不是7。如果删除程序中的析构函数，再次运行程序，可以发现count的值将是7。由程序还可以看到，静态数据成员在类外进行初始化，不要试图在类中定义静态变量时对其赋初值，这样将产生语法错误，因为编译系统是不给类分配内存的。

由于静态成员是属于对象全体的，因而静态成员函数亦是属于类的，而不是属于某个特定的对象，由此可推知静态函数不具有this指针。由于静态函数没有this指针，通常它只访问属于全体对象的成员——静态成员，也可以访问全局变量。静态函数若访问非静态成员，必须指明其所属的对象，这样既麻烦，又无多大的实际意义，因而一般情况下，静态函数不访问类的非静态成员，因为这些成员是属于特定对象的。归结起来使用静态函数要注意以下两点：

1）静态成员函数属于类，它的表示形式为：

类名::成员函数

或对象名.成员函数

与数据成员一样，建议使用前一种表示形式。

2)静态成员函数没有this指针，因而它不能直接访问非静态成员，通常静态成员函

数只访问静态成员（数据和函数）或全局变量。

3）友元