Как определить запечатанный класс В C++?


Как остановить класс, который будет унаследован другим классом.

6   51   2011-01-17 15:12:00

6 ответов:

в C++11 решение

в C++11, вы можете запечатать класс с помощью final ключевое слово в определение:

class A final  //note final keyword is used after the class name
{
   //...
};

class B : public A  //error - because class A is marked final (sealed).
{                   //        so A cannot be derived from.
   //...
};

чтобы узнать другие виды использования final, см. Мой ответ здесь:


в C++03 решение

код Бьярне Страуструпа:могу ли я остановить людей, получающих от моего класс?

class Usable;
class Usable_lock {
    friend class Usable;
private:
    Usable_lock() {}
    Usable_lock(const Usable_lock&) {}
};

class Usable : public virtual Usable_lock {
public:
    Usable();
    Usable(char*);
};
Usable a;

class DD : public Usable { };

DD dd;  // error: DD::DD() cannot access
        // Usable_lock::Usable_lock(): private  member

Generic_lock

Итак, мы можем использовать шаблон, чтобы сделать Usable_lock достаточно общий, чтобы запечатать любой класс:

template<class T>
class  Generic_lock 
{
    friend T;
    Generic_lock() {}                     //private
    Generic_lock(const Generic_lock&) {}  //private
};

class Usable : public virtual Generic_lock<Usable>
{
public:
    Usable() {}
};

Usable a; //Okay
class DD : public Usable { };

DD dd; //Not okay!

есть два способа, простой, дешевый, и правильным. Два ответа @Naveen и @Nawaz имеют дело с правильным, что требует ручного создания уплотнитель класс для каждого класса, который вы действительно хотите запечатать.

не дурак-доказательство способ, который используется в библиотеках adobe использует шаблонный класс для этого. Проблема в том, что вы не можете объявить аргумент шаблона как друг, и это означает, что вам придется переключиться с private to тем менее безопасно protected:

template <typename T>
class sealer {
protected: sealer() {}
};
class sealed : virtual sealer<sealed> {};

и вы можете автоматизировать его с помощью макроса (я не помню точный вкус макроса в коде Adobe):

#define seal( x ) virtual sealer<x>
class sealed : seal(sealed) 
{};

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

class derived : sealed {};
int main() {
   derived d;  // sealer<T>::sealer() is protected within this context
}

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

class derived : sealed, sealer<sealed> {};
int main() {
   derived d;
};

Я не уверен, изменится ли это в C++0x, я думаю, что вспоминаю некоторые дискуссии о том, будет ли шаблон класса дружить с одним из его аргументов, но в беглом поиске по проекту я не могу сказать. Если бы это было разрешено, то это было бы прекрасным общим решением:

template <typename T>
class sealer {
   sealer() {}
   friend class T; // Incorrect in C++03
};

C++11 добавляет возможность предотвращения наследования от классов или просто предотвращения переопределения методов в производных классах. Это делается с помощью специального идентификатора final. Например:

class Base final { };

class Derived1 : Base { }; // ill-formed because the class Base has been marked final

или

class Base {
    virtual void f() final;
};

class Derived : Base {
    void f(); // ill-formed because the virtual function Base::f has been marked final

обратите внимание, что final не является ключевым словом языка. Это технически идентификатор; он приобретает особое значение только при использовании в этих конкретных контекстах. В любом другом месте, это может быть допустимым идентификатором.

на основе Бьярне Страуструпа http://www.stroustrup.com/bs_faq2.html#no-derivation FAQ с небольшой модификацией без использования ключевого слова друга:

// SEALED CLASS DEFINITIONS
class Usable_lock {
protected:
    Usable_lock() {}
    Usable_lock(const Usable_lock&) {}
};
#define sealed_class private virtual Usable_lock

// SEALED CLASS USAGE EXMAPLES
class UsableLast : sealed_class {
public:
    UsableLast(){}
    UsableLast(char*){}
};
class DD : public UsableLast {};

// TEST CODE
template <class T> T createInstance() {
    return T();
}
int main()
{
    createInstance<UsableLast>();
//  createInstance<DD>();
    return 0;
}

в следующем коде показано, как определить запечатанный класс В C++/CLI.

class A sealed
{
    //here goes the class code
};

class B : public A
{
};

теперь B: не может наследовать от A, поскольку он был объявлен как "запечатанный". Также подробное объяснение о sealed keyword можно найти здесь http://msdn.microsoft.com/en-us/library/0w2w91tf.aspx

обновление: добавлен C++ / CLI, также другие ответы показали последний способ достижения того же C++11 с помощью final ключевое слово.

вы не можете. C++ не Java или C#. А также нет никакого смысла, никогда, ИМХО.