Russian Qt Forum

Всем привет!

Предположим у меня есть некоторая функция, аргументом которой является указатель на функцию:

C++ (Qt)
typedef int (*pFunc)(int);
int myFunction(pFunc pf){...}
... 
 

Далее, мне захотелось написать некоторый класс, например такой:

C++ (Qt)
class MyClass
{
public:
	int function(int x) {return x;} // for example
};
 

   

А теперь, как мне передать в функцию myFunction(pFunc pf) указатель на функцию данного класса (function(int)) ?

ну первое что приходит на ум это примерно так:

C++ (Qt)
#include <iostream>
using namespace std;
 
typedef int (*pFunc)(int);
 
class SomeClass
{
public:
	int f(pFunc pf) {return (*pf)(2);} // for example
};
 
class MyClass
{
public:
	int function(int x) {return x;} // for example
};
 
int main()
{
	SomeClass sc;
	int x = sc.f(reinterpret_cast<pFunc>(&MyClass::function));
 
	cout << x << endl;
	return 0;
} 
 

Но компилятор выдаёт ошибку:

Есть ли выход, господа?  ???

Если не менять сигнатуру, то boost::bind?

Спасибо! Пойду раскуривать boost::bind  :)

P.S. Я конечно уважаю библиотеку Boost, но всё же: есть ли ещё решения ?

Сделать абстрактный класс
и спользовать его вместо указателя на функцию, иначе boost::bind и boost::function.

Ну я же сказал что если не менять сигнатуру функции, иначе можно просто

Сигнатуру какой функции? Boost::bind или Boost::function умеют приводиться к указателю на функцию? Без изменения int myFunction(pFunc pf){...} разве можно что-то сделать?

Если не менять сигнатуру, то только через статическую функцию и запомненный экземпляр.
Никакой boost::bind тут не поможет, т. к. он отдаёт функтор а не указатель на функцию.
Если же сигнатуру можно менять, то вариантов куча. :)

Всем спасибо за обсуждение  :)

Ясно что указатели на члены классов ссылаются на область памяти внутри класса, а члены класса определяются смещением. Реальный адрес получается в результате применения смещения к начальному адресу конкретного объекта...
Мне лично хотелось узнать есть ли возможность приведения типа:

C++ (Qt)
pFunc pf = (pFunc)&MyClass::function;
 

 
Ну похоже, что нет... Может это и правильно  :)

Ладно, пойду пивка попью  ;D Ещё раз всем спасибо! 

В каждый не статический метод класса неявно передаётся ещё один параметр - указатель на объект данного класса (тот самый this).

shapoclak Вы лучше расскажите что вам надо в результате, а народ подскажет как красивее это сделать.

другое дело как этот "this" представляют компиляторы с разной оптимизацией и т.д.
короче так делать не хорошо. проще как выше сказали сделать наследование от IBase какая разница что хранить указатель на функцию или указатель на класс если все равно придется про "this" думать!

Даже если бы и была — в результате получился не pFunc, а что-то вроде int (*)(const MyClass*, int). Но на деле — указатели на члены очень сильно отличаются по своему устройству от обычных. Так что никакое подобное приведение невозможно. В принципе, возможно это обойти, но в любом случае — чтобы получить требуемый int (*)(int) придется где-то хранить указатель на объект. С учетом этого получаем примерно такой код:

C++ (Qt)
template<class type, int (type::*fun)(int)>
class StFunc
{
	static type *owner;
	static int call(int i)
	{
		return (owner->*fun)(i);
	}
public:
	static pFunc get_ptr(type *t)
	{
		owner=t;
		return &StFunc<type, fun>::call;
	}
};
 
template<class type, int (type::*fun)(int)> type* StFunc<type, fun>::owner;
 

Юзать это дело так:

C++ (Qt)
	MyClass m;
	pFunc pm = StFunc<MyClass, &MyClass::function>::get_ptr(&m);
 

Главная проблема в том, что и ф-ция call — указатель на которую мы передаем вместо требуемого — должна быть статической (чтобы это был обычный указатель на ф-цию). А значит — указатель на объект MyClass, который она использует, тоже должен быть статическим.
Это в свою очередь означает, что одновременно мы сможем использовать только один такой указатель для каждой пары класс/метод.

Иными словами — это костыль. Очень кривой и с большим количеством потенциальных граблей. Так что единственный случай, когда такое нужно использовать — это если мы не можем никак изменить ф-цию, которая этот самый pFunc хочет. Если же мы ее можем изменить, можно сделать гораздо проще:

Было:

C++ (Qt)
typedef int (*pFunc)(int);
 
int myFunction(pFunc pf)
{
	int i;
	// do something...
	return pf(i);
}
 

Стало:

C++ (Qt)
template<class TFunc>
int myFunction(TFunc pf)
{
	int i;
	// do something...
	return pf(i);
}
 

И все. Теперь мы можем передавать туда не только указатели на ф-ции, но и вообще все, что позволяет применить к нему operator().

Правда, напрямую мы передавать туда указатели на члены все еще не можем: для их вызова все еще требуется указатель на сам объект. А значит — если мы не хотим писать версию myFunction с двумя аргументами — нам все еще нужен переходник. Но теперь он будет устроен гораздо проще, а главное — мы избавились от статики, а значит и от ограничений на одновременное использование:

C++ (Qt)
template<class type>
class MemFun
{
	type *owner;
	int (type::*fun)(int);
public:
	MemFun(type *t, int (type::*f)(int)) : owner(t), fun(f) {}
 
	int operator()(int i)
	{
		return (owner->*fun)(i);
	}
};
 
............
	// using:
 
	MyClass m;
	MemFun<MyClass> pm(&m, &MyClass::function);
	myFunction(pm);
 

А теперь можно вспомнить, что подобный функционал (причем гораздо более гибкий, чем наш самопальный MemFun) давно уже реализован во всяких Boost и иже с ними. Собственно, именно его и предлагали использовать выше по треду...

Eugene Efremov,
Спасибо за исчерпывающий обзор!

По поводу красоты  :)

На самом деле на функцию которая получает указатель не накладывается такого жёсткого ограничения, поэтому вариантов здесь не мало, более того, заранее известно даже то, что использовать она будет функцию известного класса и даже известно какую  :) Поэтому самый простой вариант это такой:

C++ (Qt)
int myFunction(MyClass *myClass) 
{
    int i;
    ...
    return myClass->function(i);
}
 

Но пересмотрев архитектуру программы, наверно самое логичное решение унаследоваться от абстрактного класса, как предложил Barmaglodd ну и кое что ещё по мелочи изменить...