c++不能继承的类

首先我们要明白的一点是，继承只是派生类继承了基类的全部成员函数和变量

但是并没有继承基类的构造函数和析构函数可以样理解，就是儿子不能继承父亲

的生死，虽然没有继承但是编译器会为你隐式的调用。

看下面的代码

#include<iostream>
#include<vector>
using namespace std;
/*
c++继承后，派生类的构造函数隐式的调用基类的构造函数，析构函数也一样，那么我们把构造和析构函数都
声明成private那么，这个类就不能被继承，那么我们如何获得这个对象的实例呢。我们
可以在类中定义一个静态变量Tom
*/
class Tom
{
public:
	Tom()
	{
		cout << "我是基类的构造函数" << endl;
	}
	~Tom()
	{
		cout << "我是基类的析构函数" << endl;
	}
};
class Jack :public Tom
{
public:
	Jack()
	{
		cout << "我是派生类的构造函数" << endl;
	}
	~Jack()
	{
		cout << "我是派生类的析构函数" << endl;
	}
};
void main()
{
	Jack();
	system("pause");

}

那么有了这个答案，我们把基类的构造函数改成Private看看结果

那么编译器会报错（vs2013）：

错误    2    error C2248: “Tom::~Tom”: 无法访问 private 成员(在“Tom”类中声明)   

那么我们就可以知道，当构造函数与析构函数是private的时候，就无法继承了

但是这里存在个问题，构造函数无法访问，那么实例也就不能出现了，这样的

话我们应该提前准备实例放在类中，看下面的代码

静态函数实现

#include<iostream>
#include<vector>
#include<string>
using namespace std;
/*
c++继承后，派生类的构造函数隐式的调用基类的构造函数，析构函数也一样，那么我们把构造和析构函数都
声明成private那么，这个类就不能被继承，那么我们如何获得这个对象的实例呢。我们
可以在类中定义一个静态变量Tom
*/
class Tom 
{
public:
	static Tom* getTom();//注意static，否则不能访问
	static Tom* getTom(string name);
	void get_name()
	{
		cout << name << endl;
	}
        void get_delete()//自己的析构
	{
		delete this;
	}
private:
	string name;
	int age;
	Tom()
	{
		name = "hello";
		cout << "我是基类的构造函数" << endl;
	}
	Tom(string name)
	{
		this->name = name;
	}
	~Tom()
	{
		cout << "我是基类的析构函数" << endl;
	}
};
 Tom* Tom::getTom()
{
	Tom *tom1 = new Tom();
	return tom1;
}
Tom* Tom::getTom(string name)
{
	Tom *tom1 = new Tom(name);
	return tom1;
}

void main()
{
	Tom *obj1 = Tom::get_Tom();
	Tom*obj2 = Tom::get_Tom("11");
	obj1->get_name();
	obj2->get_name();
        obj1->get_delete();
	obj2->get_delete();
	system("pause");
}

这个方法虽然可以实现不能继承的类，但是比较麻烦，不能直接定义实例在栈上。

那么我们可以使用友元类和虚继承的方式完成这个问题

看下面的代码

#include<iostream>
#include<vector>
using namespace std;
/*多继承以及虚继承的关系
虚继承只会保留基类中的一份成员变量
注意A类是辅助类
*/
class A
{
private:
	A()
	{

	}
	~A()
	{

	}
};

class B :virtual public A
{
	friend A;
};
class C :public B
{
public :
	void Hello()
	{
		cout << "hello" << endl;
	}
};

void main()
{
	C a;
	a.Hello();//报错，因为无法访问A的构造函数


	system("pause");

}

那么我们理一下关系：

A类构造函数private，但是A是B的友元类，那么B可以访问，由于是虚继承

那么对于C而言访问不了A中的构造函数，那么就实现了B的不可被继承。

总结

• 实现不可继承的类，c++11存在final关键字
• 可以利用静态函数返回指针
• 可以使用友元类和虚继承来完成

补充：

利用静态函数返回类的对象，不是指针的话虽然可以成功，但是析构的时候使用不了

析构函数。