C++面向对象高级编程（下）-Geekband

11, 组合和继承

一, Composition 复合  has-a的关系

简单来讲, 就是:

class A{

    classB b1;  

};

这里讲到Adapter设计模式：

template<class T>

class queue{

protected:

    deque<T> c;

......

};

queue为 最先插入在元素将是最先被删除；反之最后插入的元素将最后被删除，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。

deque为　双端队列中的元素可以从两端插入也可以从两端弹出。

所以 queue只用到了deque的一部分内容，即对deque进行了封装，将功能强大的类封装为特性化的类。-Adapter

构造析构： 

构造：由内到外

析构：由外到内

二，Delegation 委托      Composition by reference( 这里其实包含指针和引用两种情况 )

如:

class StringRap;

class String {

.......

private:

    StringRap* rep;

};

委托: 我拥有你, 但我只在想用你的时候才去实现你.(指向对象的指针)

class StringRap{

friend class String;

.....

};

以上的String实际实现是由StringRap类来操作. 这里实际上运用了一个设计模式:

Handle/Bady - pImpl

其中在String类中的StringRap指针就是Handle, StringRap类就是Bady.

在String类在进行相互赋值的时候, 其实底层都是StringRap实现的, 

StringRap拷贝实现其实是, 把当前对象指向的地址返给新的对象, 然后自己reference counting++ 

而当其中一个String值发生改变的时候, 那么就会申请一块新空间,并赋值为当前的内容,并单独分给要改变的Stirng. 

真是妙哉!

三, 继承 Is-a

分public, protected, private 

构造:由内到外

析构:由外到内 

注意:  很多时候要求父类的析构是virtual 

12, 虚函数与多态

继承的是调用权而非功能 - 关键句





非虚: 不希望子类override

虚: 希望子类override , 但自己已有定义

纯虚: 子类一定要定义它





虚函数重要用途: 

    子类对象调用父类非虚函数funA(), 而funA()中调用了虚函数funB(), 而子类override了funB(), 那么funA中将调用子类的funB()而不是父类的funB.

即funA()中的关键功能推迟实现 - Template Method

这里的funA称之为应用框架. 





那么这里的子类funB是如何被调用起来的?

答: 

class CMyDoc: public CDocument 

myDoc.Open() ->CDocument::Open(&this)  

这里显示出了this指针是多么的神奇

13, 委托相关设计

委托+继承

Composite设计模式 较好的说明了 继承+委托 的相互作用关系. 

例子: 

如上视图中, 在一个文件夹中有文件夹也有文件, 而文件夹中的文件夹很可能也有文件夹和文件....

这里就需要一个类创建的对象中,既能保存一个文件夹,也能保存一个文件;而其中的文件夹还能保存文件及文件夹. 





所以, 用到委托+继承来解决这个问题:





设: 

class Primitive代表文件

class Composite代表文件夹 ,文件夹中肯定是可以放文件夹和文件的.

所以我们在类Composite中有 vector<Composite*> 和vector <Primitive*>

那当然也有函数 add(Composite )和add(Primitive)分别用来保存文件夹中含有的文件夹和文件.

有没有发现很麻烦? 如果我们能够只用一个vector和一个add是不是会更省事?





此时,我们使用 继承





创建基类: 

class Component

{

//..

    public:

    virtrual void add(Component*) { }        //这里不能为纯虚函数 . 你猜 , 为什么? 

};





而另外两个类应该继承Component:





class Primitive : public Component

{

//..

};





class Composite : public Component

{

    vector<Compenent*> c;

public:

       void add(Component* elem){

        c.push_back(elem);

    }

//....

};













继承+委托

Prototype设计模式

让父类管理未来的子类,在父类还不知道子类类名的时候就可以进行管理了. 这里的管理指, 所有从本父类派生出去的子类对象都能够通过父类名称来得到.





如果要通过父类名称来获得子类的对象, 那么我们就需要:

    static Image *_prototypes[10];

    static int _nextSlot;

这样就可以用于保存子类的对象. 别忘了在类声明外部,定义这些静态变量哟! ~ 





那我们如何将子类的对象保存到这个数组中? 那我们需要子类调用一个函数,把自己给放进来:

static void addPrototype(Image *image)

    {

        _prototypes[_nextSlot++] = image;

    }





子类如何主动触发去调用addPrototype这个函数呢? 我们的目的就是不让用户根据子类名称去创建对象,而是通过父类.

所以前提条件就是:

子类默认构造函数为私有:

 private:

    LandSatImage()

    {

        addPrototype(this);

    }

那如何创建这个"this"对象呢? 那么我就应该在子类内声明一个本类的成员变量,并且为静态:

    // This is only called when the private static data member is inited

    static LandSatImage _landSatImage;

这样在程序运行起来的时候就会创建.

别忘了在类外定义该静态对象:

// Register the subclass's prototype

LandSatImage LandSatImage::_landSatImage;

此时就会调用构造函数, 并且将自己放到父类的静态数组中. 

到此我们已经在父类中拥有了这个LandSatImage子类的对象.如果有多个不同子类那么就会加进来更过不同的子类对象.

那如何通过父类来获得特定子类的一个对象?而且我们是不知道子类的名称的, 所以这个创建新子类对象的实现办法只能让子类自己去完成:

在子类中:

 Image *clone()

    {

        return new LandSatImage(1);    //new有没有什么问题?为什么是1

    }





在父类中如何才能得到该特定的子类呢? 父类中的实现办法:

Image *Image::findAndClone(imageType type)

{

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

    if (_prototypes[i]->returnType() == type)

      return _prototypes[i]->clone();

} 

此时的type就是用户自己设定的子类类型. 是子类编写用户去添加的枚举类型, 父类只负责判断是否相等就行,这样就将需要判断的类型定义也推迟到后期实现.

枚举内加入新子类的类型:

enum imageType

{

  LSAT, SPOT

};









其实上的子类clone中的new是有玄机的. 你想想 如果 new又调用了默认构造函数的话,又把自己这种类型的子类addPrototype到父类的静态数组中,这就不能保证数组中单一子类型的唯一性了, 所以我们需要写一个新的构造函数:

  protected:

    // This is only called from clone()

    LandSatImage(int dummy)

    {

        _id = _count++;

    }

这里为了和默认构造函数区分开,我们多个int参数.int并没有用,所以在new LandSatImage(1)的1是随便写的.

完整代码:
#include <iostream.h>

//
enum imageType
{
  LSAT, SPOT
};

class Image
{
  public:
    virtual void draw() = 0;
    static Image *findAndClone(imageType);
  protected:
    virtual imageType returnType() = 0;
    virtual Image *clone() = 0;
    // As each subclass of Image is declared, it registers its prototype
    static void addPrototype(Image *image)
    {
        _prototypes[_nextSlot++] = image;
    }
  private:
    // addPrototype() saves each registered prototype here
    static Image *_prototypes[10];
    static int _nextSlot;
};

Image *Image::_prototypes[];
int Image::_nextSlot;

// Client calls this public static member function when it needs an instance
// of an Image subclass
Image *Image::findAndClone(imageType type)
{
  for (int i = 0; i < _nextSlot; i++)
    if (_prototypes[i]->returnType() == type)
      return _prototypes[i]->clone();
}

class LandSatImage: public Image
{
  public:
    imageType returnType()
    {
        return LSAT;
    }
    void draw()
    {
        cout << "LandSatImage::draw " << _id << endl;
    }
    // When clone() is called, call the one-argument ctor with a dummy arg
    Image *clone()
    {
        return new LandSatImage(1);
    }
  protected:
    // This is only called from clone()
    LandSatImage(int dummy)
    {
        _id = _count++;
    }
  private:
    // Mechanism for initializing an Image subclass - this causes the
    // default ctor to be called, which registers the subclass's prototype
    static LandSatImage _landSatImage;
    // This is only called when the private static data member is inited
    LandSatImage()
    {
        addPrototype(this);
    }
    // Nominal "state" per instance mechanism
    int _id;
    static int _count;
};

// Register the subclass's prototype
LandSatImage LandSatImage::_landSatImage;
// Initialize the "state" per instance mechanism
int LandSatImage::_count = 1;

class SpotImage: public Image
{
  public:
    imageType returnType()
    {
        return SPOT;
    }
    void draw()
    {
        cout << "SpotImage::draw " << _id << endl;
    }
    Image *clone()
    {
        return new SpotImage(1);
    }
  protected:
    SpotImage(int dummy)
    {
        _id = _count++;
    }
  private:
    SpotImage()
    {
        addPrototype(this);
    }
    static SpotImage _spotImage;
    int _id;
    static int _count;
};

SpotImage SpotImage::_spotImage;
int SpotImage::_count = 1;

// Simulated stream of creation requests
const int NUM_IMAGES = 8;
imageType input[NUM_IMAGES] =
{
  LSAT, LSAT, LSAT, SPOT, LSAT, SPOT, SPOT, LSAT
};

int main()
{
  Image *images[NUM_IMAGES];

  // Given an image type, find the right prototype, and return a clone
  for (int i = 0; i < NUM_IMAGES; i++)
    images[i] = Image::findAndClone(input[i]);

  // Demonstrate that correct image objects have been cloned
  for (i = 0; i < NUM_IMAGES; i++)
    images[i]->draw();

  // Free the dynamic memory
  for (i = 0; i < NUM_IMAGES; i++)
    delete images[i];
}

彩蛋: