Definite methods with parameters from variadic templates - c++

Question

I would like to define a variadic template class BaseA, which has a variadic function execute(...). The subclasses extend execute(...) with definite arguments.
I try a demo code, but it has type conversion error, how to collect all subclasses and use execute?
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// template base class A
template <typename ... Types>
class BaseA {
public:
virtual int execute(Types ...) = 0;
};
// subclass 1
class SubA1 :public BaseA<int> {
public:
int execute(int b) override {
//...
printf("sub-1 has int %d", b);
return 0;
}
};
// subclass 2
class SubA2 :public BaseA<int, string> {
public:
int execute(int b, string c) override {
//...
printf("sub-2 is int:%d and str:%s", b, c.c_str());
return 0;
}
};
// SubA3 may has other arguments
int main() {
vector<BaseA<int> *> as(3);
as[0] = (BaseA<int> *) new SubA1();
as[1] = (BaseA<int, string> *) new SubA2(); // error here
as[0]->execute(1);
as[1]->execute(1, "2");
// as[2] ...
return 0;
}
Thanks for any ideas.

Answer 1

Use another base for the array and typecast when using.
#include <iostream>
#include <string>
#include <vector>
class BaseAA {
public:
BaseAA(){
}
~BaseAA(){
}
template <typename ... Types>
int executeAA(Types ...){
std::cout << "BaseAA";
return 0;
}
};
// template base class A
template <typename ... Types>
class BaseA: public BaseAA {
public:
using BaseType = BaseA<Types...>;
virtual int execute(Types ... ts){
std::cout << "BaseA ";
return executeAA<Types ...>(ts...);
};
};
// subclass 1
class SubA1 :public BaseA<int> {
public:
int execute(int b) override {
//...
BaseType::execute(b);
std::cout << "sub-1 has int " << b << '\n';
return 0;
}
};
// subclass 2
class SubA2 :public BaseA<int, std::string> {
public:
int execute(int b, std::string c) override {
//...
BaseType::execute(b, c);
std::cout << "sub-2 is int:"<<b<<" and str:" << c;
return 0;
}
};
// SubA3 may has other arguments
int main() {
std::vector<BaseAA *> as(3);
as[0] = new SubA1();
as[1] = new SubA2(); // error here
static_cast<SubA1::BaseType*>(as[0])->execute(1);
static_cast<SubA2::BaseType*>(as[1])->execute(1, "2");
// as[2] ...
return 0;
}
If you don't want the typecast then you can use a single parameter type
with derived classes for the different groups of parameters.
#include <iostream>
#include <vector>
#include <tuple>
using namespace std::string_literals;
template <class O, class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_this(O* o, F&& f, Tuple&& t, std::index_sequence<I...>) {
return (o->*f)(std::get<I>(t)...);
}
struct ParamsBase {
};
class BaseAA {
public:
BaseAA(){
}
~BaseAA(){
}
virtual int execute(const ParamsBase& p) = 0;
};
template<typename ... Ts>
struct Params: public ParamsBase {
using Tuple_t = std::tuple<Ts...>;
static size_t const count = sizeof ... (Ts);
Tuple_t p;
Params(Tuple_t&& p): p(p){
}
static Params const& getParams(const ParamsBase& p) {
return static_cast<const Params&>(p);
}
static Tuple_t const& getTuple(const ParamsBase& p) {
return getParams(p).p;
}
};
// template base class A
template <typename ... Types>
class BaseA: public BaseAA {
public:
using Params_t = Params<Types...>;
virtual int execute(const ParamsBase& pin) override {
return apply_this(this, (int(BaseA::*)(Types...))(&BaseA::execute), Params_t::getTuple(pin), std::make_index_sequence<Params_t::count>{});
}
virtual int execute(Types ... t){
std::cout << " default ";
return 0;
}
};
// subclass 1
class SubA1 :public BaseA<int> {
public:
virtual int execute(int b) override {
BaseA::execute(b);
std::cout << " sub-1 has int " << b << '\n';
return 0;
}
};
// subclass 2
class SubA2 :public BaseA<int, std::string> {
public:
virtual int execute(int b, std::string c) override {
BaseA::execute(b, c);
std::cout << " sub-2 is int: "<<b<<" and str: " << c;
return 0;
}
};
// SubA3 may has other arguments
int main() {
std::vector<BaseAA *> as(3);
as[0] = new SubA1();
as[1] = new SubA2();
as[0]->execute(Params(std::make_tuple(1)));
as[1]->execute(Params(std::make_tuple(1, "2"s))); // s makes std::string
// as[2] ...
return 0;
}
https://godbolt.org/z/tueU2f

Answer 2

When you create a
vector<BaseA<> *> as(2);
you are expecting that vector can accept any type. Which is, I believe, wrong in C++. The vector can accept only type.
When you use template to instantiate the Base class type, the compiler will generate following class hierarchy for you.
class BaseA_int {
public:
virtual int execute(int) = 0;
};
// subclass 1
class SubA1 :public BaseA_int {
public:
int execute(int b) override {
//...
return 0;
}
};
class BaseA_int_string
{
public:
virtual int execute(int, string) = 0;
};
// subclass 2
class SubA2 :public BaseA_int_string {
int execute(int b, string c) override {
//...
return 0;
}
};
And here you can see that derived classes uses different base classes. As the vector can only one type, Base<> *, but your are assigning a type of Base to it, the compiler gives an error.
So Base and Base are entirely two different base classes.
The below will compile without any issue, but it cannot accept Base
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// template base class A
template <typename ... Types>
class BaseA {
public:
virtual int execute(Types ...) = 0;
};
// subclass 1
class SubA1 :public BaseA<int> {
int execute(int b) override {
//...
return 0;
}
};
// subclass 2
class SubA2 :public BaseA<int, string> {
int execute(int b, string c) override {
//...
return 0;
}
};
int main() {
vector<BaseA<int> *> as(2);
as[0] = (BaseA<int> *) new SubA1(); // type conversion error here
as[0]->execute(1);
return 0;
}