@类和

抽象

抽象是对具体对象（问题）进行概括，抽出这一类对象的公共性质并加以描述的过程。

先注意问题的本质及描述，其次是实现过程或细节。

数据抽象：描述某类对象的属性或状态（对象相互区别的物理量）。

代码抽象：描述某类对象的共有的行为特征或具有的功能。
抽象的实现：通过类的声明。
抽象实例——钟表

数据抽象：

int Hour,int Minute,int Second

代码抽象：

SetTime(),ShowTime()

封装

将抽象出的数据成员、代码成员相结合，将它们视为一个整体。

目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只需要通过外部接口，以特定的访问权限，来使用类的成员。

实现封装：类声明中的{}

封装

实例：

class Clock

{

public:void SetTime(int
NewH,int NewM, int NewS);

   void ShowTime();

private: int Hour,Minute,Second;

};

c++中的类

类是具有相同属性和行为的一组对象的集合，它为属于该类的全部对象提供了统一的抽象描述，其内部包括属性和行为两个主要部分。

利用类易于编写大型复杂程序，其模块化程度比C中采用函数更高。

类的声明形式

类是一种用户自定义类型，声明形式：

class 类名称

{

public:

         公有成员（外部接口）

private:

         私有成员

protected:

         保护型成员

};

公有类型成员

在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。

n
私有类型成员

在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。

如果紧跟在类名称的后面声明私有成员，则关键字private可以省略:

class Clock

{ int Hour,Minute,Second;

public:void SetTime(int
NewH,int NewM,int NewS);

    void ShowTime();

};

类的成员

class Clock

{

public:

void SetTime(int NewH, int NewM,

                     int NewS);

void ShowTime();

private:

int Hour, Minute,

Second;

};

void Clock::SetTime(int NewH, int NewM,int NewS)

{

Hour=NewH;

Minute=NewM;

Second=NewS;

}

void Clock::ShowTime()

{

cout<<Hour<<":"<<Minute<<":"<<Second;

}

成员函数

在类中说明原型，可以在类外给出函数体实现，并在函数名前使用类名加以限定。也可以直接在类中给出函数体，形成内联成员函数。

允许声明重载函数和带默认形参值的函数

内联成员函数

为了提高运行时的效率，对于较简单的函数可以声明为内联形式。

n
内联函数体中不要有复杂结构（如循环语句和switch语句）。

在类中声明内联成员函数的方式：

将函数体放在类的声明中。

使用inline关键字。

内联成员函数举例(一)

class Point

{

public:

void Init(int

initX,int initY)

{

  X=initX;

  Y=initY;

}

int GetX() {return

X;}

int GetY() {return

Y;}

private:

int X,Y;

};

n
内联成员函数举例(二)

class Point

{

public:

void Init(int

initX,int initY);

int GetX()； 

int GetY()；

private:

int X,Y;

};

inline void Point::Init(int initX,int initY)

{

X=initX;

Y=initY;

}

inline int Point::GetX()

{

return X;

}

inline int Point::GetY()

{

return Y;

}

n
对象

类的对象是该类的某一特定实体，即类类型的变量。

声明形式：

类名对象名；

n
例：

Clock
myClock;

类中成员的访问方式

类中成员互访

直接使用成员名

类外访问

使用“对象名.成员名”方式访问 public 属性的成员

例
类的应用举例

#include

using namespace std;

class Clock

{

   ......//类的声明略

}

//…类的实现略

int main()

{ Clock myClock;

  myClock.SetTime(8,30,30);

  myClock.ShowTime();

}

n
构造函数

n
构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。

n
在对象创建时由系统自动调用。

n
如果程序中未声明，则系统自动产生出一个默认形式的构造函数

n
允许为内联函数、重载函数、带默认形参值的函数

n
特殊性质：

n
函数名与类名相同

n
没有返回值

n
声明为公有函数public

n
构造函数的实现：

Clock::Clock(int NewH, int NewM, int NewS)

{

Hour= NewH;

Minute= NewM;

Second= NewS;

}

建立对象时构造函数的作用：

int main()

{

Clock
c(0,0,0); //隐含调用构造函数，将初始值作为实参。

c.ShowTime();}

函数重载

重载函数的声明

C++允许功能相近的函数在相同的作用域内以相同函数名声明，从而形成重载。方便使用，便于记忆。

例：

int add(int x,int y);

float add(float x,float y);

int add(int x,int y);

int add(int x,int y, int z);

注意事项

重载函数的形参必须不同:个数不同或类型不同。

编译程序将根据实参和形参的类型及个数的最佳匹配来选择调用哪一个函数。

编译器不以形参名来区分

编译器不以返回值来区分

n
不要将不同功能的函数声明为重载函数，以免出现调用结果的误解、混淆。这样不好：

int add(int x,int y)

{ return x+y; }

float add(float x,float y)

{ return x-y; }

例重载函数应用举例

编写三个名为add的重载函数，分别实现两整数相加、两实数相加和两个复数相加的功能。

#include

using namespace std;

struct complex

{

double real;

double
imaginary;

};

int main()

{

int m, n;

double x, y;

complex c1,
c2, c3;

int add(int m,
int n);

double
add(double x, double y);

complex
add(complex c1, complex c2);

cout<<"Enter
two integer: ";

cin>>m>>n;

cout<<“integer
<<m<<’+’<<n<<”="<<add(m,n)<<endl;

cout<<"Enter two real number: ";

cin>>x>>y;

cout<<"real
number “<<x<<’+’<<y<<”= "<<add(x,y)
<<endl;

cout<<"Enter
the first complex number: ";

cin>>c1.real>>c1.imaginary;

cout<<"Enter
the second complex number: ";

cin>>c2.real>>c2.imaginary;

c3=add(c1,c2);

cout<<“complex
number (”<<c1.real<<’,’

<<c1.imaginary <<")+("<<c2.real<<’,’

<<c2.imaginary<<")=("<<c3.real<<’,’

<<c3.imaginary<<")\n";

}

运行结果：

Enter two integer: 3 5

integer 3+5=8

Enter two real number: 2.3 5.8

real number 2.3+5.8= 8.1

Enter the first complex number: 12.3 45.6

Enter the second complex number: 56.7 67.8

complex number (12.3,45.6)+(56.7,67.8)= (69,113.4)

class Clock

{

public:

Clock(int NewH,int
NewM,int NewS);//构造函数1

Clock()

{Hour=0;Minute=0;Second=0;}
//构造函数2

void SetTime(int
NewH,int NewM,int NewS);

void
ShowTime();

private:

int Hour,Minute,Second;

};

构造函数的实现：

Clock::Clock(int NewH, int NewM, int NewS)

{

Hour= NewH;

Minute= NewM;

Second= NewS;

}

建立对象时构造函数的作用：

int main()

{

Clock
c(20,10,20); //隐含调用构造函数1，将初始值作为实参。

Clock myClock; //隐含调用构造函数2，使用默认函数值。

c.ShowTime();

}

析构函数

完成对象被删除前的一些清理工作。

在对象的生存期结束的时刻系统自动调用它，然后再释放此对象所属的空间。

如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。

规定：

是类的公有函数成员

名称由类名前加” ~”构成

没有返回值

构造函数和析构函数举例

#include

using namespace std;

class Clock

{

public:

Clock(int NewH=0,int
NewM=0,int NewS=0); //构造函数

Clock(Clock
&c)//拷贝构造函数

{Hour=c.Hour;

Minute=c.Minute;

Second= c.Second;

}

void SetTime(int
NewH,int NewM,int NewS);

void ShowTime();

void Display
();

~Clock() //析构函数

{

    cout<<"One object is

deleted."<<endl;

private:

int Hour,Minute,Second;

};

Clock::Clock(int NewH,int NewM,int NewS)//构造函数

{Hour=NewH;

Minute=NewM;

Second= NewS;}

void Clock::SetTime(int NewH, int NewM,int NewS)

{

Hour=NewH;

Minute=NewM;

Second=NewS;

}

void Clock::ShowTime()

{ cout<<Hour<<":"<<Minute<<":"<<Second<<endl; }

void Clock::Display()

{ if(Hour<=12)

    cout<<Hour<<":"<<Minute<<":"<<Second<<"

AM."<<endl;

else

   cout<<Hour-12<<":"<<Minute<<":"<<Second<<"

PM."<<endl;

}

猜你喜欢