C++: требуется статическая функция в абстрактном классе

Question

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

Например:

class AbstractCoolThingDoer 
{ 
    void dosomethingcool() = 0; // now if you implement this class 
             // you better do this 
} 

class CoolThingDoerUsingAlgorithmA: public AbstractCoolthingDoer 
{ 
    void dosomethingcool() 
    { 
     //do something cool using Algorithm A 
    } 
} 

class CoolThingDoerUsingAlgorithmB: public AbstractCoolthingDoer 
{ 
    void dosomethingcool() 
    { 
     //do the same thing using Algorithm B 
    } 
} 

Теперь я хотел бы сделать coolthing без деталей, как coolthing будет сделано. Так что я хотел бы сделать что-то вроде

AbstractCoolThingDoer:dosomethingcool(); 

без необходимости знать, как coolthing будет сделано, но это, кажется, требуется функция, которая одновременно является виртуальной и статическим, который, конечно, противоречие.

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

РЕДАКТИРОВАТЬ: Не уверен, что я понял, чего я пытаюсь достичь. У меня есть 3 критерии, которые я ищу, чтобы удовлетворить

1. библиотека, которая использует abstractcoolthingdoer и не должны быть переписаны когда-либо, даже если другой coolthingdoer написано, что библиотека никогда не слышал.

2. Если вы попытаетесь написать coolthingdoer, который не соответствует требуемой структуре, исполняемый файл, который использует библиотеку, не будет компилироваться.

3. coolthingdoer имеет некоторые статические функции, которые требуются.

Я, вероятно, преследую плохой дизайн, поэтому, пожалуйста, укажите мне лучший вариант. Мне нужен завод?

Answer 1

Может быть, что-то вроде это поможет (см ideone.com example):

#include <iostream> 

class A 
{ 
protected: 
    virtual void do_thing_impl() = 0; 
public: 
    virtual ~A(){} 
    static void do_thing(A * _ptr){ _ptr->do_thing_impl(); } 
}; 

class B : public A 
{ 
protected: 
    void do_thing_impl(){ std::cout << "B impl" << std::endl; } 
}; 

class C : public A 
{ 
protected: 
    void do_thing_impl(){ std::cout << "C impl" << std::endl; } 
}; 

int main() 
{ 
B b_; 
C c_; 

A::do_thing(&b_); 
A::do_thing(&c_); 

return (0); 
} 

EDIT: Мне кажется, что ОП не требуется время выполнения полиморфизма, а время компиляции полиморфизма без необходимости экземпляра класса (использование функции static, когда реализация скрыта в производных классах, не требуется никаких экземпляров). Надеюсь, что следующий код помогает решить (example on ideone.com):

#include <iostream> 

template <typename Derived> 
struct A 
{ 
    static void do_thing() { Derived::do_thing(); } 
}; 

struct B : public A<B> 
{ 
    friend A<B>; 
protected: 
    static void do_thing() { std::cout << "B impl" << std::endl; } 
}; 

struct C : public A<C> 
{ 
    friend A<C>; 
protected: 
    static void do_thing() { std::cout << "C impl" << std::endl; } 
}; 

int main() 
{ 
A<B>::do_thing(); 
A<C>::do_thing(); 

return (0); 
} 

EDIT # 2: Для того, чтобы заставить неудачу во время компиляции в случае, если пользователь не соответствует требуемому шаблону, здесь slight modification at ideone.com:

#include <iostream> 

template <typename Derived> 
struct A 
{ 
    static void do_thing() { Derived::do_thing_impl(); } 
}; 

struct B : public A<B> 
{ 
    friend A<B>; 
protected: 
    static void do_thing_impl() { std::cout << "B impl" << std::endl; } 
}; 

struct C : public A<C> 
{ 
    friend A<C>; 
protected: 
    static void do_thing_impl() { std::cout << "C impl" << std::endl; } 
}; 

struct D : public A<D> 
{ 
friend A<D>; 
}; 

int main() 
{ 
A<B>::do_thing(); 
A<C>::do_thing(); 
A<D>::do_thing(); // This will not compile. 

return (0); 
} 

Answer 2

Это выглядит как подходящее место для реализации bridge pattern. Возможно, это то, чем вы (бессознательно) готовы достичь. Короче говоря, вы указываете интерфейс и его реализации, а затем вызываете свой метод do_thing, в свою очередь, вызываете реализацию по указателю на класс реализации.

C++ example