Effective C++改善程序与设计的55个具体做法

---

前言

所谓资源就是，一旦用了它，将来必选还给系统。C++程序中最常使用的资源就是动态分配内存，但内存只是众多必须管理资源之一。其他常见的资源还包括文件描述器(file descriptors)、互斥锁(mutex locks)、图形界面中的字型和笔刷、数据库连接、以及网络sockets。不论哪种资源，重要的是，当你不再使用它时，必须将它还给系统。

---

条款13：以对象管理资源

class Investment{...};  //投资类型，继承体系中的root class
//返回指针，指向Investment继承体系内的动态分配对象。
//调用者有责任删除它。为简化不写参数
Investment*createInvestment();

void f() {
	Investment*pInv = createInvestment();   //调用factory函数
	...
	delete pInv;
}

无法确保f总是会执行其delete语句，
为确保createInvestment返回的资源总是被释放，我们需要将资源放进对象内，
当控制流离开f，该对象的析构函数会自动释放哪些资源。实际上这正是隐身于
本条款背后的半边想法：把资源放进对象内，我们便可依赖C++"析构函数的自
动调用机制"确保资源释放。

---

许多资源被动态分配于heap内而后被用于单一区块函数内，它们应该在控制流
离开那个区块或函数时被释放。标准程序库提供的auto_ptr正是针对这种形式
而设计的特制产品。auto_ptr是个“类指针(pointer-like)对象”，也就是所谓的
智能指针，其析构函数自动对其所指的对象调用delete。

auto_ptr是个“类指针(pointer-like)对象”，也就是所谓 “智能指针”，其析构函数自动对所指的对象调用delete。

void f() {
	std::auto_ptr<Investment> pInv(createInvestment());
	//调用factory函数，一如既往地使用pInv
	//经由auto_ptr的析构函数自动删除pInv
}

• 获得资源后立刻放进管理对象(managing object)内。
• 管理 对象运用析构函数确保资源被释放。

auto_ptr有一个不同寻常的性质：若通过copy构造函数或copy assignment操作符复制它们，它们会变成null，而复制所得的指针将取得资源的唯一拥有权！

template<class _Ty>
	class auto_ptr
	{	// wrap an object pointer to ensure destruction
public:
	typedef _Ty element_type;

	explicit auto_ptr(_Ty * _Ptr = nullptr) noexcept
		: _Myptr(_Ptr)
		{	// construct from object pointer
		}

	auto_ptr(auto_ptr& _Right) noexcept
		: _Myptr(_Right.release())
		{	// construct by assuming pointer from _Right auto_ptr
		}

	auto_ptr(auto_ptr_ref<_Ty> _Right) noexcept
		{	// construct by assuming pointer from _Right auto_ptr_ref
		_Ty * _Ptr = _Right._Ref;
		_Right._Ref = nullptr;	// release old
		_Myptr = _Ptr;	// reset this
		}

	template<class _Other>
		operator auto_ptr<_Other>() noexcept
		{	// convert to compatible auto_ptr
		return (auto_ptr<_Other>(*this));
		}

	template<class _Other>
		operator auto_ptr_ref<_Other>() noexcept
		{	// convert to compatible auto_ptr_ref
		_Other * _Cvtptr = _Myptr;	// test implicit conversion
		auto_ptr_ref<_Other> _Ans(_Cvtptr);
		_Myptr = nullptr;	// pass ownership to auto_ptr_ref
		return (_Ans);
		}

	template<class _Other>
		auto_ptr& operator=(auto_ptr<_Other>& _Right) noexcept
		{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
		}

	template<class _Other>
		auto_ptr(auto_ptr<_Other>& _Right) noexcept
		: _Myptr(_Right.release())
		{	// construct by assuming pointer from _Right
		}

	auto_ptr& operator=(auto_ptr& _Right) noexcept
		{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
		}

	auto_ptr& operator=(auto_ptr_ref<_Ty> _Right) noexcept
		{	// assign compatible _Right._Ref (assume pointer)
		_Ty * _Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
		}

	~auto_ptr() noexcept
		{	// destroy the object
		delete _Myptr;
		}

	_NODISCARD _Ty& operator*() const noexcept
		{	// return designated value
 #if _ITERATOR_DEBUG_LEVEL == 2
		_STL_VERIFY(_Myptr, "auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

		return (*get());
		}

	_NODISCARD _Ty * operator->() const noexcept
		{	// return pointer to class object
 #if _ITERATOR_DEBUG_LEVEL == 2
		_STL_VERIFY(_Myptr, "auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

		return (get());
		}

	_NODISCARD _Ty * get() const noexcept
		{	// return wrapped pointer
		return (_Myptr);
		}

	_Ty * release() noexcept
		{	// return wrapped pointer and give up ownership
		_Ty * _Tmp = _Myptr;
		_Myptr = nullptr;
		return (_Tmp);
		}

	void reset(_Ty * _Ptr = nullptr)
		{	// destroy designated object and store new pointer
		if (_Ptr != _Myptr)
			delete _Myptr;
		_Myptr = _Ptr;
		}

private:
	_Ty * _Myptr;	// the wrapped object pointer
	};

std::auto_ptr<Investment> pInv1(createInvestment());
//pInv2指向对象，pInv1被设为null
std::auto_ptr<Investment> pInv2(pInv1);
pInv1 = pInv2; //pInv1指向对象，pInv2被设置为null

auto_ptr的替代方案是“引入计数型智慧指针”
(reference-counting smart pointer;RCSP)。所谓RCSP也是个智能指针，持续
追踪共有多少对象指向某笔资源，并在无人指向它时自动删除该资源。

void f()
{
	std::tr1::shared_ptr<Investment> pInv1(createInvestment());
	std::tr1::shared_ptr<Investment> pInv2(pInv1); //指向同一个对象
	pInv1 = pInv2; //指向同一个对象
	...   
}

请记住

• 为防止资源泄漏，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源。
• 两个常被使用的RAII class分别是tr1::shared_ptr和auto_ptr。前者通常是较佳选择，因为其copy行为比较直观。若选择auto_ptr，复制动作会使它指向（被复制物）null.

条款14：在资源管理类中小心coping行为

条款13的观念：“资源取得时机便是初始化时机”
(Resource Acuisition Is Initialization;RAII),并以此作为"资源管理类"的脊柱，
也描述了auto_ptr和tr1::shared_ptr如何将这个观念表现在heap-based资源上

请记住

• 复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为。
• 普通而常见的RAII class copying行为是：抑制copying、施行引用计数法(reference counting)。不过其他行为也都可能被实现。

条款15：在资源管理类中提供对原始资源的访问

请记住

• APIs往往要求访问原始资源(raw resources),所以每一个RAII class应该提供一个"取得其所管理之资源"的办法。
• 对原始资源的访问可能经由显示转换或隐式转换。一般而言显示转换比较安全，但隐式转换对客户比较方便。

条款16：成对使用new和delete时要采取相同的形式

delete 的最大问题在于：即将被删除的内存之内究竟有多少对象？这个对象的问题
答案决定了有多少个析构函数必须被调用起来。

---

实际上这个问题可以更简单些：即将被删除的那个指针，所指的是单一对象或
对象数组？这个必不可缺的问题，因为单一对象的内存布局一般而言不同于数
组的内存布局。

	std::string* stringPtr1 = new std::string;
	std::string* stringPtr2 = new std::string[100];

	delete stringPtr1;   //删除一个对象
	delete[] stringPtr2; //删除一个又对象组成的数组

请记住

• 如果你在new表达式中使用[]，必须在相应的delete表达式中也使用[]。如果你在相应的new表达式中不使用[],一定不要在相应的delete表达式中使用[]。

条款17：以独立语句将newed对象置入智能指针

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

1. 执行"new Widget"

2. 调用prioirty

3. 调用tr1::shared_ptr构造函数

   万一对priority的调用导致异常，会发生什么事？
   在此情况下"new Widget"返回的指针将会遗失。
   

---

避免这类问题的办法很简单：使用分离语句，分别写(1)创建Widget。
(2)将它置入一个智能指针内，然后再把那个智能指针传给processWidget:

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

请记住

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