1.再说智能指针
1.1 为什么要用智能指针？对于一个指针，它指向一个动态分配内存的对象，若同时有多个指针指向该对象，那么当我们delete的时候，就会出现delete 一个无效内存的错误，因为该对象已经被delete过了，所以这就造成了错误。针对这一情况，我们想到，new 和 delete 必须是成对出现的，那么联想到类里面，很容易想到这个构造函数和析构函数也是成对出现的，对于每一个对象，初始化的时候会调用构造函数，而销毁的时候必然要调用析构函数。因此我们就可以对 指针 进行封装，将该指针的初始化，即资源的获取放在构造函数里，将资源的销毁放在析构函数里，把该类的对象看做一个指针，行使指针的功能，并且不会出现内存泄露的问题。如下例所示：
#ifndef __SMARTPTR_H__
#define __SMARTPTR_H__
#include <iostream>
class Animal{
public:
Animal(){
std::cout << "Animal..." << std::endl;
}
~Animal(){
std::cout << "~Animal..." << std::endl;
}
void display(){
std::cout << "in Animal..." << std::endl;
}
};
class SmartPtr{
public:
SmartPtr();
explicit SmartPtr(Animal *ptr);
~SmartPtr();
void reset_ptr(Animal *ptr);
const Animal *get_ptr() const;
Animal *operator->();
const Animal *operator->() const;
Animal &operator*();
const Animal &operator*() const;
operator bool() const;
private:
SmartPtr(const SmartPtr &other);
SmartPtr &operator=(const SmartPtr &other);
Animal *ptr_;
};
#endif
#include "smartptr.h"
SmartPtr::SmartPtr()
:ptr_(NULL)
{
}
SmartPtr::SmartPtr(Animal *ptr)
:ptr_(ptr)
{
}
SmartPtr::~SmartPtr(){
delete ptr_;
}
void SmartPtr::reset_ptr(Animal *ptr){
if(ptr_ != ptr){
delete ptr_;
ptr_ = ptr;
}
}
const Animal *SmartPtr::get_ptr() const{
return ptr_;
}
Animal *SmartPtr::operator->(){
return ptr_;
}
const Animal *SmartPtr::operator->() const{
return ptr_;
}
Animal &SmartPtr::operator*(){
return *ptr_;
}
const Animal &SmartPtr::operator*() const{
return *ptr_;
}
SmartPtr::operator bool()const{ //这里进行了类型转换
return ptr_; // 把ptr 转化成了bool类型
}
#include "smartptr.h"
#include <iostream>
using namespace std;
int main(int argc, const char *argv[])
{
SmartPtr smart(new Animal);
smart->display();
(*smart).display();
smart.reset_ptr(NULL);
if(!smart){ //类中将该对象转换成了bool型
cout << "ptr == NULL" << endl;
}
smart.reset_ptr(new Animal);
if(smart){
cout << "ptr != NULL" << endl;
}
return 0;
}
1.2 关于箭头操作符(->)
1.2.1 箭头操作符可以理解为一个递归调用的过程，直到返回结果为指针时才停止递归。这里以c++primer中的例子来说明问题。假如有一个类的对象 point，我们在主函数中调用 point->action(),由于优先级规则，这里相当于调用（point->action）（）；换句话说，我们想要调用的是point->action 的求值结果，这里编译器这样求值：
a）如果 point是个指针，则编译器将代码编译为调用该对象的action 成员；
b）如果 point 是定义了 operator->操作符重载的一个类的对象，则 point ->action 相当于 调用 (point.operator->) ->action, 求出括号内结果后重复一二步。
1.2.2 举例来说明这个问题，注意，重载箭头的返回值必须是指向类类型的指针，或者定义了自己的重载箭头操作符的类类型对象。
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class A{
public:
void action(){
cout << "Action in class A" << endl;
}
};
class B{
public:
A *operator->(){
return &a_;
}
void action(){
cout << "Action in class B" << endl;
}
private:
A a_;
};
class C{
public:
B &operator->(){
return b_;
}
void action(){
cout << "Action in class C" << endl;
}
private:
B b_;
};
int main(int argc, const char *argv[])
{
C *pc = new C;
pc->action();
C c;
c->action();
return 0;
}
2.句柄类
2.1 为什么要用句柄类？句柄类是什么？我们试图把一个继承体系中的多个对象放入一个数组中（即多个不同派生类的对象都放到一个数组中）。如果采用指针，会造成内存管理的极度混乱（因为有些对象可能已经被销毁，那么该指针就指向一块无用的内存）。在这个例子中，我们把 Animal 指针封装在一个Handle 类中，这个Handle 类实现的是深拷贝（拷贝构造函数里调用 Animal 类的copy 函数，将对象的全部内容拷贝，生成一个新的对象），这样每个Handle 对象相互独立。
为了实现Handle的深拷贝，我们在Animal中添加copy虚函数，这样就可以通过Animal* 达到赋值实际对象的目的（Cat、Dog）是一种多态。
为了实现通过Handle可以控制Animal，我们为Handle重载了->操作符，使它表现的像一个指针。（还有一种方案，在Handle中实现display，然后通过ptr去调用Animal内部的display）。
封装句柄的最终目的是在数组、vector中封装Animal系列对象的多态行为。
目前这个句柄的特点：Animal系列的继承体系对用户是可见的。
可以改进的地方：把深拷贝改为引用计数。
#ifndef __ANIMAL_H__
#define __ANIMAL_H__
#include <iostream>
class Animal{
public:
virtual ~Animal() {};
virtual void display() const = 0 ;
virtual Animal *copy() const = 0 ;
};
class Cat : public Animal{
public:
void display() const{
std::cout << "Cat ..." << std::endl;
}
Cat *copy() const{
std::cout << "Cat copy" << std::endl;
return new Cat(*this);
}
};
class Dog : public Animal{
public:
void display() const{
std::cout << "Dog ..." << std::endl;
}
Dog *copy()const{
return new Dog(*this);
}
};
#endif
#ifndef __HANDLE_H__
#define __HANDLE_H__
#include "animal.h"
class Handle{
public:
Handle();
Handle(const Animal &ptr);
Handle(const Handle &other);
Handle &operator=(const Handle &other);
~Handle();
Animal *operator->();
const Animal *operator->() const;
private:
Animal *ptr_;
};
#endif
#include "handle.h"
#include "animal.h"
#include <iostream>
Handle::Handle()
:ptr_(NULL)
{
}
Handle::Handle(const Animal &ptr)
:ptr_(ptr.copy())
{
std::cout << "Handle constructor ..." << std::endl;
}
Handle::Handle(const Handle &other)
:ptr_(other.ptr_->copy())
{
std::cout << "Handle copy cnstructor... " << std::endl;
}
Handle &Handle::operator=(const Handle &other){
if(this != &other){
delete ptr_;
ptr_ = other.ptr_->copy();
}
return *this;
}
Handle::~Handle(){
delete ptr_;
}
Animal *Handle::operator->(){
return ptr_;
}
const Animal *Handle::operator->() const{
return ptr_;
}
#include "handle.h"
#include "animal.h"
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, const char *argv[])
{
vector<Handle> vec;
Cat c1, c2, c3;
Dog d1,d2;
vec.push_back(Handle(c1));
vec.push_back(Handle(c2));
vec.push_back(Handle(c3));
vec.push_back(Handle(d1));
vec.push_back(Handle(d2));
for(vector<Handle>::iterator it = vec.begin(); it != vec.end(); ++it){
(*it)->display();
}
Handle h(c1);
h->display();
return 0;
}
2.2 关于上例中的push_back函数，以Cat c1；为例，从语法的角度理解，这里先用c1对象去初始化一个Handle 对象，这里Handle对象时临时的，它的生存期值是在本行，生成的handle 临时对象会会调用handle类的拷贝构造函数 ，生成一个副本，vec 里面放的就是这个副本。注意在初始化Handle对象的时候，调用有参数的构造函数，在这个构造函数初始化列表中，我们调用了Animal类的copy函数，实现了对象的深拷贝，即将对象的全部内容拷贝到一个新的对象中去，之后二者再无关联。
3.句柄类和智能指针的主要区别：
a) 智能指针主要目的在于使用RAII管理资源，实现资源的自动释放。
b) 句柄类也实现了智能指针的功能，但是其主要目的是为了在数组中实现多态。