C++ 高阶模板

Question

I'm trying to create a system in C++ where I can implement many different entities E each with a different type T associated to them. I want to make a generic owner for these so that for implementations E1 associated to T1, E2 associated to T2 ect, I can wrap them inside a container where they can all be managed, something like (in pseudocode)

E<ConcreteT1> e1;
E<ConcreteT2> e2;
//...
Container c;
c.add(e1)
c.add(e2)
//...

I'm a beginner in C++ and I'm aware of basic templates, but I think I need some kind of 'higher order template' where the top level (C) is generic over the middle level (E) which is in turn generic over subsequent levels. Maybe this is a total anti-pattern and I'm doing something completely wrong. Please let me know how to solve this problem. I'm happy to use C++17 features but I would rather avoid the latest and greatest C++20 if possible.

Thank you

EDIT: The actual problem I'm trying to solve is to have an interface taking a generic E (event) in some of the methods.

template <typename E>
class Interface{
  method(E e){...}
}

I want to implement many concretions (event handlers) each with their own E (kind of events)

class EOne{}
class ImplOne:Interface<EOne>{
  method(Eone e){...}
}

class ETwo{}
class ImplTwo:Interface<ETwo>{
  method(ETwo e){...}
}

and then manage these in some more containers, say Container c as above. Then I will have a queue of callables where the callables may call methodN with the respective event types.

for(auto &handler:container){
 eventQueue.pop()();
}

I know I'm probably going down the wrong road here.

Answer 1

You could use a std::variant and use visitation.

Eg. the queue object could be defined as

using InterfaceVar = std::variant<Interface<E1>, Interface<E2>>;
std::queue< InterfaceVar > eventQueue;

Then you would use visitation to discriminate on the type (It sounds like you want it this way). You could use std::visit for this or your own method of visitation.

Example from cppreference :

#include <iomanip>
#include <iostream>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>
 
// the variant to visit
using var_t = std::variant<int, long, double, std::string>;
 
// helper constant for the visitor #3
template<class> inline constexpr bool always_false_v = false;
 
// helper type for the visitor #4
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
// explicit deduction guide (not needed as of C++20)
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
int main() {
    std::vector<var_t> vec = {10, 15l, 1.5, "hello"};
    for(auto& v: vec) {
 
        // 1. void visitor, only called for side-effects (here, for I/O)
        std::visit([](auto&& arg){std::cout << arg;}, v);
 
        // 2. value-returning visitor, demonstrates the idiom of returning another variant
        var_t w = std::visit([](auto&& arg) -> var_t {return arg + arg;}, v);
 
        // 3. type-matching visitor: a lambda that handles each type differently
        std::cout << ". After doubling, variant holds ";
        std::visit([](auto&& arg) {
            using T = std::decay_t<decltype(arg)>;
            if constexpr (std::is_same_v<T, int>)
                std::cout << "int with value " << arg << '\n';
            else if constexpr (std::is_same_v<T, long>)
                std::cout << "long with value " << arg << '\n';
            else if constexpr (std::is_same_v<T, double>)
                std::cout << "double with value " << arg << '\n';
            else if constexpr (std::is_same_v<T, std::string>)
                std::cout << "std::string with value " << std::quoted(arg) << '\n';
            else 
                static_assert(always_false_v<T>, "non-exhaustive visitor!");
        }, w);
    }
 
    for (auto& v: vec) {
        // 4. another type-matching visitor: a class with 3 overloaded operator()'s
        std::visit(overloaded {
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; },
        }, v);
    }
}