限制一个类的对象实例,只能在"堆"上分配,或者只能在"栈"上分配

红太狼 2024-04-17 17:35 86阅读 0赞

### 类的设计 ###

*   *   *  1、只能在栈上创建
         *  2、只能在堆上创建
         *  3、如何防止一个类被拷贝
         *  4、如何防止一个类被继承
         *  5、如何让一个类只创建一个对象

在 C++ 中创建一个类对象分为静态和动态，一种是静态建立，如 A a, 一种是动态建立 A \* a = new A;

他们的区别如下：

**静态建立类对象**：是由编译器在栈空间为对象分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象，使用这种方法，直接调用类的构造函数

**动态建立类对象**：是使用 new 运算符将对象建立在堆空间中。这个过程分为两步，第一步先是执行 operator new() 函数，在堆空间中搜索合适的内存并进行分配；第二步才调用构造函数构造对象，初始化这片内存空间。这种方法，间接调用类的构造函数

### 1、只能在栈上创建 ###

如果让对象只能在栈上创建，就不能调用 operate new 函数，所以把他们设置为私有的访问权限就行了(全局函数 operator new 和 operator delete)

//设计一个类只能在栈上创建对象，
    class B{ 
    public:
        B(){ }
        ~B(){ }
    private:
        void * operator new(size_t size){ }
        void operator delete(void *ptr){ }
    };

### 2、只能在堆上创建 ###

只能在堆上创建，就是不可以在栈中建立对象，容易想到的是可以把构造函数私有化，因为这样类外就访问不到了，但是存在一个问题就是，对于 new 操作符，也需要构造函数进行初始化，这样一来 new 也无法提供构造函数的功能

如果对象在栈中分配，编译器在分配空间的时候，需要检查析构函数的访问权限，如果把析构函数设置为私有的，则编译器在栈中建立对象的时候会报错，因为对象无法访问析构函数，导致不可以在栈中创建，虽然可以解决问题，但是有缺陷…

class A  {   
    public:  
        A(){ 
    		//code
    	}  
        void destory(){ 
        	delete this;
        }  
    private:  
        ~A(){ }  
    };  
    
    int main() { 
    	A* a = new A;
    	a->destory();
    
    	return 0;
    }

缺陷：如果把该类作为基类，需要继承的的时候，析构函数要设置为 virtual ，然后在子类重写，如果把析构函数为私有的，在子类不可见，无法实现多态

C++ 类中一共有三种权限，可以把析构函数设置为 protected ，该权限的成员函数在类外依然不可以访问，但是可以在子类访问到，这样就解决了继承的问题.

class A  {   
    protected:  
        A(){ }  
        ~A(){ }  
    public:
    	// 这样写是为了代码的规范
    	// 如果使用 new 来进行申请空间，却使用 destroy 函数释放感觉怪怪的
    	// 所以使用函数进行申请空间，使用函数释放空间 
        static A* create()  {   
            return new A();  
        }  
        void destory()  {   
            delete this;  
        }  
    };

调用create()函数在堆上创建类A对象，调用destory()函数释放内存

### 3、如何防止一个类被拷贝 ###

将拷贝构造函数和赋值函数的权限设置为私有 private ,这样外界就无法访问了

### 4、如何防止一个类被继承 ###

方法1：将构造函数设置为私有，因为继承肯定会调用基类的构造函数，所以把它设置为私有就无法访问了

方法2：利用关键字 final ，在类名的后面加上这个关键字，可以防止该类被继承

### 5、如何让一个类只创建一个对象 ###

**饿汉模式**：在类还没有实例化对象前，在类中就有一个对象，而且不能创建其他的对象。执行效率高,获取对象快，但是在类加载的时候就初始化对象，会浪费内存空间，用空间换取时间的方式…

//饿汉单例模式
    template<class T>
    class SingLeton { 
    public:
    	// 调用对象 data
    	static T* getsingleton() { 
    		return &data;
    	}
    private:
    	//在类还没有实例化对象前就有一个对象了
    	static T data;
    };

**懒汉模式**：用时间换取空间，需要的时候再创建对象，如果已经创建好了就不会再分配内存空间。它在类加载的时候不会被初始化，

template<class T>
    class Singleton { 
    public:
    	static T* GetSingleton() { 
    		if (data == nullptr) { 
    			data = new T();
    		}
    		return data;
    	}
    private:
    	static T* data;
    };

但是这段代码还存在很大的问题？  
线程是否安全？锁竞争？对象会不会被加载到寄存器？

volatile 保持内存的可见性：所有线程都能看到共享内存的最新状态，如果一个线程创建了 data 对象，但是被优化到寄存器，别的线程不知道，可能会继续创建对象。每次读取前必须先从主内存刷新最新的值，每次写入后必须立即同步回主内存当中

竞态条件：从多进程间通信的角度来讲，是指两个或多个线程对共享的数据进行读或写的操作时，最终的结果取决于这些进程的执行顺序。