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

最新推荐文章于 2023-03-28 18:42:29 发布

咸鸭蛋不好吃

最新推荐文章于 2023-03-28 18:42:29 发布

阅读量492

点赞数

分类专栏： C++ GeekBand 文章标签： C++

本文链接：https://blog.csdn.net/skyhuangdan/article/details/50938920

版权

GeekBand 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

C++

6 篇文章 0 订阅

订阅专栏

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];
}

彩蛋: