4、C++快速入门2

1、抽象类

　　如果一个类里面有纯虚函数，其被编译器认为是一个抽象类，抽象类不能用来实例化一个对象

　　纯虚函数定义：virtual void 函数名（void）=  0;

　　抽象类是给派生类定义好接口函数，如果派生类不实现抽象类中的所有纯虚函数，这个派生类还是一个抽象类，不能实例化对象

2、抽象类界面

　　一个程序由多个人编写，分为：

　　应用编写：使用类

　　类编写：提供类（把提供类编译成库）

　　eg：Makefile内容

　　Human:main.o libHuman,so

　　　　g++ -o $@ $< -L./ -lHuman

　　%.o:%.cpp

　　　　g++ -fPIC -c -o $@ $<

　　libHuman.so:Englishman.o Chinese.o Human.o

　　　　g++ -shared  -o $@ $^

　　make后执行命令：LD_LIBRARY_PATH=./ ./Human

　　这个时候如果修改Englishman.cpp ，make libHuman.so的时候只会重新生成libHuman.so,不会重新生成应用程序

　　对上面那个Makefile，如果.h和.cpp都发送了变化，这个时候如果仅make  libHuman.so,运行的时候程序会崩溃，怎么样解决这种问题？

　　解决办法是main.c中仅包含一个头文件a.h，main中需要实例化某个对象的时候让该类提供一个函数，这个函数在a.h中声明，并在类中实现：

　　eg：在类中Human & CreateEnglishman(char *name,int age,char *address){ return *(new Englishman(name,age,address))};

　　　　在a.h中Human & CreateEnglishman(char *name,int age,char *address);//注意a.h是中间头问题，被main.c包含，a.h也被类所在的cpp包含

　　注意：通过delete 来删除CreateEnglishman返回的对象的时候，是调用huamn的析构函数，所有需要把析构函数声明为虚函数，这样能根据对象的实际情况调用相印的类的析构函数，析构函数不能是纯析构函数，否则在派生类必须要实现同名的析构函数，否则派生类还是抽象类（有纯虚函数的类都是抽象类）

3、函数模板

template<typename T>

T& mymax(T& a,T& b)

{

　　return (a < b)?b:a;

}

使用的方法：int ia =1,ib =2;mymax(ia,ib);

函数模块只是编译指令，一般写在头文件中，编译程序的时候，编译器根据函数的参数来“推导”模板的参数，然后生成具体的函数

比如上面的使用方法会生成如下代码：

int& mymax(int& a,int& b)

{

　　return (a < b)?b:a;

}

函数模版支持两中隐式转换（比如上述mymax函数模版，当传入的a和b的类型不一致时，编译器会报错推导不出函数，仅两张情况例外）：

A、const转换，模块参数声明为const：T& mymax(const T&,const T&b);这个时候传入的参数可以不带const属性；

B、数组或函数指针转换：T& mymax(T& a,T& b)；如果char a[]="abc";char b="cd";mymax(a,b)会出错，因为a,b在这里实际上是（char[4],char[3]）,无法推导出T

如果存在多个可匹配的模块函数和普通函数

eg：template<typename T>

const T& mymax(const T& a,const T& b)

{

　　return (a<b)?b:a;

}

const T& mymax(T& a,T& b)

{

　　return (a<b)?b:a;

}

const int& mymax(const int& a,const int& b)

{

　　return (a<b)?b:a;

}

int main(int argc,char **argv)

{

　　int ia =1;int ib =2;

　　mymax(ia,ib);

}

函数选择过程：

A、列出所有匹配的函数：

　　第一个模板函数推导后的函数：mymax(const int& a,const int& b)

　　第二个模板函数推导后的函数：mymax(int& a,int& b)

　　第三个普通函数：mymax(const int& a,const int& b)

B、根据参数的转换排序:第二个模块和第三个函数排在第一位；第一个模板排在第二位

　　第一个模板int->const int

　　第二个模板int->int

　　第三个函数int->int

C、如果某个候选函数的参数跟调用时传入的参数跟匹配，则选择此候选函数

D、如果这些候选函数的参数匹配度相同

　　首先，优先选择普通函数

　　其次，对于多个模板函数，选择“更特化”的（更特化指的是参数更特殊、更具体、更细化）

　　否则出现二义性错误

4、类模块

template<typename T>

class AAA{

private:

　　T t;

public:

　　void test_func(const T &t);

　　void print(void);

}

template<typename T> void AAA<T>::test_func(const T &t)

{

　　this->t = t;

　　count<<t<<endl;

}

template<typename T> void AAA<T>::print(void)

{

　　cout<<t<<endl;

}

int main(int argc,char **argv)

{

　　AAA<int> a;

　　a.test_func(1);

　　a.print();

　　AAA<double> b;

　　b.test_func(1.23);

　　b.print();

　　return 0;

}

同时如果对当前的类模块不满意，也可以定做上面的类模版

在上面的基础上添加代码：

template<>

class AAA<int>{

public:

　　void test_func_int(const int & t)

　　{

　　　　cout<<t<<endl;

　　}

　　void print_int(void);

}

void AAA<int>::print_int(void)

{

　　cout<<"for test"<<endl;

}

重写main函数：

int main(int argc,char **argv)

{

　　AAA<int> a;

　　a.test_func_int(1);

　　a.print_int();

　　AAA<double> b;

　　b.test_func(1.23);

　　b.print();

　　return 0;

}

5、异常

三个函数A、B、C，其中A调用B，B调用C

C()

{

　　return XX;

}

B()

{

　　if(C()){}

　　else return -Err;

}

A()

{

　　if(B()){}

　　else {}

}

如果C出错了，A需要去处理这个错误，就需要一级一级的判断，这样如果存在N级调用的时候会非常麻烦，在C++中通过异常来处理该问题

函数A捕获函数C发出的异常，举例如下：

void C(){

　　throw 1;//抛出异常后直接跳到A中的catch处执行了，如果这里抛出的不是int类型的数据，程序会崩溃

}

void B(){

　　cout<<"call c...."<<endl;

　　C();

　　cout<<"After call c...."<<endl;//当在C中抛出异常后，这条语句不会在执行

　　}

void A(){

　　try{

　　　　B{}

　　}catch (int i)

　　{

　　　　cout<<"catch exception "<<i<<endl

　　}

　　//catch (...){}//这里的省略号表示所有异常

}

当抛出了个派生类的时候，如果catch（基类），会发生隐式转换，catch能捕获异常。

可以在函数后面声明这个函数会抛出那些异常，如果其throw非声明异常，程序会崩溃，不管有没相印的catch：eg ：void C() throw(int,double){}

抛出异常如果函数没处理，其实际上是交给系统来处理了，会执行2个函数“unexpected”和“terminate”，unexpected函数用来处理声明之外的异常，terminate函数用来处理catch分支未捕获到的异常，如果都没有会两者都调用

可以通过下面语句修改这个默认的处理函数

eg：set_unexpected(异常处理函数);

也可以设置终止函数：

eg：set_terminate(终止函数名称);

6、智能指针（下面的sp就是只能指针）

void test_func(void)　{

　　Person *p = new Person();

}

int main(int argc,char **argv)

{

　　test_func();//没有释放new的Person对象，会造成内存泄漏，知道main函数退出

}

如果test_func改为｛Person per;｝//局部变量，函数退出时对象就会被释放，调用其析构函数

使用指针也能不会造成内存泄漏的方法：

方法1：

class sp{

private:

　　Person *p;

public:

　　sp(Person *other)

　　{

　　　　p =other;

　　}

　　~sp()

　　{

　　　　if(p)

　　　　　　delete p;

　　}

}

void test_func(void)　{

　　sp s = new Person();

}

int main(int argc,char **argv)

{

　　test_func();

}

对方法一进行修改：

class sp{

private:

　　Person *p;

public:

　　sp():p(0){}//构造函数p的默认值是0

　　sp(Person *other)

　　{

　　　　p =other;

　　}

　　~sp()

　　{

　　　　if(p)

　　　　　　delete p;

　　}

　　Person *operator->()//重载->

　　{

　　　　return p;

　　}

}

void test_func(void)　{

　　sp s = new Person();

　　s->printInfo();//调用的是Person里面的函数，因为“->”重载了

}

int main(int argc,char **argv)

{

　　int i;　　

　　for(i =0;i<2;i++)

　　　　test_func();

}

再次修改：

class sp{

private:

　　Person *p;

public:

　　sp():p(0){}

　　sp(Person *other)

　　{

　　　　p =other;

　　}

　　sp(sp &other)

　　{

　　　　p =other.p;

　　}

　　~sp()

　　{

　　　　if(p)

　　　　　　delete p;

　　}

　　Person *operator->()//重载->

　　{

　　　　return p;

　　}

}

void test_func(sp &other)　{

　　sp s = other;

　　s->printInfo();//调用的是Person里面的函数，因为“->”重载了

}

int main(int argc,char **argv)

{

　　int i;　　

　　sp other = new Person()//编译会出错

/*

　　上面这句代码相当与：

　　A、Person *p = new Person()

　　B、sp tmp(p);相当于调用sp(Person *other)构造函数

　　C、两种可能：1、sp other(tmp);相当于调用sp(sp &other)构造函数

　　　　　　　　　　出问题的愿意是sp & other这个引用来指向tmp这个临时变量，这是不对的，引用没法执行一个临时变量；但是const sp &other可以指向tmp，所以修改sp(sp &other)构造函数为sp(const sp &other)

　　　　　　　　  2、tmp转换成Person*，在调用sp(Person *other)构造函数来生成other

　　　　　　　　　　tmp是一个sp对象，其没办法隐式转换成Person *指针

*/

　　　test_func(other );　　

}

执行结果正确；

但是如果main函数改为下面，程序运行会崩溃：

int main(int argc,char **argv)

{

　　int i;　　

　　sp other = new Person();

　　for(i=0;i<2;i++)

　　　test_func(other );　　//原因是第一次退出test_func的时候会释放掉new分配的Person空间，第二次循环的时候在次调用s->printInfo();时候，Person对象已经不存在了，可以通过在Person对象中加一个引用计数，并添加获取、加1、减1三个函数，同时在sp类中所有的构造函数都调用加1函数，析构函数中先调用减1函数，接着调用获取函数来得到引用计数的值，如果为零，就调用delete p来释放，并把p设置为NULL。

}

同时还可以在sp中重载“*”

eg：Person& operator*()

　　{

　　　　return *p;

　　}

在main中

　　sp other = new Person();

　　(*other).printlnfo();

可以把sp定义为类模块：

template<typename T>

class sp{

private:

　　T *p;

public:

　　sp():p(0){}

　　sp(T *other)

　　{

　　　　p = other;

　　　　p->incStrong();

　　}

　　sp(const sp &other)

　　{

　　　　p = other.p;

　　　　p->incStrong();

　　}

　　~sp()

　　{

　　　　if(p)

　　　　{

　　　　　　p->decStrong();

　　　　　　if(p->getStrongCount() == 0)

　　　　　　{

　　　　　　　　delete p;

　　　　　　　　p = NULL;

　　　　　　}

　　　　}

　　}

　　T *operator->()

　　{

　　　　return p;

　　}

　　T& operator*()

　　{

　　　　return *p;

　　}

}

template<typename T>

void test_FUNC(SP<T> &other)

{

　　sp<T> s =other;

　　s->printInfo();

}

int main(int argc,char **argv)

{

　　sp<Person> other = new Person();

　　test_func(other);

}

7、Android轻量级指针（在源码RefBase.h中,sp的相关源码在StrongPointer.h中）

　　对上面的代码，引用计数的加1和减1操作不是原子的，在多线程的时候存在风险，在Android源码的RefBase.h中，其也是维护了一个引用计数，其加1和减1如下：

　　void incStrong()

　　{

　　　　__sync_fech_and_add(&mCount,1);

　　}

　　void decStrong()

　　{

　　　　//__sync_fetch_and_sub(&mCount,1)返回的是减一之前的指

　　　　if(__sync_fetch_and_sub(&mCount,1)==1){

　　　　　　delete static_case<const T*>(this);

　　　　}

　　}

　　修改6中的代码继承源码中的智能指针：

using namespace std;

using namespace android::RSC;

class Person : public LightRefBase<Person>{//LightRefBase里面有sp的相关代码

public:

　　Person(){

　　　　cout<<"Person()"<<endl;

　　}

　　~Person()

　　{

　　　　cout<<"~Person()"<<endl;

　　}

　　void printlnfo(void)

　　{

　　　　cout<<"just a test function"<<endl;

　　}

}

template<typename T>

void test_FUNC(sp<T> &other)

{

　　sp<T> s =other;

　　s->printInfo();

}

int main(int argc,char **argv)

{

　　sp<Person> other = new Person();

　　test_func(other);

}

8、弱指针的引人

　　智能指针的缺陷

　　eg：test_func()

　　{

　　　　sp<Person> a = new Person(); //a指向的对象的count = 1

　　　　sp<Person> b = new Person();//b指向的对象的count = 1

　　　　a->setFather(b);//a引用了b；b所指向的count =2；

　　　　b->setSon(a);//b引用了a；a所指向的count =2；

　　}

　　test_func程序退出的时候~a和~b执行，两者的count =1，这个时候会产生内存泄漏

　　

　　eg：

using namespace std;

using namespace android::RSC;

class Person : public LightRefBase<Person>{//LightRefBase里面有sp的相关代码

private：

　　sp<Person> father;

　　sp<Person> son;

public:

　　Person(){

　　　　cout<<"Person()"<<endl;

　　}

　　~Person()

　　{

　　　　cout<<"~Person()"<<endl;

　　}

　　void setFather(sp<Person> &father)

　　{

　　　　this->father = father;

　　}

　　void setSon(sp<Person> &son)

　　{

　　　　this->son= son;

　　}

　　void printlnfo(void)

　　{

　　　　cout<<"just a test function"<<endl;

　　}

}

void test_FUNC()

{

　　　　sp<Person> father = new Person();

　　　　sp<Person> son = new Person();

　　　　father ->setSon(son );

　　　　son ->setFather(father );

}

int main(int argc,char **argv)

{

　　test_func(other);

　　return 0;

}

执行结果：

Person()

Person()

如果去掉son ->setFather(father );

执行结果：

Person()

Person()

~Person()

~Person()

分析原因：如果对象里含有其他对象成员，构造时先构造其他对象成员，在构造对象本事；析构时顺序正好相反

sp<Person> father = new Person();

1、对于new Person()

1.1 Person对象里面的father被被构造，执行sp的默认构造函数inline sp():m_ptr(0){},什么都没做

1.2 Person对象里面的son被构造，执行sp的默认构造函数inline sp():m_ptr(0){},什么都没做

1.3 Person对象本身被构造

2、Person对象的指针传给“sp<Person> father”

　　导致sp(T*other)被调用

　　它增加了这个Person对象的引用计数（现在此值等于1）

sp<Person> son= new Person();

1、对于new Person()

1.1 Person对象里面的father被被构造，执行sp的默认构造函数inline sp():m_ptr(0){},什么都没做

1.2 Person对象里面的son被构造，执行sp的默认构造函数inline sp():m_ptr(0){},什么都没做

1.3 Person对象本身被构造

2、Person对象的指针传给“sp<Person> son”

　　导致sp(T*other)被调用

　　它增加了这个Person对象的引用计数（现在此值等于1）

1、setSon里面执行的是"="操作，sp的“=”符号被重载了，它会再次增加son对象的引用计数变成2了

father ->setSon(son );

1、setFather里面执行的是"="操作，sp的“=”符号被重载了，它会再次增加father对象的引用计数变成2了

son ->setFather(father );

当test_func被执行完后，father和son被析构

1、father析构的时候调用~sp()：会调用对象的decStrong函数来减1引用计数，还没为0，不会delete掉对象

1、son析构的时候调用~sp()：会调用对象的decStrong函数来减1引用计数，还没为0，不会delete掉对象

　　对于father指向的对象，其通过father ->setSon(son )引用了son对象，导致son计数变成2了，其可以决定son指向对象的生死，同理son指向的对象，其通过son->setFather(father)引用了father对象，导致father计数变成2了，其可以决定son指向对象的生死

　　如果想杀掉father，需要先杀掉son中的引用值，同理杀掉son，需要先杀掉father中的引用值，这样就死锁了。

　　强指针/强引用   A指向B，A决定B的生死

　　弱指针/弱引用  A指向B，A不能决定B的生死

　　本例子这里是强引用，导致死锁，必须引入弱引用或者弱指针，使得father ->setSon(son )时不增加引用计数就可以解决该问题。

9、强弱引用（强弱指针）的引入

　在RefBase基类中有定义了两个引用计数，分别用于强弱引用

　强引用的使用sp<Person>,sp的构造函数肯定是调用incStrong来增加强引用计数，析构函数调用decStrong来减少引用计数

弱引用的使用wp<Person>,wp的构造函数肯定是调用incWeak来增加强引用计数，析构函数调用decWeak来减少引用计数

　eg：本例子需要复制Android源码中的RefBase.cpp到本工程中,还有一些头文件

　举例person9.cpp

　　Makefile:

　　person9:person9.o RefBase.o

　　　　g++ -o $@ $^

　　%.o : %.cpp

　　　　g++ -c -o $@ $< -I include

　　clean:

　　　　rm -f *.o person9

　　person9.cpp

using namespace std;

using namespace android;

class Person : public RefBase{

private：

　　wp<Person> father;

　　wp<Person> son;

public:

　　Person(){

　　　　cout<<"Person()"<<endl;

　　}

　　~Person()

　　{

　　　　cout<<"~Person()"<<endl;

　　}

　　void setFather(sp<Person> &father)

　　{

　　　　this->father = father;

　　}

　　void setSon(sp<Person> &son)

　　{

　　　　this->son= son;

　　}

　　void printlnfo(void)

　　{

　　　　cout<<"just a test function"<<endl;

　　}

}

void test_FUNC()

{

　　　　sp<Person> father = new Person();

　　　　sp<Person> son = new Person();

　　　　father ->setSon(son );

　　　　son ->setFather(father );

}

int main(int argc,char **argv)

{

　　test_func(other);

　　return 0;

}

执行结果：

Person()

Person()

~Person()

~Person()

解决了强指针相互引用导致死锁的问题

eg：

修改上面的main函数：

int main(int argc,char **argv)

{

　　wp<Person> s = new Person();

　　s->printlnfo();//编译的时候会出错，因为弱指针里面“->”没有重载，也没有重载“*”，因为wp进简单引用，没有控制对象的生死，所以如果重载"->"或者“*”，在使用的时候可能对象已经释放了，存在风险，所以源码中没有重载

　　return 0;

}

所以要改为强指针

int main(int argc,char **argv)

{

　　sp<Person> s = new Person();

　　if(s != 0)

　　　　s->printlnfo();

　　return 0;

}

eg:修改person.cpp

using namespace std;

using namespace android;

class Person : public RefBase{

private：

　　char *name

　　wp<Person> father;

　　wp<Person> son;

public:

　　Person(){

　　　　cout<<"Person()"<<endl;

　　}

　　Person(char *name){

　　　　cout<<"Person(char *name)"<<endl;

　　　　this->name = name;

　　}

　　void setFather(sp<Person> &father)

　　{

　　　　this->father = father;

　　}

　　void setSon(sp<Person> &son)

　　{

　　　　this->son= son;

　　}

　　~Person()

　　{

　　　　cout<<"~Person()"<<endl;

　　}

　　char *getNmae(void)

　　{

　　　　return name;

　　}

　　void printlnfo(void)

　　{

　　　　sp<Person> f = father.promote();//弱指针转换成强指针

　　　　sp<Person> s = son.promote();

　　　　cout<<"I am"<<endl;

　　　　if(f  != 0)

　　　　　　cout<<"My father is "<<f->getName()<<endl;

　　　　if(s != 0)

　　　　　　cout<<"My son is "<<s->getName<<endl;

　　}

}

void test_FUNC()

{

　　　　sp<Person> father = new Person("LiYiShi");

　　　　sp<Person> son = new Person("LiErShi");

　　　　father ->setSon(son );

　　　　son ->setFather(father );

　　　　father->printInfo();

　　　　son ->printInfo();

}

int main(int argc,char **argv)

{

　　test_func();

　　return 0;

}

执行结果：

Person(char*name)

Person(char*name)

I am LiYiShi My son is LiErShi

I am LiErShi My fatheris LiYiShi

~Person()

~Person()

本例子使用弱指针解决了相互引用导致的问题，并且将弱指针转换为强指针可以引用对象中的函数。

强引用计数永远小与弱引用计数

10、单例模式

最简单的单例模式使用一个全局指针，如果指针为空，就new一个对象，否则直接使用

eg：

class Singleton；

Singleton *gInstance；

class Singleton{

public:

　　static Singleton *getInstance()

　　{

　　　　if(NULL = gInstance)

　　　　　　gInstance = new Singleton;

　　　　return gInstance;

　　}

　　Singleton()

　　{

　　　　cout<<"singleton()"<<endl;

　　}

　　void printInfo(){cout<<"This is singleton"<<endl}

｝;

int main(int argc,char ** argv)

{

　　Singleton *s = Singleton::getInstance();

　　s->printInfo();

　　Singleton *s = Singleton::getInstance();

　　s->printInfo();

　　Singleton *s = Singleton::getInstance();

　　s->printInfo();

　　return 0;

}

执行结果：

Singleton()//只会执行一次构造函数

This is singleton

This is singleton

This is singleton

修改main函数：

void *start_routine_thread1(void *arg)

{

　　cout<<"this is thread 1...."<<endl

　　Singleton *s = Singleton::getInstance();

　　s->printInfo();

　　return NULL;

}

void *start_routine_thread2(void *arg)

{

　　cout<<"this is thread 2...."<<endl

　　Singleton *s = Singleton::getInstance();

　　s->printInfo();

　　return NULL;

}

int main(int argc,char ** argv)

{

　　//创建线程，在线程里也去调用Singleton::getInstance()

　　pthread_t thread1ID;

　　pthread_t thread2ID;

　　pthread_create(&thread1ID,NULL,start_routine_thread1,NULL);

　　pthread_create(&thread2ID,NULL,start_routine_thread2,NULL);

　　sleep();

　　return 0;

}

上面的例子还是存在风险，如果两个线程同时执行，存在几率调用两次构造函数，改进方法是给那段代码加上锁；

eg：

　static pthread_mutex_t g_tMutex = PTHREAD_MUTEX_INITIALIZE;

　class Singleton{

　　static Singleton *getInstance()

　　{　　

　　　　if(NULL = gInstance)

　　　　{

　　　　　　pthread_mutex_lock(&g_tMutex );

　　　　　　if(NULL = gInstance)　　　　　　

　　　　　　　　gInstance = new Singleton;

　　　　　　pthread_mutex_lock(&g_tMutex );
　　　　}

　　　　return gInstance;

　　}

}

同时如果有人不使用getInstance()来实例化对象，而是调用Singleton *s = new Singleton();甚至Singleton s5，这些都会调用构造函数

解决办法：把构造函数声明为private来解决

优化：

把全局变量gInstance和锁移到类内部，并声明为static

eg：

　class Singleton{

　private：

　　　　static Singleton *gInstance；

　　　　static pthread_mutex_t g_tMutex ;

　public：

　　static Singleton * getInstance()

　　{。。。。}

　　。。。。

}

static在类外初始化：

Singleton *Singleton ::gInstance；

pthread_mutex_t Singleton ::g_tMutex = PTHREAD_MUTEX_INITIALIZE;

上面这种单例设计模式被称为懒汉模式（用到时才生存实例对象），对应的还有饿汉模式

饿汉模式就是在类外初始化的时候直接实例化,这个时候也不需要锁了：

Singleton *Singleton ::gInstance = new Singleton()；

11、桥接模式（android源码中只要发现了impl，其肯定就是使用桥接模式）

作用：将抽象部分和它的实现部分分离，使他们都可以独立地变化

说通俗点就是在一个类里面放另一个类的指针，这个指针指向令一个对象，使用这个指针来访问对象中的函数

举例：给电脑安装操作系统

eg：using namespace std;

class OS{

public :

　　virtual void install() = 0;//纯虚函数

}

class LinuxOS : public OS{

public:

　　virtual void Install(){cout<<"Install Linux OS"<<endl;}

}

class WindowsOS : public OS{

public:

　　virtual void Install(){cout<<"Install Windows OS"<<endl;}

}

class Computer{

public:

　　virtual void printInfo() = 0;

}

class MAC:public Computer{

public:

　　virtual void printInfo(){cout<<"This isMac"<<endl;};

}

class MacWithLinux: public LinuxOS,public MAC {

public:

　　void InstallOS(){printInfo();Install();}

}

class MacWithWindows: public WindowsOS,public MAC {

public:

　　void InstallOS(){printInfo();Install();}

}

class Lenovo:public Computer{

public:

　　virtual void printInfo(){cout<<"This is Lenovo"<<endl;};

}

class LenovoWithLinux: public LinuxOS,public Lenovo {

public:

　　void InstallOS(){printInfo();Install();}

}

class LenovoWithWindows: public WindowsOS,public Lenovo {

public:

　　void InstallOS(){printInfo();Install();}

}

int main(int argc,char **argv)

{

　　MacWithLinux a;

　　a.InstallOS();

　　LenovoWithLinux b;

　　b.InstallOS();

　　return 0;

}

上面的这个例子太复杂了如果computer有M个派生类，OS有N个派生类，那么要维护一个M*N的派生类，对于computer和OS我们能否建立连接，也就是说搭一个桥，在computer里面建个指针指向OS就可以了

改进代码如下：

eg：using namespace std;

class OS{

public :

　　virtual void installOS_impl() = 0;//纯虚函数

}

class LinuxOS : public OS{

public:

　　virtual void installOS_impl(){cout<<"Install Linux OS"<<endl;}

}

class WindowsOS : public OS{

public:

　　virtual void installOS_impl(){cout<<"Install Windows OS"<<endl;}

}

class Computer{

public:

　　virtual void printInfo() = 0;

　　virtual void InstallOS() = 0;

}

class MAC:public Computer{

public:

　　virtual void printInfo(){cout<<"This isMac"<<endl;};

　　MAC(OS *impl){this->impl = impl};

　　void InstallOS(){printinfo();impl->installOS_impl();};

private:

　　OS *impl;

}

class Lenovo:public Computer{

public:

　　virtual void printInfo(){cout<<"This is Lenovo"<<endl;};

　　Lenovo(OS *impl){this->impl = impl};

　　void InstallOS(){printinfo();impl->installOS_impl();};

private:

　　OS *impl;

}

int main(int argc,char **argv)

{

　　OS *os1 = new linuxOS();

　　OS *os2 = new WindowsOS();

　　computer *c1 = new Mac(os1 );

　　computer *c2 = new Lenovo(os2 );

　　c1->InstallOS();

　　c2->InstallOS();

return 0;

}

　　　　Computer　　　　　　　　　　　OS　　　　　　　　　　　　　　　　　　　　　

　　　　InstallOS（抽象部分）                IntallOS_impl(实现部分)

　　Mac              Lenovo　　　　　　Linux　　 Windows

　　在Mac里面存放指针：OS *impl  使用的时候让其指向new Linux或者new Windows

　　这就是所谓的桥接关系