Я хотел бы настроить указатель на функцию как член класса, который является указателем на другую функцию в том же классе. Причины, по которым я это делаю, сложны.
В этом примере я хотел бы, чтобы результат был «1»
class A {
public:
int f();
int (*x)();
}
int A::f() {
return 1;
}
int main() {
A a;
a.x = a.f;
printf("%d\n",a.x())
}
Но это не получается при компиляции. Зачем?
c++
oop
function-pointers
Майк
источник
источник
Ответы:
Синтаксис неправильный. Указатель на член - это категория типа, отличная от обычного указателя. Указатель на член нужно будет использовать вместе с объектом своего класса:
class A { public: int f(); int (A::*x)(); // <- declare by saying what class it is a pointer to }; int A::f() { return 1; } int main() { A a; a.x = &A::f; // use the :: syntax printf("%d\n",(a.*(a.x))()); // use together with an object of its class }
a.x
еще не сказано, для какого объекта должна быть вызвана функция. Он просто говорит, что вы хотите использовать указатель, хранящийся в объектеa
. Добавлениеa
другого времени в качестве левого операнда к.*
оператору сообщит компилятору, для какого объекта следует вызвать функцию.источник
(a.*a.x)()
Почему(a.*x)()
не работает?a.x
является указателем на функцию-член класса A.*a.x
разыменовывает указатель, поэтому теперь это ссылка на функцию.a.(*a.x)
«привязывает» функцию к экземпляру (точно так жеa.f
).(a.(*a.x))
необходимо сгруппировать этот сложный синтаксис и(a.(*a.x))()
фактически вызывает методa
без аргументов.int (*x)()
не является указателем на функцию-член. Указатель на функцию - член записывается следующим образом:int (A::*x)(void) = &A::f;
.источник
Вызов функции-члена в строковой команде
#include <iostream> #include <string> class A { public: void call(); private: void printH(); void command(std::string a, std::string b, void (A::*func)()); }; void A::printH() { std::cout<< "H\n"; } void A::call() { command("a","a", &A::printH); } void A::command(std::string a, std::string b, void (A::*func)()) { if(a == b) { (this->*func)(); } } int main() { A a; a.call(); return 0; }
Обратите внимание
(this->*func)();
и на способ объявления указателя функции с именем классаvoid (A::*func)()
источник
Вам необходимо использовать указатель на функцию-член, а не просто указатель на функцию.
class A { int f() { return 1; } public: int (A::*x)(); A() : x(&A::f) {} }; int main() { A a; std::cout << (a.*a.x)(); return 0; }
источник
Хотя это основано на безупречных ответах в другом месте на этой странице, у меня был вариант использования, который они полностью не решили; для вектора указателей на функции выполните следующие действия:
#include <iostream> #include <vector> #include <stdio.h> #include <stdlib.h> class A{ public: typedef vector<int> (A::*AFunc)(int I1,int I2); vector<AFunc> FuncList; inline int Subtract(int I1,int I2){return I1-I2;}; inline int Add(int I1,int I2){return I1+I2;}; ... void Populate(); void ExecuteAll(); }; void A::Populate(){ FuncList.push_back(&A::Subtract); FuncList.push_back(&A::Add); ... } void A::ExecuteAll(){ int In1=1,In2=2,Out=0; for(size_t FuncId=0;FuncId<FuncList.size();FuncId++){ Out=(this->*FuncList[FuncId])(In1,In2); printf("Function %ld output %d\n",FuncId,Out); } } int main(){ A Demo; Demo.Populate(); Demo.ExecuteAll(); return 0; }
Что-то подобное полезно, если вы пишете командный интерпретатор с индексированными функциями, которые необходимо объединить с синтаксисом параметров и подсказками и т. Д. Возможно, также полезно в меню.
источник
typedef int (A::*AFunc)(int I1,int I2);
Хотя вы, к сожалению, не можете преобразовать существующий указатель функции-члена в простой указатель функции, вы можете создать шаблон функции-адаптера довольно простым способом, который обертывает указатель функции-члена, известный во время компиляции, в обычной функции, например:
template <class Type> struct member_function; template <class Type, class Ret, class... Args> struct member_function<Ret(Type::*)(Args...)> { template <Ret(Type::*Func)(Args...)> static Ret adapter(Type &obj, Args&&... args) { return (obj.*Func)(std::forward<Args>(args)...); } }; template <class Type, class Ret, class... Args> struct member_function<Ret(Type::*)(Args...) const> { template <Ret(Type::*Func)(Args...) const> static Ret adapter(const Type &obj, Args&&... args) { return (obj.*Func)(std::forward<Args>(args)...); } };
int (*func)(A&) = &member_function<decltype(&A::f)>::adapter<&A::f>;
Обратите внимание, что для вызова функции-члена
A
должен быть предоставлен экземпляр .источник
Основываясь на ответе @ IllidanS4, я создал класс шаблона, который позволяет передавать практически любую функцию-член с предопределенными аргументами и экземпляром класса по ссылке для последующего вызова.
template<class RET, class... RArgs> class Callback_t { public: virtual RET call(RArgs&&... rargs) = 0; //virtual RET call() = 0; }; template<class T, class RET, class... RArgs> class CallbackCalltimeArgs : public Callback_t<RET, RArgs...> { public: T * owner; RET(T::*x)(RArgs...); RET call(RArgs&&... rargs) { return (*owner.*(x))(std::forward<RArgs>(rargs)...); }; CallbackCalltimeArgs(T* t, RET(T::*x)(RArgs...)) : owner(t), x(x) {} }; template<class T, class RET, class... Args> class CallbackCreattimeArgs : public Callback_t<RET> { public: T* owner; RET(T::*x)(Args...); RET call() { return (*owner.*(x))(std::get<Args&&>(args)...); }; std::tuple<Args&&...> args; CallbackCreattimeArgs(T* t, RET(T::*x)(Args...), Args&&... args) : owner(t), x(x), args(std::tuple<Args&&...>(std::forward<Args>(args)...)) {} };
Тест / пример:
class container { public: static void printFrom(container* c) { c->print(); }; container(int data) : data(data) {}; ~container() {}; void print() { printf("%d\n", data); }; void printTo(FILE* f) { fprintf(f, "%d\n", data); }; void printWith(int arg) { printf("%d:%d\n", data, arg); }; private: int data; }; int main() { container c1(1), c2(20); CallbackCreattimeArgs<container, void> f1(&c1, &container::print); Callback_t<void>* fp1 = &f1; fp1->call();//1 CallbackCreattimeArgs<container, void, FILE*> f2(&c2, &container::printTo, stdout); Callback_t<void>* fp2 = &f2; fp2->call();//20 CallbackCalltimeArgs<container, void, int> f3(&c2, &container::printWith); Callback_t<void, int>* fp3 = &f3; fp3->call(15);//20:15 }
Очевидно, это будет работать, только если данные аргументы и класс владельца все еще действительны. Что касается читабельности ... простите меня.
Изменить: удалил ненужный malloc, сделав кортеж нормальным хранилищем. Добавлен унаследованный тип для ссылки. Добавлена возможность предоставить все аргументы вместо этого во время вызова. Сейчас работаем над обоими ....
Изменить 2: Как и было обещано. Единственное ограничение (которое я вижу) состоит в том, что предопределенные аргументы должны быть перед аргументами, предоставленными средой выполнения в функции обратного вызова. Спасибо @Chipster за помощь в соблюдении требований gcc. Это работает на gcc на ubuntu и visual studio на windows.
#ifdef _WIN32 #define wintypename typename #else #define wintypename #endif template<class RET, class... RArgs> class Callback_t { public: virtual RET call(RArgs... rargs) = 0; virtual ~Callback_t() = default; }; template<class RET, class... RArgs> class CallbackFactory { private: template<class T, class... CArgs> class Callback : public Callback_t<RET, RArgs...> { private: T * owner; RET(T::*x)(CArgs..., RArgs...); std::tuple<CArgs...> cargs; RET call(RArgs... rargs) { return (*owner.*(x))(std::get<CArgs>(cargs)..., rargs...); }; public: Callback(T* t, RET(T::*x)(CArgs..., RArgs...), CArgs... pda); ~Callback() {}; }; public: template<class U, class... CArgs> static Callback_t<RET, RArgs...>* make(U* owner, CArgs... cargs, RET(U::*func)(CArgs..., RArgs...)); }; template<class RET2, class... RArgs2> template<class T2, class... CArgs2> CallbackFactory<RET2, RArgs2...>::Callback<T2, CArgs2...>::Callback(T2* t, RET2(T2::*x)(CArgs2..., RArgs2...), CArgs2... pda) : x(x), owner(t), cargs(std::forward<CArgs2>(pda)...) {} template<class RET, class... RArgs> template<class U, class... CArgs> Callback_t<RET, RArgs...>* CallbackFactory<RET, RArgs...>::make(U* owner, CArgs... cargs, RET(U::*func)(CArgs..., RArgs...)) { return new wintypename CallbackFactory<RET, RArgs...>::Callback<U, CArgs...>(owner, func, std::forward<CArgs>(cargs)...); }
источник