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 の知識がない Container クラスに ValueSetter を渡します。実際、将来的には 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 に答える