当所有类型都没有任何公共代码时使用模板

Using template when none of the types have any code in common

本文关键字：代码 任何公 类型      更新时间：2023-10-16

我有以下类：

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上操作，后者将其数据存储在联合的缓冲区中。我将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;

我该怎么做？

只做显而易见的事情。没有要求模板专业化与另一个专业化或原始模板有任何共同点。因此：

class IIntValueSetter {
};
template <class Ty> class ValueSetter; // declared but not defined
template <>
class ValueSetter<int> : public IIntValueSetter {
    // whatever
};
ValueSetter<int> vsi;

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

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

我想我在找这样的东西。我在下面只实现了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;
};
相关文章：