1

我接受 onathan Wakely 的评论作为答案。谢谢！以下为原帖。

[原帖] 对自动在类中设置和获取方法有一个想法，如下所示

template<class T>
class Has
{
public:
    template<class U>
    const U& get() const;

    template<>
    const T& get<T>() const
    {
        return m_t;
    }

    template<class U>
    void set(const U& t);

    template<>
    void set<T>(const T& t)
    {
        m_t = t;
    }

private:
    T m_t;
};

一个例子

class Door {};
class Window {};

class House
    : public Has<Door>
    , public Has<Window>
{};

House house;

// set
house.set(Door());
house.set(Window());

// get
const Door& door = house.get<Door>();
const Window& window = house.get<Window>();

如果组件的类型不同并且它们的类型名称是可读的，那么上面显示的代码就可以了。但是如果类型名称不可读，例如房子的面积有一个类型double，我想使用

house.get<Area>(); // or
house.get<AREA>(); // where the template argument can be a const integer

以外

house.get<double>();

而如果有面积和体积这两个双重类型的分量，那么复数怎么处理呢？非常感谢！

有一种方法可以将双精度包装为新类型，例如

template<class T>
class Wrap
{
public:
    Wrap(const T& value = T())
        : m_value
    {}

    operator T()
    {
        return m_value;
    }

private:
    T m_value;
};

class Area
    : public Wrap<double>
{};

这样做，有没有性能影响？谢谢。

按照 jweyrich 的建议，添加以下代码

template<class Name, class T>
class With
{
public:
    template<class U>
    const U& get() const;

    template<>
    const T& get<Name>() const
    {
        return m_t;
    }

    template<class U>
    void set(const U& t);

    template<>
    void set<Name>(const T& t)
    {
        m_t = t;
    }

private:
    T m_t;
};

我认为这很完美。

一个例子

class Door {};
class Window {};

class Area {};    // Empty, just a name holder
class Volume {};  // Another a name holder

class House
    : public Has<Door>
    , public Has<Window>
    , public With<Area, double>
    , public With<Volume, double>
{};

House house;

// set
house.set(Door());
house.set(Window());
house.set<Area>(3000);
house.set<Volume>(30000);

// get
const Door& door = house.get<Door>();
const Window& window = house.get<Window>();
double area = house.get<Area>();
double volume = house.get<Volume>();

任何人都知道模板继承，是否有任何性能降低？在我看来，我认为没有。非常感谢！

4

0 回答 0