关于C++停止类被继承的方法

这个问题已经被老生常谈了，一共有2中方案，但是今天写内部类时，想到另一种方案，通过内部类实现停止类继承；

首先来回顾前两种方案：

1、C++11语法，final关键字

class A1{
    public:
     A1(){};
        ~A1(){};
};

class B1 final:public A1{//禁止B1被继承

};

class C1:public B1{//错误，

};

编译情况：

2、构造函数私有化

2.1直接将构造函数私有化,这种方案有一个问题，只是达到禁止继承的目的，但是该类也无法创造出自己的对象；

class A1{
    //public:
    private:
        int a;
        A1(int b):a(b){};
    public:
    ~A1(){};
};

class B1 :public A1{

};



int main(){
    A1 a1=new A1(6);
    //B1 *b1=new  B1();
    return 0;
}

编译器提示类A1也无法创建出对象；

 2.2利用友元，定义一个基类，将基类构造函数私有化

class B1;

class A1{
    //public:
    private:
    int b;
        A1(int a):b(a){};
        ~A1(){};
        friend class B1;
    public:
    int get(){return b;};
};

class B1 :public  A1{
    public:
        B1(int a):A1(a){};
};

class C1:public B1{
    public:
    C1(int a):B1(a){};
};

int main(){
    C1 b1(10);
    cout<<b1.get()<<endl;
    //C1 c1;
}

上述代码，并不能防止B1被继承，因为C1会调用B1的构造函数,而B1调用A1，然而B1是A1的友元类，所以代码可以通过，输出结果为10;

解决上述情况只需要成为虚基类即可，因为多个类继承自同一个基类时，共享同一个基类，为了防止基类被多次初始化，基类的初始化任务必须由继承体系中最底层的类完成；

修改完代码：

class B1;

class A1{
    //public:
    private:
    int b;
        A1(int a):b(a){};
        ~A1(){};
        friend class B1;
    public:
    int get(){return b;};
};

class B1 :public virtual A1{
    public:
        B1(int a):A1(a){};
};

class C1:public B1{
    public:
    C1(int a):B1(a){};
};

int main(){
    C1 b1(10);
    cout<<b1.get()<<endl;
    //C1 c1;
}

编译时报错:

3、内部类方案

class C
{
private:
    /* data */
    int a;
public:
    C(/* args */){};
    C(/* args */int c):a(c){};
    int get(){return a;}
    ~C(){};
};
class A{
    public:
        class B:public C//内部类，当为public时可以被继承,
        {
        private:
            /* data */
        public:
            B(/* args */):C(0){};
            explicit B(int b):C(b)  {} ;
            ~B(){};
        };
     private: 
};


class D:public A::B{
    public:
    D(int c):A::B(c){};
    ~D(){};
};


int main(){
   D d(10);
   cout<<d.get()<<endl;
}

运行结果为：

 将内部类访问属性私有化：

class A{
    public:
    private: 
        class B:public C//内部类，当为public时可以被继承,
        {
        private:
            /* data */
        public:
            B(/* args */):C(0){};
            explicit B(int b):C(b)  {} ;
            ~B(){};
        };
     
};

编译结果为:

只不过这一种方案，需要在内部类的外部类定义接口访问内部类，属实繁杂，不过这也是一种实现方案，示例代码为；

class C
{
private:
    /* data */
    int a;
public:
    C(/* args */){};
    C(/* args */int c):a(c){};
    int get(){return a;}
    ~C(){};
};
class A{
    private: 
        class B:public C//内部类，当为public时可以被继承,
        {
        private:
            /* data */
        public:
            B(/* args */):C(0){};
            explicit B(int b):C(b)  {} ;
            ~B(){};
        };
     B b;
     public:
     A(int a):b(a){};
    int get(){return b.get();};
};
int main(){
   A a(10);
   cout<<a.get()<<endl;
}

最后感谢博主：https://blog.csdn.net/renwotao2009/article/details/6596710