Аннотация класс без абстрактных методов

Question

Можно ли сделать абстрактное представление класса в C++ без объявления абстрактных методов? В настоящее время у меня есть класс Sprite с подклассом StaticSprite и DynamicSprite. Я хотел бы сделать класс класса Sprite абстрактным.

Проблема в том, что нет никаких методов, которыми они делят. Ну, как StaticSprite, так и DynamicSprite могут совместно использовать метод draw(), но параметры этого метода различны, поэтому это не вариант.

Спасибо!

EDIT: Вот код, чтобы показать, что я пытаюсь сделать:

Sprite:

class Sprite 
{ 
    public: 
     Sprite(HINSTANCE hAppInst, int imageID, int maskID); 
     ~Sprite(); 

    protected: 
     HINSTANCE hAppInst; 
     HBITMAP hImage; 
     HBITMAP hMask; 
     BITMAP imageBM; 
     BITMAP maskBM; 
     HDC hSpriteDC; 
}; 

Staticsprite:

class StaticSprite : public Sprite 
{ 
    public: 
     StaticSprite(HINSTANCE hAppInst, int imageID, int maskID); 
     ~StaticSprite(); 

     void draw(Position* pos, HDC hBackbufferDC); 
}; 

Dynamicsprite:

class DynamicSprite : public Sprite 
{ 
    public: 
     DynamicSprite(HINSTANCE hAppInst, int imageID, int maskID); 
     ~DynamicSprite(); 

     void draw(HDC hBackbufferDC); 
}; 

Как вы видите, бесполезно создавать объект Sprite, поэтому я хотел бы сделать этот абстрактный класс. Но я не могу сделать draw() abstract, поскольку он использует разные параметры.

Answer 1

Вы можете объявить ваш деструктор, как чисто виртуальные, так как все классы Имеется.

class AbstractClass 
{ 
public: 
    virtual ~AbstractClass() = 0 ; 
} ; 

Однако вам необходимо определить этот деструктор в другом месте.

AbstractClass::~AbstractClass() {} 

Answer 2

Нет, нет.

Вы можете использовать это, конечно:

class Sprite 
{ 
}; 

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

Вы можете добавить чистый виртуальный деструктор:

class Sprite 
{ 
public: 
    virtual ~Sprite() = 0; 
}; 

или вы можете сделать защищенный конструктор, останавливая экземпляра:

class Sprite 
{ 
protected: 
    Sprite(); 
}; 

Answer 3

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

например.

virtual void blah() const = 0; 

В противном случае вы можете использовать любой класс как абстрактный класс

Answer 4

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

// .h 
struct Foo { 
    virtual ~Foo() = 0; 
}; 

// .cpp 
Foo::~Foo() { 
} 

Answer 5

Если класс не делает ничего, и ничего не дает, и существует только в качестве маркеров, нет никаких оснований беспокоиться о том или нет, это его абстрактного. Это по существу не проблема.

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

Пожалуйста, избегайте создания виртуального деструктора. Таким образом безумие.

Answer 6

Проблема в том, что не существует методов, которыми они делятся.

У вас там проблемы. Вы не должны использовать наследование здесь! Если вы не собираетесь заменять один класс другим, они просто не должны быть в отношениях между родителем и ребенком.

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

EDIT: На основе образца кода вы наследуетесь для повторного использования, и я бы предложил использовать композицию вместо этого. Sprite может быть struct, который принадлежит как DynamicSprite, так и StaticSprite. Вы можете поместить как можно больше/немного вспомогательной логики в Sprite.

Answer 7

Для конкретных обстоятельств вашего сообщения рассмотрите личное наследование. Таким образом, вы можете лениво использовать реализацию базы, не рекламируя ложное отношение IS-A к миру.

Answer 8

Если вы действительно должны использовать наследование, рассмотреть возможность использования без виртуального интерфейса (NVI) идиом (см http://www.parashift.com/c++-faq-lite/strange-inheritance.html#faq-23.3)

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

То, что вы определенно не хотите делать, это перегрузка виртуальной функции (что похоже на то, что вы действительно хотите сделать).

Answer 9

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

class SomeBaseClass 
{ 
protected: 
    SomeBaseClass() {} 
    SomeBaseClass(const SomeBaseClass &) {} 
    SomeBaseClass &operator=(const SomeBaseClass&) {} 
public: 
    virtual ~SomeBaseClass() {} 
    ... 
}; 

Или, новый стиль:

class SomeBaseClass 
{ 
protected: 
    SomeBaseClass() = default; 
    SomeBaseClass(const SomeBaseClass &) = delete; 
    SomeBaseClass &operator=(const SomeBaseClass&) = delete; 
public: 
    virtual ~SomeBaseClass() = default; 
    ... 
}; 

деструктор, как правило, лучше публиковать, потому что вы можете захотеть удалить объект указателем базового класса.