设计资源管理类时应注意的细节

 

 

在设计自己的资源管理类时，应该注意以下几点：


1 看自己设计需要，注意Copying行为


（a）如果在你的设计中，不需要进行资源的复制，那么就禁用它（显示声明Copying行为为私有，或直接私有继承Uncopyable），因为按照传统的Copying行为很容易出现资源的重复释放，从而导致程序异常。

 

 

错误示例，资源重复释放：

 

#include <stdio.h>
#include <mutex>

class Lock
{
	public:
		explicit Lock(std::mutex* pm)
			     :mutexPtr(pm)
			 {
				if(NULL != mutexPtr)
				{
					mutexPtr->lock();
				}
				
			 }
		~Lock()
		{
			if(NULL != mutexPtr)
			{
				printf("!!!!!!!!!!!!!!!!\n");
				mutexPtr->unlock();
			}
			
		}
		

	private:
		std::mutex* mutexPtr;

};

int main()
{
	std::mutex m;
	
	// 建立区块使用锁，离开区块自动释放锁
	{
		Lock ml1(&m);
		Lock ml2(ml1);   // 资源重复解锁
	}

	return 0;

}

 

 

 

 

 

 

正确示例，禁止拷贝，错误控制在编译时期

 

 

#include <stdio.h>
#include <mutex>

class Lock
{
	public:
		explicit Lock(std::mutex* pm)
			     :mutexPtr(pm)
			 {
				if(NULL != mutexPtr)
				{
					mutexPtr->lock();
				}
				
			 }
		~Lock()
		{
			if(NULL != mutexPtr)
			{
				printf("!!!!!!!!!!!!!!!!\n");
				mutexPtr->unlock();
			}
			
		}
       private:
		// 禁止copying操作
		Lock(const Lock&);  
        Lock operator=(const Lock&);  
		

	private:
		std::mutex* mutexPtr;

};

int main()
{
	std::mutex m;
	
	// 建立区块使用锁，离开区块自动释放锁
	{
		Lock ml1(&m);
		Lock ml2(ml1);   // 无法通过编译
	}

	return 0;

}

 

 

 

 

 

 

（b）如果你希望设计中允许Copying行为，那么可以对底层资源使用引用计数法（shared_ptr）。


（c）如果你希望设计中允许Copying行为，那么复制资源管理对象时，可以通过进行“深度拷贝”，例如对指针变量进行拷贝时，指针和指向的资源都拷贝一份。


（d）如果你希望设计中允许Copying行为，那么同样可以通过转移底部资源所有权的方式（unique_ptr, auto_ptr）。




备注:
（1） 赋值RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为。
（2） 普遍而常见的RAII class copying 行为是：抑制copying、施行引用计数法。不过其它行为也可能被实现。


 




2 看自己设计需要，在资源管理类中提供对原始资源的访问


（1）如果你希望对资源管理类中提供对原始资源的访问，可以如下方式：


（a）提供一个显示转换函数，利用类似get函数获取某个私有方式, 返回对象。
 

// 提供显式调用函数,返回原始指针
const std::mutex* getRawMutexPtr()
{
    printf("call  getRawMutexPtr success !!!\n");
    return  mutexPtr;
}

（b）提供一个隐式转换函数， 内部进行转换，类似这种（void implict(long b) ;  int a ;    implict(a) )。

// 提供隐式类型转换函数,
operator const std::mutex*()
{
    printf("call type switch function success !!!\n");
    return  mutexPtr;
}

 

，

其中，显示转换比较安全，隐式转换函数会增加错误发生机会，但隐式对客户比较方便。

 

 

示例：

#include <stdio.h>
#include <mutex>
 
class Lock
{
    public:
        explicit Lock(std::mutex* pm)
                 :mutexPtr(pm)
             {
                if(NULL != mutexPtr)
                {
                    mutexPtr->lock();
                }
                
             }
        ~Lock()
        {
            if(NULL != mutexPtr)
            {
                printf("!!!!!!!!!!!!!!!!\n");
                mutexPtr->unlock();
            }
            
        }
        
        // 提供显式调用函数,返回原始指针
        const std::mutex* getRawMutexPtr()
        {
            printf("call  getRawMutexPtr success !!!\n");
            return  mutexPtr;
        }
        
        // 提供隐式类型转换函数,
        operator const std::mutex*()
        {
            printf("call type switch function success !!!\n");
            return  mutexPtr;
        }
        
       private:
        // 禁止copying操作
        Lock(const Lock&);  
        Lock operator=(const Lock&);
        
 
    private:
        std::mutex* mutexPtr;
 
};
 
int main()
{
    std::mutex m;
    
    // 建立区块使用锁，离开区块自动释放锁
    {
        Lock ml1(&m);
        //Lock ml2(ml1);   // 无法通过编译
        
        // 取得原始指针
        const std::mutex*  myMutexPtr1 = ml1;
        
        // 取得原始指针
        const std::mutex*  myMutexPtr2 = ml1.getRawMutexPtr();
    }
    
  
 
    return 0;
 
}

 

 

 

3 以独立语句将newed对象存储于智能指针内

错误的调用方式:

processWidget(std::tr1::shared_ptr<Widget>(new Widget), priority());

分析:

调用processWidget之前,编译器必须创建代码,做下述三件事:
(1) 调用priority
(2) 执行"new Widget"
(3) 调用std::tr1::shared_ptr

C++编译器以什么样的次序完成这件事情呢？弹性很大。可以确定的是"new Widget"一定执行在"std::tr1::shared_ptr"构造函数被调用之前,
因为这个表达式的结果还要被传递作为它的参数,但对priority的调用则可以排在第一或第二或第三执行。
如果编译器以下述顺序执行

(1) 执行"new Widget"
(2) 调用priority
(3) 调用std::tr1::shared_ptr

万一priority的调用出现异常,会发生什么事?在此情况下"new Widget"返回的指针会丢失,因为它还没有置入"std::tr1::shared_ptr"内。
因此会引发资源泄漏。

避免的方法:
使用分离语句,分别写出
(1) 创建Widget
(2) 将它置入智能指针内,然后再把这个智能指针传给函数

std::tr1::shared_ptr<Widget>pw(new Widget);

processWidget(pw, priority());

结论:

以独立语句将newed对象存储于智能指针内。如果不这样做,一旦异常被抛出,有可能导致难以察觉的资源泄漏。