实现一个不能被继承的类

在掌握了基本的继承关系时，为了加深理解和延伸知识，可以实现以下几个特殊的类：

1.实现一个不能被继承的类：

实现原理： 将类的构造函数声明成私有的。

class AA {                     //实现一个不能被继承的类----将基类的构造函数和析构函数声明成私有的，当派生类要构造基类时，就会因为
                               //无法调用基类的构造函数而出错				
public:
	static AA* GetObj()
	{
		return new AA;
	}
	static AA* DelObj(AA *pa)
	{
		delete pa;
		pa = NULL;
	}

private:
	AA(){}
	~AA(){}
};

int main()
{
	AA *pc = AA::GetObj();
	AA *pd = AA::DelObj(pc);
	return 0;
}

2.实现一个只能在栈上创建对象的类

class AA {                    //实现一个只能在栈上创建对象的类---1.将构造函数定义成私有的，只提供在栈上创建对象的方法
                              //                                  2.将 operator new 重载为私有
public:

	static AA  GetObj()
	{
		return AA();
	}

private:
	AA(int a = 0)
		:_a(a)
	{}

	//2.产生堆对象的唯一方法是使用new, 禁止使用new就可禁止产生堆对象.由于new执行时会调用operator new, 
	//而operator new是可重载的, 所以将operator new和operator delete重载为private即可，
	//但是该方法有缺陷--也能在静态区创建对象
	//static void* operator new(size_t size);
	//static void operator delete(void *p);

	int _a;
};

AA bb = AA::GetObj();
int main()
{
	AA aa = AA::GetObj();
	bb = aa;
	//AA *p = new AA;//编译报错---operator new + 构造函数
	return 0;
}

3.实现一个只能在堆上创建对象的类

为了防止先调用类提供的公有方法创建堆上的对象后，再利用拷贝构造函数和赋值运算符的重载而创建栈上的对象，这里提出类的防拷贝的操作，即将类的拷贝构造和赋值运算符的重载皆声明为私有。

class AA {			//实现一个只能在堆上创建对象的类---1.将构造函数声明称私有
public:

	static AA&  GetObj()              //返回引用
	{
		return *(new AA);
	}
	static AA* GetObj2(int n = 1)     //返回指针
	{
		return new AA(n);    
	}
	static AA* GetObj3(int n = 1)      //返回指针
	{
		return new AA[n];    
	}

private:
类的防拷贝：   1.声明成私有                2.只进行声明不定义
	AA(const AA& a);
	AA& operator=(const AA& a);

	AA(int a = 0)
		:_a(a)
	{}

	int _a;
};

int main()
{
	AA *p = AA::GetObj2(10);		//在堆上创建一个对象初始化_a为10
	AA *p2 = AA::GetObj3(10);		//在对上创建10个对象，_a都被默认的初始化为10

	return 0;
}

为了防止先调用类提供的公有方法创建堆上的对象后，在