Runtime Concept 的模拟(1)

 

/**//*
Runtime Concept 的模拟(1)
无意间看到longshanks的blog《OOP的黄昏》
http://www.cppblog.com/longshanks/archive/2007/12/06/37915.html
受益匪浅！
以前没意识到还有Runtime Concept这么好的东东。
一时技痒，就来模拟一个，在C++0x还没出来之前，勉强也可以用用。

基本原理：
在concept类的构造函数里把约束的函数放到函数指针。

这个实现的缺陷：
1. 成员函数的调用方法不知道是不是符合标准，不过估计移植性没什么问题。
2. concept类随着约束的增加而增大。
3. concept类只能引用，这样就不能很好的使用std::vector了。

另：
1. VC的非虚成员函数指针居然可以指向虚函数并正常调用，诡异。
*/

#include <stdio.h>
#include <vector>
#include <string>

typedef FILE* monitor;
struct Rectangle
...{
    void draw(monitor device) const
    ...{
        fprintf(device, "Rectangle.draw ");
    }
    void draw() const
    ...{
        printf("Rectangle.draw ? ");
    }
};

struct Ellipse
...{
    virtual void draw(monitor device) const
    ...{
        fprintf(device, "Ellipse.draw virtual ");
    }
};

struct Triangle
...{
    int draw(monitor device, int another_arg) const
    ...{
        fprintf(device, "Triangle.draw? ");
        return 0;
    }
};

void drawShape(const Rectangle &refShape, monitor device)
...{
    refShape.draw(device);
}

void drawShape(const Ellipse &refShape, monitor device)
...{
    refShape.draw(device);
}

void drawShape(const Triangle &refShape, monitor device)
...{
    refShape.draw(device, 0);
}

//concept
class Shape
...{
private:
    class object...{};
    const object* pointer;
    typedef void (object::*tdraw)(monitor device) const;
    typedef void (*tglobal_drawShape)(const object& refShape, monitor device);
    tdraw pdraw;
    tglobal_drawShape pglobal_drawShape;
    
public:
    void draw(monitor device) const
    ...{
        (pointer->*pdraw)(device);
    }
    static void drawShape(const Shape &refShape, monitor device)
    ...{
        (*refShape.pglobal_drawShape)(*refShape.pointer, device);
    }
    
    template <class T>
    Shape(const T& t) : 
        pointer(reinterpret_cast<const object*>(&t)), 
        pdraw(reinterpret_cast<tdraw>(&T::draw)), 
        pglobal_drawShape(reinterpret_cast<void (*)(const object&, monitor)>
            (static_cast<void (*)(const T&, monitor)>(&::drawShape)))
    ...{
        if (0) static void (T::*tdraw)(monitor) const = &T::draw;
        if (0) static void (*pglobal_drawShape)(const T&, monitor) = &::drawShape;
    }
    
    Shape& operator = (const Shape& rhs)
    ...{
        pointer = rhs.pointer;
        pdraw = rhs.pdraw;
        pglobal_drawShape = rhs.pglobal_drawShape;
        return *this;
    }
};

void DrawShapes(monitor device, std::vector<Shape> const& g)
...{
    std::vector<Shape>::const_iterator b(g.begin()), e(g.end());
    for(; b != e; ++b)
    ...{
        b->draw(device);
        Shape::drawShape(*b, device);
    }
}

int main(int argc, char *argv[])
...{
    Rectangle s1;
    Ellipse s2;
    std::vector<Shape> vg;
    vg.push_back(s1);
    vg.push_back(s2);
    vg.push_back(vg[0]);
    vg.push_back(vg[2]);
    vg[3] = vg[1];
    //vg.push_back(Triangle());            //错误，不符合Shape concept
    //vg.push_back(std::string("xxx"));    //错误，不符合Shape concept

    DrawShapes(stdout, vg);

    return 0;
}