设计一个类不能被继承、设计一个类只能在堆上创建实例，设计一个类只能在栈上创建实例

方式一：把构造函数声明为私有函数（该方法创建的类只能在堆上创建实例）

在C#中有关键字sealed，在Java中有关键字final它们修饰的类不能被继承 

在C++中我们知道，子类的构造函数会自动调用父类的构造函数，子类的析构函数也会自动调用父类的析构函数，所以我们可以把父类的构造函数和析构函数定义为私有函数 

同时我们可以定义两个公有的静态函数来创建对象和释放对象，以达到创建实例的目的



class A
{
public:
      static A* GetA()
      {
            return new A();
      }
      static void DeleteA(A* a)
      {
            delete a;
      }
private:
      A(){}
      ~A(){}
};




方式二：利用虚拟继承

B类使用起来和其它的类型没有什么区别，可以在堆上也可以在栈上创建实例。因为B类是A< B >类的友元类型，所以可以调用它的私有函数 

但如果想从B类继承一个类的话，由于B 类是由A< B >类虚拟继承来的，所以就会跳过B类直接调用A< B >类的构造函数，而别的类并不是A< B >的友元类型所以不能调用

template <class T>
class A
{
      friend T;
private:
      A(){}
      ~A(){}
};
class B :virtual public A<B>
{
public:
      B(){}
      ~B(){}
};




只能在栈上创建实例：

只有使用new运算符，才会在堆上创建实例，只要禁用new运算符就可以保证只在栈上创建实例

class B
{
public:
      B(){}
      ~B(){}
private:
      void *operator new(size_t t){}
      void operator delete(void *ptr){}
};

所有类的祖宗是object，所有类只能有一个父亲。Java的单继承指的是一个类不能有多个父亲，而C++就能有好多父亲。
举个例子：
如果A 没有继承任何类，那他的类层次关系默认是 A -- Object
如果A 继承了类B，那他的类层次关系变为 A -- B -- Object,Object是他爷爷，B是他唯一的父亲,B直接继承Objcet，A间接继承Object
转载于:https://www.cnblogs.com/CrisZjie180228/p/8728176.html

    

继承的基本概念： 
（1）Java不支持多继承，也就是说子类至多只能有一个父类。 
（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。
（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承。
（4）子类中定义的成员方法，并且这个方法的名字返回类型，以及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。
分析以上程序示例，主要疑惑点是“子类继承父类的成员变量，父类对象是否会实例化？私有成员变量是否会被继承？被继承的成员变量在哪里分配空间？”
1：虚拟机加载ExtendsDemo类，提取类型信息到方法区。
2：通过保存在方法区的字节码，虚拟机开始执行main方法，main方法入栈。
3：执行main方法的第一条指令，new Student(); 这句话就是给Student实例对象分配堆空间。因为Student继承Person父类，所以，虚拟机首先加载Person类到方法区，并在堆中为父类成员变量在子类空间中初始化。然后加载Student类到方法区，为Student类的成员变量分配空间并初始化默认值。将Student类的实例对象地址赋值给引用变量s。
4：接下来两条语句为成员变量赋值，由于name跟age是从父类继承而来，会被保存在子类父对象中(见图中堆中在子类实例对象中为父类成员变量分配了空间并保存了父类的引用，并没有实例化父类。)，所以就根据引用变量s持有的引用找到堆中的对象(子类对象)，然后给name跟age赋值。 4：调用say()方法，通过引用变量s持有的引用找到堆中的实例对象，通过实例对象持有的本类在方法区的引用，找到本类的类型信息，定位到say()方法。say()方法入栈。开始执行say()方法中的字节码。
5：say()方法执行完毕，say方法出栈，程序回到main方法，main方法执行完毕出栈，主线程消亡，虚拟机实例消亡，程序结束。 
总结：相同的方法会被重写，变量没有重写之说，如果子类声明了跟父类一样的变量，那意味着子类将有两个相同名称的变量。一个存放在子类实例对象中，一个存放在父类子对象中。父类的private变量，也会被继承并且初始化在子类父对象中，只不过对外不可见。 
super关键字在java中的作用是使被屏蔽的成员变量或者成员方法变为可见，或者说用来引用被屏蔽的成员变量或成员方法，super只是记录在对象内部的父类特征(属性和方法)的一个引用。啥叫被屏蔽的成员变量或成员方法？就是被子类重写了的方法和定义了跟父类相同的成员变量，由于不能被继承，所以就称作被屏蔽。 说到这里，上面提出的疑惑也就解开了。 

转载于:https://www.cnblogs.com/zhanghengscnc/p/7450904.html

// only3Instance.cpp : 定义控制台应用程序的入口点。

//通过此实例实现一个类，这个类不能被继承，并且最多可以实例化3次
//在设计模式中，有一种模式叫“单例模式”，这个模式向我们展现了一个类，这个类只产生一个实例

//这个类里面，屏蔽掉了拷贝构造函数，构造函数，析构函数，这样这个类就不会被继承，因为我们

//知道，当一个类被继承时，子类必须先调用父类的构造函数，在析构时，父类最后被析构，将创建对象的部分定义为一个静态对象，所以只会产生一个实例

//下面我们仿照这一思路，改变对象“静”的特性，就可以随心所欲的创建对象，同时我们在堆上定义一个变量（static），用来检验

//对象创建的个数
#include "stdafx.h"

#include <process.h>

#include <iostream>

using namespace std;
 
 

class CFinalClass

{

public:

 static CFinalClass* GetInstance()

 {

  if (m_index>=m_count)

  {

   return NULL;

  }

  m_index++;

  return new CFinalClass();

 }

 static void SetCount(int n)

 {

  m_count=n;

 }

private:


 static int m_index;

 static int m_count;


private://将构造函数和析构函数定义为私有的，这样就不会被继承
 CFinalClass()

 {
 }

 ~CFinalClass()

 {
 }

};
 
 

int CFinalClass::m_index=0;

int CFinalClass::m_count=0;
 
 
 
int _tmain(int argc, _TCHAR* argv[])

{
 

 CFinalClass::SetCount(3);

 CFinalClass *p1=CFinalClass::GetInstance();

 CFinalClass *p2=CFinalClass::GetInstance();

 CFinalClass *p3=CFinalClass::GetInstance();

 CFinalClass *p4=CFinalClass::GetInstance();

 CFinalClass *p5=CFinalClass::GetInstance();
 if (p1==NULL)

 {

  cout<<"p1 is null"<<endl;

 }

 else

 {

  cout<<"p1 is not null"<<endl;

 }
 if (p2==NULL)

 {

  cout<<"p2 is null"<<endl;

 }

 else

 {

  cout<<"p2 is not null"<<endl;

 }
 if (p3==NULL)

 {

  cout<<"p3 is null"<<endl;

 }

 else

 {

  cout<<"p3 is not null"<<endl;

 }

 cout<<"-----------------------------------------"<<endl<<endl;

 if (p4==NULL)

 {

  cout<<"p4 is null"<<endl;

 }

 if (p5==NULL)

 {

  cout<<"p5 is null"<<endl;

 }

 system("pause");

 return 0;

}