Question

我正在尝试存储和操作具有不同参数类型的模板类对象列表;模板类有两个参数化方法，一个返回参数类型，一个 void 一个接受它作为输入。

更具体地说，我有一个模板类定义如下：

class TestInt : public Test<int>
{
public:
    int a() {
        return 1;
    }
    void b(int t) {
        std::cout << t << std::endl;
    }
};

class TestString : public Test<std::string>
{
public:
    std::string a() {
        return "test";
    }
    void b(std::string t) {
        std::cout << t << std::endl;
    }
};

它的不同规格，如：

TestInt

我希望能够在单个列表中存储TestString和for (auto it = list.begin(); it != list.end(); ++it) (*it)->b((*it)->a());类型的不同对象，并通过它调用一个方法作为另一个方法的输入，如：

boost::any

我查看了Test但是我无法将迭代器强制转换为特定的类，因为我不知道每个存储对象的具体参数类型。也许这不能用像C ++这样的静态类型语言来完成，但我想知道是否可以解决这个问题。

为了完整起见，我要补充一点，我的总体目标是开发一个“参数化观察者”，即能够用不同的参数定义观察者（与观察者模式一样）：{{1} class是观察者类，而我正在尝试正确定义的不同类型观察者的列表存储在主题类中，通过两种方法a()和b()通知它们。

Answer 1

虚拟实际上没有任何意义，因为对于每个T，签名都是不同的。

所以看起来你还有另一个版本的永恒＆＃34;我们如何模拟虚拟功能模板＆＃34;或者＆＃34;如何创建没有虚函数的界面＆＃34;：

第一个基本上包含了你可以在这里使用的想法。

以下是我要做的事情：

<强> Live On Coliru

#include <algorithm>
#include <iostream>

namespace mytypes {
    template <typename T>
    struct Test {
        T a() const;
        void b(T t) { std::cout << t << std::endl; } 
    };

    template <> int         Test<int>::a()         const { return 1;      }
    template <> std::string Test<std::string>::a() const { return "test"; }

    using TestInt    = Test<int>;
    using TestString = Test<std::string>;
}

#include <boost/variant.hpp>

namespace mytypes { 
    using Value = boost::variant<int, std::string>;

    namespace detail {
        struct a_f : boost::static_visitor<Value> {
            template <typename T>
            Value operator()(Test<T> const& o) const { return o.a(); }
        };
        struct b_f : boost::static_visitor<> {
            template <typename T>
            void operator()(Test<T>& o, T const& v) const { o.b(v); }

            template <typename T, typename V>
            void operator()(Test<T>&, V const&) const {
                throw std::runtime_error(std::string("type mismatch: ") + __PRETTY_FUNCTION__);
            }
        };
    }

    template <typename O>
    Value a(O const& obj) {
        return boost::apply_visitor(detail::a_f{}, obj);
    }

    template <typename O, typename V>
    void b(O& obj, V const& v) {
        boost::apply_visitor(detail::b_f{}, obj, v);
    }
}

#include <vector>

int main()
{
    using namespace mytypes;
    using AnyTest = boost::variant<TestInt, TestString>;

    std::vector<AnyTest> list{TestInt(), TestString(), TestInt(), TestString()};

    for (auto it = list.begin(); it != list.end(); ++it)
        b(*it, a(*it));
}

打印

1
test
1
test

奖励积分

如果你坚持，你可以将AnyTest变体包装到一个合适的类中，并拥有a()和b(...)成员函数：

<强> Live On Coliru

int main()
{
    using namespace mytypes;
    std::vector<AnyTest> list{AnyTest(TestInt()), AnyTest(TestString()), AnyTest(TestInt()), AnyTest(TestString())};

    for (auto it = list.begin(); it != list.end(); ++it)
        it->b(it->a());
}

Answer 2

扩展我上面的评论，我目前想到的最简单的方法是实现你想要做的事情 - 至少我从你的示例代码中理解它 - 如下：

/* Interface for your container, better not forget the destructor! */
struct Test {
  virtual void operate(void) = 0;
  virtual ~Test() {}
};
/* Implementation hiding actual type */
template<typename T>
struct TestImpl : public T, public Test {
  void operate(void) {
    T::b(T::a());
  }
};

/* Actual code as template policies */
struct IntTest {
  int a(void) {
    return 42;
  }
  void b(int value) {
    std::cout << value << std::endl;
  }
};
struct StringTest {
  std::string a(void) {
    return "Life? Don't talk to me about life.";
  }
  void b(std::string value) {
    std::cout << value << std::endl;
  }
};

然后，您需要为类Test的对象创建容器，并使用相应TestImpl<IntTest>，TestImpl<StringTest>的对象填充它，依此类推。要避免对象切片，您需要引用或指针语义，例如std::vector<std::unique_ptr<Test> >。

for (auto it = list.begin(); it != list.end(); ++it) {
  (*it)->operate();
}

使用不同的模板参数在列表项上调用参数化方法

2 个答案:

奖励积分