C++初步(7)

类之间的关系(Relationships between classes)

友元函数(Friend functions)

对class的不同成员存在3个层次的内部保护:public, protected 和 private。

在成员为 protected 和 private的情况下,它们不能够被从所在的class以外的部分引用。然而,这个规则可以通过在一个class中使用关键字friend来绕过,这样我们可以允许一个外部函数获得访问class的protected 和 private 成员的能力。

// friend functions
#include <iostream.h>

class CRectangle {
    int width, height;
  public:
    void set_values (int, int);
    int area (void) {
        return (width * height);
    }
    friend CRectangle duplicate (CRectangle);
};

void CRectangle::set_values (int a, int b) {
    width = a;
    height = b;
}

CRectangle duplicate (CRectangle rectparam) {
    CRectangle rectres;
    rectres.width = rectparam.width*2;
    rectres.height = rectparam.height*2;
    return (rectres);
}

int main () {
    CRectangle rect, rectb;
    rect.set_values (2,3);
    rectb = duplicate (rect);
    cout << rectb.area();
}

函数 duplicate是CRectangle的 friend ,因此在该函数之内,可以访问CRectangle 类型的各个object的成员 width 和 height。注意,在 duplicate()的声明中,及其在后面main()里被调用的时候,并没有把duplicate 当作class CRectangle的成员,因为它不是。

friend 函数可以被用来实现两个不同class之间的操作。广义来说,使用friend 函数是面向对象编程之外的方法,因此,如果可能,应尽量使用class的成员函数来完成这些操作。比如在以上的例子中,将函数duplicate() 集成在class CRectangle 可以使程序更短。

友元类 (Friend classes)

就像可以定义一个friend 函数,也可以定义一个class是另一个的friend,以便允许第二个class访问第一个class的 protected 和 private 成员。

// friend class
#include <iostream.h>

class CSquare;

class CRectangle {
    int width, height;
  public:
    int area (void) {return (width * height);}
    void convert (CSquare a);
};

Class CSquare {
  private:
    int side;
  public:
    void set_side (int a){side = a;}
    friend class CRectangle;
};

void CRectangle::convert (CSquare a) {
    width = a.side;
    height = a.side;
}

int main () {
    CSquare sqr;
    CRectangle rect;
    sqr.set_side(4);
    rect.convert(sqr);
    //因为rect是sqr的友类,所以可以让rect访问sqr的内部变量side
    cout << rect.area();
    return 0;
}

在这个例子中,我们声明了CRectangle 是CSquare 的friend,因此CRectangle可以访问CSquare 的protected 和 private 成员,更具体地说,可以访问CSquare::side,它定义了正方形的边长。

class CSquare是空原型。这是必需的,因为在CRectangle 的声明中引用了CSquare (作为convert()的参数)。CSquare定义在CRectangle的后面,因此如果我们没有在这个class之前包含一个CSquare 的声明,它在CRectangle中就是 不可见的。

这里要考虑到,如果没有特别指明,友元关系(friendships)并不是相互的。在CSquare 例子中,CRectangle 是一个friend类,但因为CRectangle 并没有对CSquare作相应的声明,因此CRectangle 可以访问CSquare 的 protected 和private 成员,但反过来并不行,除非将 CSquare 也定义为CRectangle的 friend。

类之间的继承(Inheritance between classes)

类的一个重要特征是继承,这使得可以基于一个类生成另一个类的对象,以便使后者拥有前者的某些成员,再加上它自己的一些成员。由其它类引申而来的子类继承基类的所有可视成员。意思是说,如果一个基类包含成员A,而我们将它引申为另一个包含成员B的类,则这个子类将同时包含 A 和 B。

要定义一个类的子类,必须在子类的声明中使用冒号(colon)操作符: ,如下所示:

class derived_class_name: public base_class_name;

public 也可以根据需要换为protected或private,描述了被继承的成员的访问权限。

// derived classes
#include <iostream.h>

Class CPolygon {
  protected:
    int width, height;
  public:
    void set_values (int a, int b) { width=a; height=b;}
};

class CRectangle: public CPolygon {
  public:
    int area (void){ return (width * height); }
};

class CTriangle: public CPolygon {
  public:
    int area (void){ return (width * height / 2); }
};

int main () {
    CRectangle rect;
    CTriangle trgl;
    rect.set_values (4,5);
    trgl.set_values (4,5);
    cout << rect.area() << endl;
    cout << trgl.area() << endl;
    return 0;
}

输出: 20 10

如上所示,类 CRectangle 和 CTriangle 的每一个对象都包含CPolygon的成员,即: width, height 和 set_values()。

标识符protected 与 private类似,它们的唯一区别在继承时才表现出来。当定义一个子类的时候,基类的protected 成员可以被子类的其它成员所使用,然而private 成员就不可以。

可以访问        public  protected   private
本class的成员   yes     yes         yes
子类的成员      yes     yes         no
非成员          yes     no          no

这里”非成员”指从class以外的任何地方引用,例如从main()中,从其它的class中或从 全域(global)或本地(local)的任何函数中。

这是因为我们在继承的时候使用的是public,记得用的是:

class CRectangle: public CPolygon;

这里关键字 public 表示新的类(CRectangle)从基类(CPolygon)所继承的成员必须获得最低程度保护。这种被继承成员的访问限制的最低程度可以通过使用 protected 或 private而不是public来改变。例如,daughter 是mother 的一个子类,我们可以这样定义:

class daughter: protected mother;

这将使得protected成为daughter从mother处继承的成员的最低访问限制。 (说的含糊,在下理解不了,还是后面说的清楚)

原来mother 中的所有public 成员到daughter 中将会成为protected成员,这是它们能够被继承的最低访问限制。当然这并不是限制daughter 不能有它自己的public 成员。最低访问权限限制只是建立在从mother中 继承的成员上的

最常用的继承限制除了public 外就是private ,它被用来将基类完全封装起来,因为在这种情况下,除了子类自身外,其它任何程序都不能访问那些从基类继承而来的成员。不过大多数情况下继承都是使用public的。

如果没有明确写出访问限制,所有由关键字class 生成的类被默认为private ,而所有由关键字struct 生成的类被默认为public。

什么是从基类中继承的? (What is inherited from the base class?)

理论上说,子类(drived class)继承了基类(base class)的所有成员,除了:

构造函数Constructor
析构函数destructor
operator=() 成员
friends 

虽然基类的构造函数和析构函数没有被继承,但是 当一个子类的object被生成或销毁的时候,其基类的默认构造函数(即,没有任何参数的构造函数)和析构函数总是被自动调用的。

如果基类没有默认构造函数,或你希望当子类生成新的object时,基类的某个重载的构造函数被调用,你需要在子类的每一个构造函数的定义中指定它:

derived_class_name (parameters) : base_class_name (parameters) {}
// constructors and derivated classes
#include <iostream.h>

class mother {
  public:
    mother ()
      { cout << "mother: no parameters\n"; }
    mother (int a)
      { cout << "mother: int parameter\n"; }
};

class daughter : public mother {
  public:
    daughter (int a)
      { cout << "daughter: int parameter\n\n"; }
};

class son : public mother {
  public:
    son (int a) : mother (a)
      { cout << "son: int parameter\n\n"; }
};

int main () {
    daughter cynthia (1);
    son daniel(1);
    return 0;
}

输出:
mother: no parameters//先调用了mother (){…}; daughter: int parameter

mother: int parameter//mother (int a){…}; son: int parameter

不同的构造函数被调用是因为daughter 和 son的构造函数的定义不同:

daughter (int a)          // 没有特别制定:调用默认constructor
son (int a) : mother (a)  // 指定了constructor: 调用被指定的构造函数

多重继承(Multiple inheritance)

在C++ 中,一个class可以从多个class中继承属性或函数,只需要在子类的声明中用逗号将不同基类分开就可以了。

class CRectangle: public CPolygon, public COutput {...};
class CTriangle: public CPolygon, public COutput {...};

多态 (Polymorphism)

基类的指针(Pointers to base class)

继承的好处之一是 一个指向子类(derived class)的指针与一个指向基类(base class)的指针是类型兼容的( type-compatible)的。

// pointers to base class

#include <iostream.h>
class CPolygon {
    protected:
        int width, height;
    public:
        void set_values (int a, int b) {
            width=a; height=b;
    }
};
class CRectangle: public CPolygon {
    public:
        int area (void) {
        return (width * height);
    }
};
class CTriangle: public CPolygon {
    public:
        int area (void) {
        return (width * height / 2);
    }
};
int main () {
    CRectangle rect;
    CTriangle trgl;
    CPolygon * ppoly1 = &rect;
    CPolygon * ppoly2 = &trgl;
    ppoly1->set_values (4,5);
    ppoly2->set_values (4,5);
    cout << rect.area() << endl;
    cout << trgl.area() << endl;
    return 0;
}

在主函数 main 中定义了两个指向class CPolygon的对象的指针,即 *ppoly1 和 *ppoly2。 它们被赋值为rect 和 trgl的地址,因为rect 和 trgl是CPolygon 的子类的对象,因此这种赋值是有效的。

使用ppoly1 和 *ppoly2 取代rect 和trgl 的唯一限制是*ppoly1 和 *ppoly2 是CPolygon 类型的,因此我们 只能够引用CRectangle 和 CTriangle 从基类CPolygon中继承的成员。正是由于这个原因,*不能够使用*ppoly1 和 ppoly2 来调用成员函数 area(),而只能使用rect 和 trgl来调用这个函数。要想使CPolygon 的指针承认area()为合法成员函数,必须在基类中声明它,而不能只在子类进行声明。

虚拟成员(Virtual members)

如果想在基类中定义一个成员留待子类中进行细化,必须在它前面加关键字 virtual ,以便可以使用指针对指向相应的对象进行操作。(还是看后面吧)

// virtual members

#include <iostream.h>
class CPolygon {
    protected:
        int width, height;
    public:
        void set_values (int a, int b)  {
            width=a;
            height=b;
        }
        virtual int area (void) { return (0); }
};

class CRectangle: public CPolygon {
    public:
        int area (void) { return (width * height); }//**此处**
};
class CTriangle: public CPolygon {
    public:
        int area (void) { return (width * height / 2); }//**此处**
};

int main () {
    CRectangle rect;
    CTriangle trgl;
    CPolygon poly;
    CPolygon * ppoly1 = &rect;
    CPolygon * ppoly2 = &trgl;
    CPolygon * ppoly3 = &poly;
    ppoly1->set_values (4,5);
    ppoly2->set_values (4,5);
    ppoly3->set_values (4,5);
    cout << ppoly1->area() << endl;
    cout << ppoly2->area() << endl;
    cout << ppoly3->area() << endl;
    return 0;
}

输出: 20 10 0

现在这三个类(CPolygon, CRectangle 和 CTriangle) 都有同样的成员:width, height, set_values() 和 area()。

area() 被定义为virtual是因为它后来在子类中被细化了。你可以做一个试验,如果在代码中去掉这个关键字,然后再执行这个程序,三个多边形的面积计算结果都将是 0 而不是20,10,0。这是因为 没有了关键字,程序执行不再根据实际对象的不用而调用相应area() 函数(即分别为CRectangle::area(), CTriangle::area() 和CPolygon::area()) ,取而代之,程序将全部调用CPolygon::area() ,因为这些调用是通过CPolygon类型的指针进行的。

关键字virtual 的作用就是在当使用基类的指针的时候,使子类中与基类同名的成员在适当的时候被调用。

虽然本身被定义为虚拟类型,我们还是可以声明一个CPolygon 类型的对象并调用它的area() 函数,它将返回0,如上例。

抽象基类(Abstract base classes)

基本的抽象类与前面类CPolygon 非常相似,唯一的区别是 在前面的例子中,已经为类CPolygon的对象(例如对象poly)定义了一个有效地area()函数,而在一个抽象类(abstract base class)中,可以对它不定义,而简单得在函数声明后面写 =0 (等于0)。(见下例)

注意如何在virtual int area (void)加 =0 来代替函数的具体实现的。这种函数被称为纯虚拟函数(pure virtual function),而所有包含纯虚拟函数的类被称为 抽象基类(abstract base classes)。

抽象基类的最大不同是 它不能够有实例(对象),但可以定义指向它的指针。

这是因为该类包含的纯虚拟函数(pure virtual function) 是没有被实现的,而又 不可能生成一个不包含它的所有成员定义的对象。然而,因为这个函数在其子类中被完整的定义了,所以生成一个指向其子类的对象的指针是完全合法的。

// virtual members

#include <iostream.h>
class CPolygon {
    protected:
        int width, height;
    public:
        void set_values (int a, int b) {
            width=a;
            height=b;
        }
        virtual int area (void) =0;
};
//可以继承,但是不能实例化(用词对不?)。
class CRectangle: public CPolygon {
    public:
        int area (void) { return (width * height); }
};
class CTriangle: public CPolygon {
    public:
        int area (void) {
            return (width * height / 2);
        }
};
int main () {
    CRectangle rect;//子类可以实例化。
    CTriangle trgl;
    CPolygon * ppoly1 = &rect;
    CPolygon * ppoly2 = &trgl;
    ppoly1->set_values (4,5);
    ppoly2->set_values (4,5);
    cout << ppoly1->area() << endl;
    cout << ppoly2->area() << endl;
    return 0;
}

再看一遍这段程序,可以发现能用同一种类型的指针(CPolygon*)指向不同类的对象,至一点非常有用。 想象一下,现在我们可以写一个CPolygon 的成员函数,使得它可以将函数area()的结果打印到屏幕上,而不必考虑具体是为哪一个子类。

// virtual members

#include <iostream.h>
class CPolygon {
    protected:
        int width, height;
    public:
        void set_values (int a, int b) {
            width=a;
            height=b;
        }
        virtual int area (void) =0;
        void printarea (void) {
            cout << this->area() << endl;
        }
};
class CRectangle: public CPolygon {
    public:
        int area (void) { return (width * height); }
};
class CTriangle: public CPolygon {
    public:
        int area (void) {
            return (width * height / 2);
        }
};
int main () {
    CRectangle rect;
    CTriangle trgl;
    CPolygon * ppoly1 = &rect;
    CPolygon * ppoly2 = &trgl;
    ppoly1->set_values (4,5);
    ppoly2->set_values (4,5);
    ppoly1->printarea();
    ppoly2->printarea();
    return 0;
}

输出: 20 10

记住,this 代表代码正在被执行的这一个对象的指针。

抽象类和虚拟成员赋予了C++ 多态(polymorphic)的特征,使得面向对象的编程object-oriented programming成为一个有用的工具。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值