0

我有以下课程：

class ValueSetter: public IValueSetter
{
public:
    explicit ValueSetter(CContainer* container)
        : _container(container)
    {
    }

    virtual void operator()(const int value, const int index) const
    {
        _container->values[index].value.i = value;
    }

    virtual void operator()(const double value, const int index) const
    {
        _container->values[index].value.d = value;
    }

    virtual void operator()(const std::string& value, const int index) const
    {
        ...
        _container->values[index].value.s = _strdup(value.c_str());
    }

private:
    CContainer* _container;
};

此类在 CContainer 上运行，CContainer 将其数据存储在联合缓冲区中。我将 ValueSetter 传递给不了解 CContainer 的 Container 类。事实上，在未来，我希望 CContainer（我通过 C API 收到）会消失，而这些值会被组织在 std::vector 或 std::list 中。我的容器的接口不应该因此而改变，也不应该关心数据是如何存储在内存中的。

考虑到这一点，我宁愿大致遵循以下原则：

class IntValueSetter: public IIntValueSetter
{
public:
    explicit IntValueSetter(Container* container)
        : _container(container)
    {
    }

    virtual void operator()(const int value, const int index) const
    {
        _container->values[index].value.i = value;
    }
private:
    CContainer_3* _container;
}

或者：

class IntValueSetter: public IIntValueSetter
{
public:
    explicit IntValueSetter(std::vector<int> values)
        : _values(values)
    {
    }

    ... 
}

但我需要能够按如下方式使用它们：

ValueSetter<int> valueSetter;

代替

IntValueSetter valueSetter;

我怎样才能做到这一点？

4

3 回答 3

4

做显而易见的事。不需要模板专业化与另一个专业化或原始模板有任何共同之处。所以：

class IIntValueSetter {
};

template <class Ty> class ValueSetter; // declared but not defined

template <>
class ValueSetter<int> : public IIntValueSetter {
    // whatever
};

ValueSetter<int> vsi;
于 2012-09-05T11:06:29.143 回答
0

如果我猜对了，您只需要编写一个类模板：

template <typename T>
class ValueSetter
{
public:
    explicit ValueSetter(std::vector<T> values): _values(values)
    {
    }
    virtual void operator()(const T value, const int index) const
    {
        _container->values[index].value.i = value;
    }
// etc.
};
于 2012-09-05T11:03:08.967 回答
0

我想我正在寻找这样的东西。我只在下面实现了 int，但每种类型都会有自己的接口类和实现类。我很想听听您对这种方法的评论！

template<typename V>
class IValueSetter
{
public:
};

template<>
class IValueSetter<std::string> 
{
public:
    virtual void operator()(const std::string& value, int index) const = 0;
};

template<typename V>
class ValueSetter
{
};

template<>
class ValueSetter<std::string>: public IValueSetter<std::string>
{
public:
    explicit ValueSetter2(CContainer* container)
        : _container(container)
    {
    }

    void operator()(const std::string& value, int index) const
    {
        _container->values[index].value.s = _strdup(value.c_str());
    }

private:
    CContainer* _container;
};

template<>
class NewValueSetter<std::string>: public IValueSetter<std::string>
{
public:
    explicit NewValueSetter(std::shared_ptr<std::list<std::string>> values)
        : _values(values)
    {
    }

    void operator()(const std::string& value, int index) const
    {
        (*values)[index] = value;
    }

private:
    std::shared_ptr<std::list<std::string>> _values;
};
于 2012-09-05T11:03:16.633 回答