Добрый день!
Допустим есть такой код:
struct runable {
virtual void execute() = 0;
};
struct runable_for_str : runable {
char temp[256];
const char* value;
runable_for_str(const char* value) :value(value) {}
virtual void execute() { /* Some logic here */ }
};
struct runable_for_int : runable {
int value;
runable_for_int(int value) :value(value) {}
virtual void execute() { /* Some logic here */ }
};
void proc1(const runable& callback) {}
void proc2(const runable& callback) {}
Сейчас вызов процедур proc1, proc2 выглядит как
proc1(runable_for_str("Some string")) {}
proc2(runable_for_int(123)) {}
Есть ли возможность каким-то паттерном автоматически определять тип? В идеале чтобы вызов свелся к следующему
proc1("Some string");
proc2(123);
Если же так не получится, то хотябы к такому:
proc1(driver_proc("Some string"));
proc2(driver_proc(123));
Я пробывал пойти через промежуточную функцию driver_proc — там перегрузка типов работает, но преобразовать промежуточные классы в runable() не получается.
Здравствуйте, PavelCH, Вы писали:
PCH>Есть ли возможность каким-то паттерном автоматически определять тип?
typedef void (*proc_fn)(const runable& callback);
void run(proc_fn fn,int value) { fn(runable_for_int(value)); }
void run(proc_fn fn,const char* value) { fn(runable_for_str(value)); }
...
run(proc1,"Some string");
run(proc2,123);
_>_>typedef void (*proc_fn)(const runable& callback);
_>void run(proc_fn fn,int value) { fn(runable_for_int(value)); }
_>void run(proc_fn fn,const char* value) { fn(runable_for_str(value)); }
_>...
_>run(proc1,"Some string");
_>run(proc2,123);
_>
Спасибо, не смотрел в этом направлении. Там просто есть еще проблема. Функции proc1, proc2, ... они могут быть разные по числу параметров и runable один из них.
Здравствуйте, PavelCH, Вы писали:
PCH>Допустим есть такой код:
PCH>...
PCH>Сейчас вызов процедур proc1, proc2 выглядит как
PCH>...
PCH>Есть ли возможность каким-то паттерном автоматически определять тип? В идеале чтобы вызов свелся к следующему
PCH>PCH>proc1("Some string");
PCH>proc2(123);
PCH>
Здесь можно было бы пробовать разнообразные подходы. Но я бы предоложил начать с рассмотрения несложного редизайна, который автоматом решает проблему (упрощенно):
struct runable {
virtual void execute() = 0;
};
template <typename> struct runable_impl;
template<>
struct runable_impl<const char*> : runable {
char temp[256];
const char* value;
runable_impl(const char* value) :value(value) {}
virtual void execute() { /* Some logic here */ }
};
template<>
struct runable_impl<int> : runable {
int value;
runable_impl(int value) :value(value) {}
virtual void execute() { /* Some logic here */ }
};
template <typename T>
void proc1(const T& t) {
runable_impl<T>(t).execute();
}
template <typename T>
void proc2(const T& t) {
runable_impl<T>(t).execute();
}
proc1("Some string");
proc2(123);
R>Здесь можно было бы пробовать разнообразные подходы. Но я бы предоложил начать с рассмотрения несложного редизайна, который автоматом решает проблему (упрощенно):
Вдохновился Вашим примерчиком и написал такую штуку — вроде то что надо:
struct runable {
virtual void execute() const = 0;
};
template <typename T> struct runable_impl : runable {
runable_impl(T t);
};
template<> struct runable_impl<const char*> : runable {
char temp[256];
const char* value;
runable_impl(const char* value) : value(value) {}
virtual void execute() const { /* Some logic here */ }
};
template<> struct runable_impl<int> : runable {
int value;
runable_impl(int value) :value(value) {}
virtual void execute() const { /* Some logic here */ }
};
template <typename T> runable_impl<T> cmdx(T t) {
return runable_impl<T>(t);
}
void proc1(const runable& cmd) {
cmd.execute();
}
void proc2(const runable& cmd) {
cmd.execute();
}
int main() {
proc1(cmdx(123));
proc2(cmdx("Some string"));
return 0;
}
