C++元编程思想（译）

C++ 是一种类型概念较强的语言，编译的时候都需要知道变量的类型。有时，在编译过程中，需要动态确定类型

先看一种简单的 商品信息 的存储结构；

示例code：

    class Book
    {
    public:
        Book(const string & author_,
             const string & title_,
             const string & publisher_,
             double price_,
             double weight_);
        string getName()
        {
            string name;
            name = author + ": " + title;
            return name.substr(0, 40);
        }
        double getPrice();
        double getWeight();
    private:
        string author, title, publisher;
        double price, weight;
    };

还可以继续扩展开来，如果有新的类似商品，这样扩展

但是对于如果业务扩张，继续销售T 恤，因为接口不能再如 getweight() 等这样了，所以就无法扩展了。

MetaClass 

可以获取类型和对象的信息，并创建新的类型，类型属性，类型实例等。 MOP

关于对象的属性，结构，等就是meta 信息。  MOP就是封装 meta- level 和 object-level 。

操作主要包括：

定义个新的类型 / 添加类型的属性 / 查询类型属性/  创建对象 / 查询对象的类型 / 设置对象的属性 / 查询对象的属性 / 删除对象

Type是为了区分出不同的属性，使用枚举变量来区分。因为有不同的value， 所以我们定义一个basevalue

calss Type
{
  public:
      enum Type T{stringT , int T, double T, unknown T};
       explicit Type(Type T typeId_): typeId(typeId_){}
      BaseValue * newValue() const
{
   return prototypes[typeId]->clone();
}
 TypeT getType() const
{
   return typeId;
}
static void int();
{
   prototypes[stringT] = new Value<string>("");
   prototypes[intT] = new Value<int>(0);
   prototypes[double T] = new Value<double>(0);
}
private:
   TypeT typeId;
   static vector<BaseValue *>prototypes;
}
vector<BaseValue*>Type::prototypes(Type::unknownT);

通过类型创建新的value， 属性attribute 为了获取类型的名称和类型

class Attribute
{
   public:
     Attibute(const string &name_, Type:: TypeT typeId)
    :name(name_),type_(typeID)
    {}
    const string & getName() const
 {
     return name; 
 }
    Type getType() const
 {
   return type_;
}
private:
  string name;
  Type type_;
};

继承的attributes 放在首位

class的主要目的就是为了创建新的对象，所以有 newObject() 返回一个指针指向对象。对于所有创建的对象，需要保存引用;如果有新的添加的属性，禁止添加到已经有实例的类中；其他方法会比较麻烦。为对象和类型维持属性列表。 属性是仅仅自己，还是包含继承该类的其他属性。对于单独的对象来说，如果可以访问到完整的属性列表是更好的。确保对于不同的类，知道它们的属性findAttribute() 搜索到属性，并返回一个引用index而 getarrtibute() 则通过index 返回相应的value。 最后的问题是什么时间添加属性： 在类的定义时候或者稍后些

class ClassDef
{   //typedefs Container, Iterator for attributes
  public:
   ClassDef(ClassDef const *base, const string &name_)
   :baseClass(base), name(name_),
    definitionFix(false)
{
   baseInit();
   effectiveAttributes.insert(effectiveAttributes.end(),
                                         ownAttibutes.begin(),
                                         ownAttributes.end());
}
template<typename iterator>
ClassDef(ClassDef const * base, const string name_, iterator attribBegin, iterator attibEnd)
  : baseClass(base), name(name_),
  ownAttributes(attriBegin, attribEnd),
  definitionFix(false)
{
   baseInit();
   effectiveAttributes.insert(effectiveAttributes.end(),
                                        ownAtttibutes.Begin(),
                                         ownAttributes.end());
}
string getName() const;
Object * newObject() const
{
   definitionFix = true;
   return new Object(this);
}
AtttIterator attribBegin() const;
AttrIterator attriEnd() const;
AttrIterator const & getAttribute(size_t idx) const;
void addAttribute(const Attribute&);
size_t getAttributeCount() const;

size_t findAttribute(string const & name) const
{
   // this does a reverse search to find the most derived
AtrtibuteContainer::const_reverse_iterator i;

for(i = effectiveAttributes.rbegin();
     i != effectiveArributes.rend();
     ++i)
{
    if(i->getName() = name)
    {
       return distance(i, effectiveAttributes.rend()) - 1;
    }
}
return getAttributeCount();
}
private:
  void baseInit()
 {
   if(baseClass)
   {
      baseClass->definitionFix = true;
      copy(baseClass->attribBegin(), baseClass->attribEnd(), back_inserter<AttributeContainer>(effectiveAttributes));
    }
}
ClassDef const * const baseClass;
string name;
AttributeContainer ownAttributes, effectiveAttributes;
mutable bool definitionFix;
}

传递的是值，传递handle 来实现值的传递

Value BaseValue::get()
{
   return *this;  // call Value(BaseValue const &)
}

class BaseValue
{
   public:
    virtual ~BaseValue() {}
    virtual BaseValue * clone() const = 0;
    virtual string asString() const = 0;
    // fromString()
   
    virtual void set(Value const &v) = 0;
   // no get()!

private:
   //Type info
};

需要有 int, double, strring 等类型， 这种很容易让人想到使用模板

    template <typename PlainT>
    class RealValue : public BaseValue
    {
    public:
        RealValue(PlainT v)
         : val(v) {}

        RealValue * clone() const
        {
            return new RealValue(*this);
        }

        string asString() const
        {
            ostringstream os;
            os << val;
            return os.str();
        }

        operator PlainT() const // conversion to plain type
        {
            return val;
        }

        RealValue<PlainT>::set(Value const & v)
        {
            val = v.get<PlainT>();
        }

    private:
        PlainT val;
    };

主要的事情就是 删除/创建，

    class Value        // Value handle
    {
    public:
        Value(BaseValue const & bv)
         : v(bv.clone())
        {}

        Value(Value const & rhs)
         : v(rhs.v ? rhs.v->clone() : 0)
        {}

        explicit Value(BaseValue * bv = 0)
         : v(bv)
        {}

        ~Value()
        {
            delete v;
        }

        Value & operator=(const Value & rhs)
        {
            // this is not a typical pimpl assignment, but a set()
            if (v)
            {
                if (rhs.v)
                { // fine, all v's exist
                    v->set(rhs);
                }
                else
                { // the other v doesn't exist, so we must delete our own :-(
                    BaseValue * old = v;
                    v = 0;
                    delete old;
                }
            }
            else
            { // we don't have a v, so just copy the other
                v = (rhs.v ? rhs.v->clone() : 0);
            }

            return *this;
        }

        template <typename PlainT>
        PlainT get() const
        {
            if (v)
            {
                RealValue<PlainT> const & rv
                    = dynamic_cast<RealValue<PlainT> const &>(*v);
                return rv;        // uses conversion operator
            }
            else
            {
                return PlainT();
            }
        }

        std::string asString() const
        {
            if (v)
            {
                return v->asString();
            }
            else
            {
                return string();
            }
        }

    private:
        BaseValue * v;
    };

实体对象

  class Object
    {
    public:
        explicit Object(ClassDef const * class_)
         : myClass(class_), values(class_->getAttributeCount())
        {
            buildValueList();
        }

        ClassDef const & instanceOf() const
        {
            return *myClass;
        }

        Value getValue(size_t attribIdx) const
        {
            return *values[attribIdx]; // calls Value(BaseValue &)
        }
        Value getValue(string const & attribName) const
        {
            size_t idx = instanceOf()->findAttribute(attribName);
            // should check for not found
            return getValue(idx);
        }

        void setValue(size_t idx, Value const & v)
        {
            values[idx]->set(v);
        }
        void setValue(string const & attribName, Value const &v)
        {
            size_t idx = instanceOf()->findAttribute(attribName);
            // should check for not found
            setValue(idx, v);
        }

    private:
        typedef vector<BaseValue *> ValueContainer;
        void buildValueList()
        {
            ClassDef::AttrIterator a;
            ValueContainer::iterator i = values.begin();
            for (a = instanceOf()->attribBegin();
                 a != instanceOf()->attribEnd();
                 ++a, ++i)
            {
                *i = a->getType().newValue();
            }
        }

        ClassDef const * const myClass;
        ValueContainer values;
    };

应用

创建 book 类型

    ClassDef base(0, "Product", 0,
                  Product::ownAttribBegin(),
                  Product::ownAttribEnd());
    ClassDef book(makeClass<Book>(&base, "Book"));

给book 类型添加属性值

    Object * ecpp(book.newObject());

    ecpp->setValue(5, RealValue<double>(22.50));
    ecpp->setValue(0, RealValue<int>(23456));
    ecpp->setValue(2, RealValue<string>("Scott Meyers"));
    ecpp->setValue("Title", RealValue<string>("Effective C++"));
    ecpp->setValue(6, RealValue<double>(280));
    size_t idx;

    cout << "ecpp:" << endl;
    for (a = book.attribBegin(), idx = 0;
         a != book.attribEnd();
         ++a, ++idx)
    {
        cout << a->getName() << ": "
             << ecpp->getValue(idx).asString() << endl;
    }

    cout << ecpp->getValue("Author").asString() << endl;

原文链接： vollmann.com/en/pubs/meta/meta/meta.html