Есть немного странная задача.

Нужно создать класс (на основе шаблонов) который мог бы вызывать функции 2 типов.

1 тип - обычная функция
2 тип - метод класса

например

Код

class Caller {     private:         typedef unsigned (__stdcall *PFUNC_THREAD)(void *);         PFUNC_THREAD func_;         Caller (const Caller& copy);         Caller& operator = (const Caller& copy);     public:         Caller(PFUNC_THREAD func, void *arg)  : func_(func);         virtual ~Caller () {}         virtual void Call(void) const {             (func_)(arg_);         } };

и

Код

template <class T> class Caller {     private:         typedef unsigned (T::*Func)(void *arg);         T *obj_;         Func func_;         void *arg_;         Caller (const Caller& copy);         Caller& operator = (const Caller& copy);     public:         Caller(T *obj, Func func, void *arg) :                obj_(obj), func_(func), arg_ (arg){}         virtual ~Caller () {}         virtual void Call(void) const {             (obj_->*func_)(arg_);         } };

только вот зотелось бы с помощью шаблонов создать один класс, который в конструкторе будет принимать указатель либо на фуннкцию, либо на метод - ну и соответственно дергать нужную

Метод в лоб, пишу на коленке, выдумывать элегантное решение в лом

Код

struct Caller_Impl {   virtual void call()=0; }; template  <class _Tp> struct Caller_Method : public  Caller_Impl {       Caller_Method (_Tp* ptr, void(_Tp::*f)(void*), void* arg) : m_ptr(ptr), m_arg(arg), m_func(f){}       void call(){         (m_ptr->*m_func)(m_arg);       }          _Tp* m_ptr;      void* m_arg;      void (_Tp::*m_func) (void*); }; struct Caller_Function : public  Caller_Impl {       Caller_Function(void (*f)(), void* arg) :  m_func(f), m_arg(arg){}       void call(){         m_func(m_arg);       }          void* m_arg;      void (*m_func) (void*); }; struct Caller {      template<class _T>      Caller(T* cl, void(T::*func)(), void* arg ){           m_caller = new Caller_Method<T>(cl,func,arg);      }      Caller(void (*func)(), void* arg){           m_caller = new Caller_Function(func,arg);      }     void call(){        m_caller->call();     }     CallerImpl* m_caller; };

Думаю идея понятна

Это сообщение отредактировал(а) Mayk - 17.12.2005, 19:52

Mayk, спасибо - хорошее решение

Цитата(Mayk @ 17.12.2005, 19:50)

выдумывать элегантное решение в лом

а что - можешь еще лучше предложить

Могу предложить попробовать обойтись без использования доп классов. Правда это нечитабельнее

Что-то типа (часть кода за вызов ф-ции и очевидный деструктор опущу)

Код

class Caller {  template<class _Tp>  Caller(_Tp* ptr, void (_Tp::*fn)(), void* arg ){             typedef void (_Tp::*Method)(void*);     call_impl = &Caller::callMethod<_Tp> ;      m_data = new char[sizeof(_Tp*) +  sizeof(Method) +  sizeof(void*)];  //m_data = { _Tp*, func(), arg}     char* p = m_data;     memcpy(p, ptr, sizeof(ptr));  p+= sizeof(ptr);     memcpy(p, fn, sizeof(fn));  p+= sizeof(fn);     memcpy(p, arg, sizeof(arg));   }  void call(){    call_impl();  }  template<class _Tp>  void callMethod(){        char* p = m_data;        _Tp* ptr;          Method* fn;        void* arg;         typedef void (_Tp::*Method)(void*);     memcpy(ptr,p, sizeof(ptr));  p+= sizeof(ptr);     memcpy(fn,p, sizeof(fn));  p+= sizeof(fn);     memcpy(arg,p, sizeof(arg));                  (ptr->*m)(p);  }  void (Caller::*call_impl)(void*);  сhar* m_data; };

Не сказал бы что это лучше :-)
Вывод - очевидные решения предпочтительнее неочевидных

Это сообщение отредактировал(а) Mayk - 17.12.2005, 20:28

Mayk, что-то никак не соберу

Код

class CallerImpl {     private :         CallerImpl (const CallerImpl& copy);         CallerImpl& operator = (const CallerImpl& copy);     protected :         void *arg_;         CallerImpl () : arg_ (NULL) {}         virtual ~CallerImpl () {}     public :         virtual void Call(void) const = 0; }; /*----------------------------------------------------------------------------*/ class StaticCaller : private CallerImpl {     private :         typedef unsigned (__stdcall *Func)(void *);         const Func func_;         StaticCaller (const StaticCaller& copy);         StaticCaller& operator = (const StaticCaller& copy);         virtual void Call (void) const { func_ (arg_); }     public :         StaticCaller (Func func, void *arg) : func_(func), arg_ (arg) {}         virtual ~StaticCaller () {} }; /*----------------------------------------------------------------------------*/ template <class T> class ClassCaller : private CallerImpl {     private :         typedef unsigned (T::*Func)(void *arg);         const T *obj_;         const Func func_;         ClassCaller (const ClassCaller& copy);         ClassCaller& operator = (const ClassCaller& copy);         virtual void Call (void) const { (obj_->*func_) (arg); }     public :         ClassCaller (T *obj, Func func, void *arg) :                      obj_(obj), func_(func) { arg_ = arg; }         virtual ~ClassCaller () {} }; /*----------------------------------------------------------------------------*/ class MyClass {     private :         CallerImpl caller_;     public :         template <class T>         MyClass (T *obj, unsigned (T::*Func)(void *), void *arg) : caller_(NULL) {             caller_ = new ClassCaller (obj, Func, arg);         }         MyClass (unsigned (__stdcall *Func)(void *), void *arg) : caller_(NULL) {             caller_ = new StaticCaller (Func, arg);         } };

не хочет так

Это сообщение отредактировал(а) zss - 17.12.2005, 21:15

Почитай сообщения об ошибках

Код

class CallerImpl {     private :         CallerImpl (const CallerImpl& copy);         CallerImpl& operator = (const CallerImpl& copy);     protected :         void *arg_;         CallerImpl () : arg_ (NULL) {}         virtual ~CallerImpl () {}     public :         virtual void Call(void) const = 0; }; /*----------------------------------------------------------------------------*/ class StaticCaller : public CallerImpl {     private :         typedef unsigned (*Func)(void *);         const Func func_;         StaticCaller (const StaticCaller& copy);         StaticCaller& operator = (const StaticCaller& copy);         virtual void Call (void) const { func_ (arg_); }     void* arg_;     public :         StaticCaller (Func func, void *arg) : func_(func), arg_ (arg) {}         virtual ~StaticCaller () {} }; /*----------------------------------------------------------------------------*/ template <class T> class ClassCaller : public CallerImpl {     private :         typedef unsigned (T::*Func)(void *arg);         const T *obj_;         const Func func_;         ClassCaller (const ClassCaller& copy);         ClassCaller& operator = (const ClassCaller& copy);         virtual void Call (void) const { (obj_->*func_) (arg); }     public :         ClassCaller (T *obj, Func func, void *arg) :                      obj_(obj), func_(func) { arg_ = arg; }         virtual ~ClassCaller () {} }; /*----------------------------------------------------------------------------*/ class MyClass {     private :         CallerImpl* caller_;     public :         template <class T>         MyClass (T *obj, unsigned (T::*Func)(void *), void *arg) : caller_(NULL) {             caller_ = new ClassCaller<T> (obj, Func, arg);         }         MyClass (unsigned (*Func)(void *), void *arg) : caller_(NULL) {             caller_ = new StaticCaller (Func, arg);         } };

Mayk, я так понимаю ты подправил

Код

ClassCaller[b]<T>[/b]

мой косяк - упустил

Код

class StaticCaller : public CallerImpl {     private :         void* arg_;  // Зачем еще раз ?

говорит, что не может конвертнуть StaticCaller* в Callerimpl* - странно ...

Цитата(zss @ 18.12.2005, 02:11)

void* arg_;  // Зачем еще раз ?

g++ ругался, что arg_ не найден.
Добавлено @ 22:15
Стоп. Понял.

Цитата(zss @ 18.12.2005, 01:12)

StaticCaller (Func func, void *arg) : func_(func), arg_ (arg) {}

Так нельзя - arg_ принадлежит базовому классу, который УЖЕ проинициализирован. => инициализировать его нельзя

Цитата(Mayk @ 17.12.2005, 22:13)

Так нельзя - arg_ принадлежит базовому классу, который УЖЕ проинициализирован. => инициализировать его нельзя

значит придется заводить arg_ для каждого наследника ?

З.Ы. Попробовал - не прокатило

Это сообщение отредактировал(а) zss - 17.12.2005, 22:21

Цитата(zss @ 18.12.2005, 02:18)

значит придется заводить arg_ для каждого наследника ?

Не обязательно

Цитата(zss @ 18.12.2005, 01:12)

ClassCaller (T *obj, Func func, void *arg) :                     obj_(obj), func_(func) { arg_ = arg; }

Вот это работает
Добавлено @ 22:24

Цитата(zss @ 18.12.2005, 02:18)

З.Ы. Попробовал - не прокатило

Цитата(zss @ 18.12.2005, 01:12)

virtual void Call (void) const { (obj_->*func_) (arg); }

компилятор даже знает почему

это ошибки из-за большого количества спиртного

Код

class CallerImpl {     private :         CallerImpl (const CallerImpl& copy);         CallerImpl& operator = (const CallerImpl& copy);     protected :         void *arg_;         CallerImpl () : arg_ (NULL) {}         virtual ~CallerImpl () {}         virtual void Call(void) const = 0; }; /*----------------------------------------------------------------------------*/ class StaticCaller : private CallerImpl {     private :         typedef unsigned (*Func)(void *);         Func func_;         StaticCaller (const StaticCaller& copy);         StaticCaller& operator = (const StaticCaller& copy);         virtual void Call (void) const { func_ (arg_); }     public :         StaticCaller (Func func, void *arg) : func_(func), arg_ (arg) {}         virtual ~StaticCaller () {} }; /*----------------------------------------------------------------------------*/ template <class T> class ClassCaller : private CallerImpl {     private :         typedef unsigned (T::*Func)(void *arg);         T *obj_;         Func func_;         ClassCaller (const ClassCaller& copy);         ClassCaller& operator = (const ClassCaller& copy);         virtual void Call (void) const { (obj_->*func_) (arg_); }     public :         ClassCaller (T *obj, Func func, void *arg) :                      obj_(obj), func_(func), arg_ (arg) {}         virtual ~ClassCaller () {} }; /*----------------------------------------------------------------------------*/

говорит

Код

'constructor' is not an unambiguous base class of 'class'

Цитата(zss @ 18.12.2005, 02:33)

ClassCaller (T *obj, Func func, void *arg) :                     obj_(obj), func_(func), arg_ (arg) {}

Ну и зачем? arg_ нельзя инициализировать. Он уже инициализирован в базовом классе. => надо писать
arg_=arg, как и было раньше.

Цитата(zss @ 18.12.2005, 02:33)

'constructor' is not an unambiguous base class of 'class'

где говорит?

Цитата(Mayk @ 17.12.2005, 22:42)

где говорит?

Код

class MyClass {     private :         CallerImpl* caller_;     public :         template <class T>         MyClass (T *obj, unsigned (T::*Func)(void *), void *arg) : caller_(NULL) {             caller_ = new ClassCaller<T> (obj, Func, arg);         }         MyClass (unsigned (*Func)(void *), void *arg) : caller_(NULL) {             caller_ = new StaticCaller (Func, arg); // здесь         } };

Замени private наследование на public

Mayk, спасибо - вроде собралось

Еще вопрос - эти 2 конструктора придется всегда за собой таскать и для порожденных классов ? Если да - то можно ли что-нибудь придумать (чтоб не таскать - хотя есть большие подозрения, что нельзя )

Если это не учебная задача, а практическая, лучше использовать готовое решение, например boost::function + boost::bind.
Все-таки это чисто техническая задача, и тратить время на ее решение (когда она уже решена так мощно, как в бусте), не целесообразно.
Стоит только посмотреть на бустовский код, чтобы понять трудозатраты на разработку подобных вещей...
Не обязательно использовать именно boost, есть еще Loki и другие подобные библиотеки.

да вроде результат достигнут.
а по boosr у меня нет инфы

Добрый вечер.
У меня один пробел остался с использованием шаблонов. Даже в книгах Страуструпа не нашел ответа.
Я хочу спецализировать конструктор в классе. Я могу написать вот так:

Но если пишу так:

компилятор пишет, что нужно написать специализацию всего класса.  Пожалуйста поясните, как можно быстрее.

Здравствуйте, добро пожаловать на форум!

частичная специализацию функций запрещена(если мне память не изменяет).



Это сообщение отредактировал(а) vinter - 8.1.2009, 19:00

используйте перегрузку, вместо частичной специализации

Гениальный совет 
Покажи же, как сие чудо будет выглядеть применительно к

Т.е. либо специализировать полностью функцию, либо специализировать весь класс. А случайно никто не знает, почему Страуструп решил так спроектировать использование шаблонов?(какова причина)

Как я понимаю таких данных ни у кого нет. А случайно в стандарте не будет ответа на мой вопрос?

проще всего посмотреть самому, чем ждать, что это сделают за тебя.


С++ сейчас не является полностью творением Страуструпа, над С++ работает целый комитет по стандартизации. Если я ничег не путаю, то отсутсвие часьтичной специализации функций это недоразумение которое будет исправлено в С++09

Вероятно опять неправильно оценили высказывание:


оно не говорит, что перегрузка заменит во всем специализацию,
а о том, что при разработке автоматизацию следует искать в перегрузке, а не частичной специализации.
И подход соответсвенно надо выбирать соответствующий. 



Это сообщение отредактировал(а) mes - 10.1.2009, 13:37

Это ты сам придумал или вычитал из какой-нибудь статьи под названием "Советы пьяного ёжика"?

Нельзя ли точней указать на тот момент, который вы подвергаете сомнению - иначе боюсь мы будем обсуждать разное. 

Я могу подвергать сомнению только утверждения, смысл которых мне полностью ясен.
Ты так и не ответил на мой вопрос.

Я не ответил, потому что не понял, о чем конкретно Вы спрашивуете 
Исходя из вышесказанного, я лишь могу ответить : прямого цитирования чего либо там не было.

Добавлено через 1 минуту и 18 секунд

Ну а показать, где неясности в высказываниях возможно ?

Я спрашивал о том, что утверждалось в процитированном тексте. Или там ничего не утверждалось? 



Какую автоматизацию?

Вот так твоя писанина выглядит со стороны: "при разработке бла-бла-бла следует искать в перегрузке, а не частичной специализации.
И подход соответсвенно надо выбирать соответствующий." Я могу лишь читать текст, который ты пишешь, но не могу угадывать твои мысли. Бесплатный совет: если хочешь, чтоб тебя понимали, при выражении своих мыслей в тексте попробуй поставить себя на место читателя, который не осведомлён насчёт твоих заморочек, потому что о них может быть известно только тебе. 

Это сообщение отредактировал(а) UnrealMan - 10.1.2009, 21:14

Ну, во первых, хватит оффтопить. Как никак мы здесь шаблоны обсуждаем.
vinter, ты не мог сказать откуда у тебя сведения о С++09. Может ссылку кинешь.

http://www.open-std.org/JTC1/SC22/WG21/ оригинал
обсуждения:
http://habrahabr.ru/blogs/cpp/25330/
http://forum.sources.ru/index.php?showtopic=190375&st=0

Можете мне не верить, но я всегда стараюсь (и учусь) подобрать выражение и исправиться сли поняли меня не корректно.  




на этом основание я отнес шаблоны, специализацию, и перегрузку к средствам автоматизации.
И имхо не только я, потму что употребления этого слова (автоматизация) в таком контексте встречалась не раз как в литературе, так и на форумах.


Цитата с автоматизацией была пояснящая предыдущую цитату.. но к сожаление ей не удалось выполнить задачу 

Основная цитата эта :

Попробую перефразировать еще раз :
Когда нужно шаблонной функции задать определенное поведение , для определенных типов параметров, то за неимением частичной специализации, можно попытаться найти решение с помощью перегрузки.


Добавлено через 3 минуты и 26 секунд

Так вроде как раз по теме. Идет обсуждение на правильность одного из ответов. 

Замечательно. Только вот смысл той фразы от этого как-то не проясняется.


Ну, это совсем не то же самое, что


"Используйте" и "рассмотрите вариант с использованием" - не одно и то же.

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


Тоже вполне известный подход наравне с перегрузкой.

Это сообщение отредактировал(а) UnrealMan - 11.1.2009, 04:26

Постараюсь более точно подбирать глаголы 
А все таки хорошо, что на фоурме есть такой придирчивый к словам человек   

Спасибо, vinter. Наверное, все таки обсуждение по поводу корректного написания сообщений в тему не оффтоп.