Остановка наследования от базового класса после n-го наследования в C ++

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

Проблема в том, что C ++ не предоставляет никаких средств для прямого ограничения наследования таким образом.

Указатель на идиому реализации может помочь вам в любом случае:

class PublicToUser final
{
    class PrivateToUser;
    std::unique_ptr<PrivateToUser> implementation;
public:
    // ***
};

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

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

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

class BaseClass { };

class DoNotInheritClass final : public BaseClass { };

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

Вот несколько идей, которые могут помочь, если вы не можете использовать решение PIMPL из другого ответа. Они основаны либо на CRTP, либо на тегах конструктора:

#include <type_traits>

struct A;

template<typename T>
struct Base final {

};

// Specialise Base for A to be non-final
template<>
struct Base<A> {};

struct A : Base<A> {};

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

template<char...>
struct password {};

struct Base2 {

    Base2() = delete;

    template<char... pwd>
    Base2(password<pwd...> ) {
        using expected_pwd = password<'t','o','p','s','e','c','r','e','t'>;
        static_assert(std::is_same_v<password<pwd...>, expected_pwd>);
    }
};

struct A2 : Base2 {

    A2() : Base2(password<'t','o','p','s','e','c','r','e','t'>{}) {}
};

struct A3 : Base2 {

    // No way to construct Base2 without correct password :)
    A3() : Base2(password<'b', 'a', 'm', 'm'>{}) {}
};

Идея этого второго фрагмента (который является скорее шуткой, чем реальным кодом ...) состоит в том, чтобы заменить конструктор по умолчанию класса Base2 структурой password. Внутри реализации вы проверяете пароль, присвоенный конструктору. В реализации производного класса вы просто вызываете конструктор Base2 с правильным паролем. Конечно, ваши пользователи могут быть производными от базового класса, но поскольку пароль полностью скрыт в реализации, нет возможности создать производные объекты :)

int main(){

    auto a = A{};
    auto a2 = A2{};
    auto a3 = A3{};  // fails
    return 0;
}