C++——类与对象

1、抽象：

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

1.1 先注意问题的本质描述，其次是实现过程和细节；

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

1.3 代码抽象：描述某类对象共有的行为特征和具体功能；

1.4 抽象的实现：类的声明。

例如：

　　钟表抽象：

　　　　数据抽象 int hour; int minute; int second;

代码抽象 settime(); showtime();

抽象实现

 class clock{//钟表类

public://在外界可以访问的，相当于钟表外面可以操作的部分，即接口

  void settime(int newh, int newm, int news);

  void showtime();//成员函数

private://在类外不能直接操作的，封装的部分，相当于钟表的内部

  int hour, int minute, int second;//成员数据};

2、封装：

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

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

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

3、继承与派生：

　　允许程序员在保持原有类的特性的基础上进行更具体的说明，通过声明派生类来实现。

4、类的多态性：

　　同一名称不同功能，达到行为标识的统一，减少程序中标识符的个数，通过重载函数和虚函数来实现。

5、类的声明：

class 类名称{

public: 公有成员（外部接口），任何外部函数都可以访问公有类型的数据和函数；

private:私有成员，只允许本类中的函数访问；

protected:保护性成员，与私有成员类似，差别在于继承与派生时对派生类的影响不同。}

#include<iostream>

using namespace std;

class Clock //时钟类的声明                                

{

public: //外部接口

//公有成员函数，在类中声明原型，可以在类外给出实现，并在函数名前使用类名加以限制，也可在类内给出，形成内联成员函数,

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

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

 void ShowTime();

private: //私有数据成员，成员数据与一般变量声明相同，但需要放在类的声明体中

 int Hour,Minute,Second;

};

//时钟类成员函数的具体实现

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

{

 Hour=NewH;

 Minute=NewM;

 Second=NewS;

}

inline void Clock::ShowTime()

{

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

}

//主函数

int main()

{

 Clock myClock; //定义类对象即类类型的变量：myClock，

 cout<<"First time set and output:"<<endl;

 myClock.SetTime(); //设置时间为默认值，在类外访问public成员使用 对象员.成员名

 myClock.ShowTime(); //显示时间

 cout<<"Second time set and output:"<<endl;

 myClock.SetTime(8,30,30); //设置时间为8：30：30

 myClock.ShowTime(); //显示时间

}

6、构造函数：

　　构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。在对象创建时由系统自动调用。如果在程序中没有声明构造函数，则系统自动产生一个默认形式的构造函数，构造函数可以使内联函数、重载函数和带默认形参值的函数，构造函数名与类名一致，没有返回值且不用void。

思考：

　　当我们声明整型数据时，int i=0;我们给i赋初值0。同样我们声明类的对象的时候也应该可以赋给初值，构造函数就是类对象赋初值的规则。

class Clock

{

public:

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

 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(0,0,0); //隐含调用构造函数，将初始值作为实参。

  c.ShowTime();

}

7、拷贝构造函数和析构函数：

析构函数

析构函数是一种特殊的成员函数，除具有一般成员函数的特性外，还具有如下特性：

1）、析构函数的函数名必须与其类名相同，不能指定返回类型，也不能使用void。为了能与构造函数相区别，要在函数名前加~(波浪符)；

2）、析构函数没有参数，一个类中只能拥有一个析构函数，所以析构函数不能重载。定义格式为： ~类名(){ 函数体 } ；

3）、如果程序员没有定义类的析构函数，系统会自动为类创建一个默认析构函数，形式为： ~类名(){ }；

4）、通常为public类型，系统在撤消对象时，自动调用析构函数。也允许显式调用；

5）、用delete运算符删除对象时也会自动调用析构函数。

当对象要被系统释放时，析构函数被调用，在析构函数中可以做一些善后处理处理的工作，如释放内存。

拷贝构造函数

概念：用一个已有的对象来初始化一个被创建的同类对象，是一种特殊的成员函数。

声明的一般格式：类名(类名 & 对象名）；

利用拷贝构造函数可以实现同类对象的数据传递, 即对象的“克隆”。(注意：与对象赋值的不同) (相对于拷贝构造函数，前面介绍的构造函数被称为普通构造函数)

拷贝构造函数的性质：

1）、函数名必须与类名相同，并且不指定返回类型；

2）、只有一个参数，是同类的对象的引用；

3）、每一个类中都必须有一个拷贝构造函数。如果类中没有声明拷贝构造函数，编译器就会自动生成一个具有上述形式的公有的拷贝构造函数。

拷贝构造函数被调用的场景:

1）、声明时赋值 Student s1 = s;

2）、作为参数传入，实参给形参赋值 func(s);

3）、作为函数返回值返回，给变量初始化赋值 Student s1 = func(s);

浅拷贝与深拷贝

如果在类的定义里没有提供拷贝构造函数，C++会提供一个默认的拷贝构造函数；默认拷贝构造函数的拷贝方式是各成员逐一复制，这称为是浅拷贝；在某些情况下，浅拷贝会产生问题，例如：当一个类在它的构造函数动态分配了内存资源，浅拷贝只会复制该资源的地址，而不会为新建的对象重新分配一个资源，因此，会出现多个对象指向同一个堆空间的地址的现象。

应用举例

　　一圆形游泳池如图所示，现在需在其周围建一圆型过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。过道宽度为3米，游泳池半径由键盘输入。要求编程计算并输出过道和栅栏的造价。

#include <iostream>

using namespace std;

const float PI = (float)3.14159; //给出p的值

const float FencePrice = 35.; //栅栏的单价

const float ConcretePrice = 20.; //过道水泥单价

class Circle //声明类Circle 及其数据和方法

{

public: //外部接口

    Circle(float r); //构造函数

    float Circumference(); //计算圆周长

    float Area(); //计算圆面积

private: //私有数据成员

    float   radius;

};

// 类的实现

Circle::Circle(float r) { radius=r; } // 构造函数初始化数据成员radius

float Circle::Circumference() // 计算圆的周长

{

    return 2 * PI * radius;

}

float Circle::Area() // 计算圆的面积

{

    return PI * radius * radius;

}

//主函数实现

void main ()

{

 float radius;

 float FenceCost, ConcreteCost;

 cout << "Enter the radius of the pool: ";  // 提示用户输入半径

 cin >> radius;

 Circle Pool(radius);   // 声明Circle 对象

 Circle PoolRim(radius + 3);

    // 计算栅栏造价并输出

    FenceCost = PoolRim.Circumference() * FencePrice;

    cout << "Fencing Cost is ￥" << FenceCost << endl;

    //  计算过道造价并输出

    ConcreteCost = (PoolRim.Area() - Pool.Area())*ConcretePrice;

    cout << "Concrete Cost is ￥" << ConcreteCost << endl;

}

运行结果

Enter the radius of the pool: 10

Fencing Cost is ￥2858.85

Concrete Cost is ￥4335.39

8、组合类中的成员数据时另一个类的对象，可以在已有抽象的基础上实现更复杂的抽象。

类的数据成员可以是数据，当然可以是类的对象，这就是类的组合。

class Point

{ private:

   float x,y; //点的坐标

  public:

   Point(float h,float v); //构造函数

   float GetX(void); //取X坐标

   float GetY(void); //取Y坐标

   void Draw(void); //在(x,y)处画点

};

//...函数的实现略

class Line

{

  private:

    Point  p1,p2; //线段的两个端点，用点类的对象作为线类的数据成员。

  public:

    Line(Point a,Point b); //构造函数，其初始值是点类的对象。

    Void Draw(void); //画出线段

};

//...函数的实现略

类组合构造函数不仅需要对本类的基本类型成员数据赋初值，也要对对象成员初始化，声明形式：

类名：：类名（对象成员所需形参，本类成员形参）：对象1（参数），对象2（参数），……{本类初始化}

class Part  //部件类

{

    public:

        Part();

        Part(int i);

        ~Part();

        void Print();

    private:

        int val;

};

class Whole

{

    public:

       Whole();

       Whole(int i,int j,int k);

       ~Whole();

       void Print();

    private:

       Part one;

       Part two;

       int date;

};

Whole::Whole()

{

  date=0;

}

Whole::Whole(int i,int j,int k):

            two(i),one(j),date(k)

{}

类要先声明后使用，但是如果要在声明之前引用一个类（当两个类之间相互引用的时候），就需要事先说明。比如说：

class B;  //前向引用声明class A

{  public:

      void f(B b);

};

class B

{  public:

      void g(A a);

};

 class Fred;//前向引用声明 ，仅仅声明B是一个类，并没有声明其任何对象，所以也不能再完整声明B之前使用其对象

 class Barney {

 public:

  void method()

  {

    x->yabbaDabbaDo(); //错误：Fred类的对象在定义之前被使用

  }

 private:

  Fred* x;//正确，经过前向引用声明，可以声明Fred类的对象指针

 };

 class Fred {

 public:

   void yabbaDabbaDo();

 private:

   Barney* y;

 };

巴特西

C++——类与对象

最新文章

热门文章