组成部分
1.抽象主题：基类，声明了代理对象和真实对象的共同点；
2.真实主题：真正需要被调用的对象；
3.代理对象：代理真实对象的对象。

分类
1.远程代理：也就是为一个对象在不同的地址空间提供局部代表，这样可以隐藏一个对象存在于不同地址空间的事实。这个不同的地址空间可以是在本机器上，也可以在另一台机器中。
2.虚拟代理：是根据需要创建开销很大的对象，通过它来存放实例化需要很长时间的真实对象，使其只有在真正需要时才被创建。
3.安全代理：也叫保护代理，用来控制真实对象访问时的权限，如果有必要的话，可以给不同调用者提供不同的权限。
4.智能指引：是指当调用真实对象时，代理处理另外一些事，比如记录对此对象的调用次数等。
5.写时拷贝：虚拟代理的一种，把复制推迟到只有客户的需要时才进行。
6.缓存代理：为某一个目标的操作结果提供临时存储空间，以便其他客户的可以共享访问，有点缓存的味道。
7.防火墙代理：保护对象，不让用户访问，安全代理的特例。
8.同步代理：可以让几个用户同时访问同一个对象而不产生冲突。
常用的是前四种代理方式。

UML类图
 

实例代码
1）Proxy.h

 1#ifndef _PROXY_H
 2#define _PROXY_H
 3
 4/**////@brief Abstract Base Class.
 5class Subject 
 6{
 7public:
 8    Subject() {}
 9    virtual ~Subject() {}
10    virtual void request() = 0;
11};
12
13/**////@brief Real entity class.
14class RealSubject: public Subject 
15{
16public:
17    RealSubject();
18    virtual ~RealSubject();
19    virtual void request();
20};
21
22/**////@brief Proxy class, including a pointer of pointing to the Real-entity class. 
23class Proxy: public Subject 
24{
25public:
26    Proxy();
27    virtual ~Proxy();
28    virtual void request();
29
30private:
31    RealSubject* m_realSubject;
32};
33
34#endif

 1#include "Proxy.h"
 2#include <iostream>
 3
 4using namespace std;
 5
 6RealSubject::RealSubject()
 7{
 8    cout << "RealSubject constructor" << endl;
 9}
10
11RealSubject::~RealSubject()
12{
13    cout << "RealSubject destructor" << endl;
14}
15
16/**////@brief Real-entity's request method.
17void RealSubject::request()
18{
19    cout << "RealSubject request" << endl;
20}
21
22Proxy::Proxy(): m_realSubject(NULL)
23{
24    cout << "Proxy constructor" << endl;
25}
26
27Proxy::~Proxy()
28{
29    cout << "Proxy destructor" << endl;
30    delete m_realSubject;
31    m_realSubject = NULL;
32}
33
34/**////@brief Proxy's request method.
35void Proxy::request()
36{
37    cout << "Proxy request" << endl;
38
39    /**////@brief Construct it when necessary.
40    if (!m_realSubject) {
41        m_realSubject = new RealSubject();
42    }
43
44    m_realSubject->request();
45}

 1#include "Proxy.h"
 2#include <iostream>
 3
 4using namespace std;
 5
 6int main()
 7{
 8    Subject* proxy = new Proxy();
 9    proxy->request();
10
11    delete proxy;
12    proxy = NULL;
13
14    return 0;
15}

1.extern "C"的理解：
很多人认为"C"表示的C语言，实际并非如此，"C"表示的是一种链接约定，只是因C和C++语言之间的密切关系而在它们之间更多的应用而已。实际上Fortran和汇编语言也常常使用，因为它们也正好符合C实现的约定。
extern "C"指令描述的是一种链接约定，它并不影响调用函数的定义，即时做了该声明，对函数类型的检查和参数转换仍要遵循C++的标准，而不是C。

2.extern "C"的作用：
不同的语言链接性是不同的，那么也决定了它们编译后的链接符号的不同，比如一个函数void fun(double d)，C语言会把它编译成类似_fun这样的符号，C链接器只要找到该函数符号就可以链接成功，它假设参数类型信息是正确的。而C++会把这个函数编译成类似_fun_double或_xxx_funDxxx这样的符号，在符号上增加了类型信息，这也是C++可以实现重载的原因。
那么，对于用C编译器编译成的库，用C++直接链接势必会出现不能识别符号的问题，是的，需要extern "C"的时刻来了，它就是干这个用的。extern "C" 的作用就是让编译器知道要以C语言的方式编译和连接封装函数。

3.在C++中调用C库的例子：
1).做一个C动态库：

编译并copy到系统库目录下(也可以自己定义库目录，man ldconfig):
[root@coredump test]# gcc --shared -o libhello.so hello.c
[root@coredump test]# cp libhello.so /lib/
2).写个C++程序去调用它：

编译并运行：
[root@coredump test]# g++ test.cpp -o test -lhello
[root@coredump test]# ./test
hello
[root@coredump test]#
3).__cplusplus宏的条件编译：
为什么要加这个条件编译呢？小沈阳有话：小妹，这是为什么呢？
因为这种技术也可能会用在由C头文件产生出的C++文件中，这样使用是为了建立起公共的C和C++文件，也就是保证当这个文件被用做C文件编译时，可以去掉C++结构，也就是说，extern "C"语法在C编译环境下是不允许的。
比如：将上面的test.cpp更名为test.c，将头文件改为stdio.h，将条件编译去掉，再用gcc编译就可以看到效果。而即使做了上面的修改，如果用g++编译就可以正常使用，这就是我上面说的“公共的C和C++文件”的意思。

4.C调用C++库：
C++调用C库看上去也不是那么困难，因为C++本身就有向前(向C)兼容的特性，再加上纯天然的extern "C"约定，使得一切都是那么自然。而让C调用C++的库似乎就没那么容易，不过也不是不可以的。
说到这里我得休息一下，大中午的，出去抽根烟先，不过我也相信如果你不知道答案，看到这里的时候肯定在到处找板砖，恨不得敲开我的脑壳子。我能理解，我也习惯了，我有个学姐一看到我第一反应就是扔出一块砖头先！
言归正传，还是要借助这纯天然的extern "C"。

1)做一个C++库：

编译并copy到系统库目录下:
[root@coredump test]# g++ --shared -o libworld.so world.cpp
[root@coredump test]# cp libworld.so /lib/
2)做一个中间接口库，对C++库进行二次封装：

其中方法m_world即为libworld库中world方法的二次封装，编译并copy到系统库目录下:
[root@coredump test]# g++ --shared -o libmid.so mid.cpp -lworld
[root@coredump test]# cp libmid.so /lib/
3).C程序通过链接二次接口库去调用C++库：

编译并运行：
[root@coredump test]# gcc test.c -l mid -o test
[root@coredump test]# ./test
world
[root@coredump test]#
注：如果对于C++库中含有类的，可以在二次接口函数中生成临时对象来调用对应的功能函数，当然要根据实际情况来定了。

5.靠，过了午休时间了，收工！

    相对于静态函数库，动态函数库在编译的时候并没有被编译进目标代码中，而只是作些标记。然后在程序开始启动运行的时候，动态地加载所需模块，因此动态函数库所产生的可执行文件比较小。由于函数库没有被整合进你的程序，而是程序运行时动态的申请并调用，所以程序的运行环境中必须提供相应的库。动态函数库的改变并不影响你的程序，所以动态函数库的升级比较方便。

2.命名：
    静态库的名字一般为libxxxx.a，其中xxxx是该lib的名称。
    动态库的名字一般为libxxxx.so.major.minor，xxxx是该lib的名称，major是主版本号，minor是副版本号。版本号也可以没有，一般都会建立个没有版本号的软连接文件链接到全名的库文件。

3.创建：
无论静态库还是动态库，创建都分为两步，第一步创建目标文件，第二步生产库。
1).静态库的创建：
#gcc -c test.c -o test.o
#ar rcs libtest.a test.o
名字为libtest.a的静态库就生产了，其中选项：
r 表明将模块加入到静态库中；
c 表示创建静态库；
s 表示生产索引；
还有更多选项像增加、删除库中的目标文件，包括将静态库解包等可以通过man来获得。
2).动态库的创建：
#gcc -fPIC -c test.c -o test.c
#gcc --share test.o -o libtest.so
-fPIC 为了跨平台

4.使用：
编译链接目标程序的方法是一样的：
#gcc main.c -L. -ltest -o main
-L.指定现在本目录下搜索库，如果没有，会到系统默认的目录下搜索，一般为/lib、/usr/lib下。
对于静态库，这个步骤之后就可以将libtest.a库删掉，因为它已经被编译进了目标程序，不再需要它了。
而对于动态库，libtest.so库只是在目标程序里做了标记，在运行程序时才会动态加载，那么从哪加载呢？加载目录会由/etc/ld.so.conf来指定，一般默认是/lib、/usr/lib，所以要想让动态库顺利加载，你可以将库文件copy到上面的两个目录下，或者设置export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/XXX/YYY，后面为你自己动态库的目录，再或者修改/etc/ld.so.conf文件，把库所在的路径加到文件末尾，并执行ldconfig刷新。这样，加入的目录下的所有库文件都可见。

另外还有个文件需要了解/etc/ld.so.cache，里面保存了常用的动态函数库，且会先把他们加载到内存中，因为内存的访问速度远远大于硬盘的访问速度，这样可以提高软件加载动态函数库的速度了。

最后提一点，当同一目录下既有动态库又有静态库，并且两个库的名字相同时，编译时会如何链接呢？

gcc编译时默认都是动态链接，如果要指定优先链接静态库，需要指定参数static。

前三个是在编译时期进行类型转换的，而最后一个则是在运行时期进行转换的，即dynamic_cast函数需要RTTI的支持，如果是VC下，需要手动打开RTTI支持选项。

static_cast主要完成相关类型之间的转换，比如整型到枚举、整型到浮点等。但static_cast不能转换掉expression的const、volitale、或者__unaligned属性

const_cast一般用于强制消除对象的常量性，它是唯一能做到这一点的 C++ 风格的强制转型，但需注意的是只能转换指针或引用类型，而不能转换普通常量类型。
如：
const int a = 1;
int b = const_cast <int>(a);
是错误的。

reinterpret_cast用于字节数相同的类型之间的转换，常用的就是整型和指针之间、函数指针类型之间进行转换。操作符仅仅重新解释了对象的比特模型而没有进行二进制转换，需谨慎使用，一般只在把类型映射回原有类型时使用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）。

函数原型:
iterator erase(iterator where);
iterator erase(iterator first,iterator last);
basic_string& erase(size_type p0=0,size_type n=np);

删除某个容器里的某个元素：c.erase(T);
看似一个简单的动作，然而对不同类型的容器，内部却做了截然不同的事情，后面介绍。

假设有这样一个题目，将某个容器中所有满足条件N == X的元素删除，按照常规的思路应该有类似这样的代码：

然而这样的代码对于任一种容器都是错误的
容器按内存分配方式可以分为链表容器和数组容器。
所谓的链表容器指的是一种表现方式，包括list、slist等这样基于节点的容器（动态分配内存块）和set、map、multiset、multimap等关联容器（平衡树实现），而数组容器指的是在一块连续的内存上保存元素的连续内存容器，比如vector、deque、string等。

OK，现在说说erase对他们的操作，链表容器以list为例，当执行container.erase(it)时，确实第一个满足条件的元素删除了，但这时it指针已经被删除了，它也不指向任何元素了，所以也只能到此为止了，也就是说上面的代码对于链表容器来说只能正确删除第一个满足条件的元素，针对这个问题我们首先想到的就是在删除指针之前，给其做个备份，很好，不错的主意，我们一般采用的方法是建立个临时变量，这个临时变量可以在程序循环中适当的位置使用，看下列代码实现，是将这个临时变量直接建立在erase实现里，这样做更简洁，也显得专业些（以删除int型链表中所有偶数为例，也是大家都喜欢的一个例子）：

链表容器使用erase删除节点还有一个特点，就是会将下一个元素的地址返回，所以也可以这样实现：

当然用list容器本身提供的算法也是个不错的主意（挂回调）：

  bool evenNumber(int n)
  {
    return (n % 2 == 0);
  }
  
  
  
  lt.remove_if(evenNumber);

数组容器以vector为例，当执行container.erase(it)时，和上面提到的一样，第一个满足条件的元素删除了，但这时数组容器不允许中间有“空隙”，所以会做个大动作，就是将被删元素后面所有的元素前移（参考STL源码），而数组容器记录的是下标，所以删除元素后，当前下标定位的元素也就顺理成章的变成了原有队列中的下一个元素，同样以删除偶数为例，代码如下：

也可以使用reverse_iterator迭代器，并且在某些删除操作中会有更好的效率（因为它会使上面提到的“大动作”变小一些）：

拷贝构造函数：一种特殊的构造函数，他由编译器调用来完成一些基于同一类的其他对象的构件及初始化；

析构函数：摧毁一个对象并保证它被彻底清除；

赋值操作符：以已有对象为蓝本给另一对象进行新的赋值。

所谓的大三律（rule of three, the law of the big three or the big three）正是在规则他们之间的关系：

1.如果类定义了析构函数，那么也应该定义拷贝构造和赋值运算符；

2.如果类含有需要动态分配的成员，那么该类必须定义拷贝构造和赋值运算符；

一句话，析构函数、拷贝构造、赋值运算符重载应该总是同时出现。下面一个简单的例子程序对这个定律做了论证：

 1#include <iostream>
 2
 3using namespace std;
 4
 5class Test
 6{
 7  public:
 8    Test() 
 9    {  
10      _pdata = new char[100]; 
11    };
12
13    ~Test() 
14    { 
15      delete [] _pdata; 
16    };
17  
18  private:
19    char* _pdata;
20};
21
22
23int main()
24{ 
25  Test a;
26  Test b;
27  
28  b = a;
29
30  return 0;
31}
32

 1#include <stdio.h>
 2#include <stdlib.h>
 3#include <string.h>
 4
 5char* fun(const char* src)
 6{
 7  static char dest[32] = "";
 8  
 9  strcpy(dest, src);
10
11  return dest;
12}
13
14int main()
15{
16  char s1[32] = "";
17  char s2[32] = "";
18
19  strcpy(s1, fun("hello"));
20  strcpy(s2, fun("world"));
21
22  printf("%s %s\n", s1, s2);
23  printf("%s %s\n", fun("hello"), fun("world"));
24
25  return 0;
26}

    读一下这个程序，先看这个程序写的有问题没（假设fun函数的参数长度小于32）？如果你对这个程序中的fun函数返回一个局部变量的数组产生了疑问，那么我希望你是没注意到我使用的static类型，若你仍有疑问，建议你先回去查查static变量的作用域和生命周期的概念。
    OK，是运行这个程序的时候了，看一下运行结果是否跟你想象的一样呢？如果是一样的，那么这篇文章你不用看了，因为你已经掌握了我下面要说的问题了。好吧，对于不理解运行结果的朋友，我们来分析一些下面那个printf语句，首先要知道printf中的表达式、函数的执行顺序是至右向左的，也就是先执行了fun("world")返回了dest的地址，然后再执行fun("hello")也返回了dest的地址，而这两次返回的dest用的同一块地址（因为是static类型），也就是第二次的执行覆盖了第一次执行的结果，对dest地址进行了重新的赋值，所以结果就是打印两个hello了。

    我们在写C/C++程序的时候，经常需要从调用函数中取得自己想要的数据，这就需要调用者和函数之间要有个内存的交互，我们通常采用的方法是传递一个指针给被调函数，作为被调函数的输出参数，这也是我们常用的、规范的做法。
    但有很多程序员比较习惯直接取返回值，这就面临一个问题就是普通局部变量都是在栈上分派的，会随着函数的结束而弹栈释放，那么就会出现返回局部变量数组的问题，这时有人会想到用malloc或new在堆上分派内存，没错，这样是避免了前面说的问题，但这样又会带来新的问题，就是需要在外部对这块内存进行释放，这个是比较难把握的，多次释放会出现程序的crash，忘记释放了会出现内存leak，所以这种方法也不被推荐。还有人想到了更另类的方法，就是上面例子中的static类型，没错，static变量也是全局的，但就会出现上面程序的运行结果（可以认为不是我们想要的结果，也就是错误的结果）。
    所以，我们要慎用返回函数内部的static内存的这种设计，但如果在无法改变设计模式的情况下（有些系统函数的实现，比如inet_ntoa，可以通过在man手册中看到这样的一句话：The string is returned in a statically allocated buffer, which subsequent calls will overwrite），那么在自己使用的时候一定要注意，不要试图保存返回的内存地址或引用，而要保存返回内存的内容，也就是例子程序中的strcpy两行。

inet_ntoa的错误使用（判断两个IP地址是否相等）：

 1struct in_addr addr1;
 2struct in_addr addr2;
 3
 4// 网络包中包含了源地址
 5addr1.s_addr = 0x6500A8C0 // 192.168.0.101
 6addr2.s_addr = 0x6600A8C0 // 192.168.0.102
 7
 8// 这个if语句将永远为真
 9if (strcmp(inet_ntoa(addr1), inet_ntoa(addr2)) == 0) {
10  // do something
11} else {
12  // do other thing
13}