C++基本功和 Design Pattern系列 Inheritance VS Delegation

http://blog.sina.com.cn/u/1261532101

首先是const 和 reference的使用,这部分内容已经在C语言里说过,但是在C++里又有了一些扩展。 

C++允许使用object作为参数传递,但是object有大有小。 比如下面一个object class:

class CBitmap{
public:
    CBitmap();
    ~CBitmap();
private:
    const static UINT32 MAX_BUFFER_SIZE = 65536;
    UINT32 m_Height;
    UINT32 m_Width;
    BYTE    m_Buffer[MAX_BUFFER_SIZE];
};

如果我们有个函数,是DrawBitmap,那么就有两种不同的声明方式。
========错误的方式========
void DrawBitmap(CBitmap Bitmap);
========正确的方式========
void DrawBitmap(CBitmap & Bitmap);
如果我们使用第一种方式,那么程序就会创建一个临时的CBitmap object,然后把Bitmap拷贝进去,传送给DrawBitmap。这可不是只会拷贝几个字节那么简单,而且CBitmap的所有内容,包括里边的m_Buffer都会拷贝。如果使用reference也就是 "&",就不会有任何操作。如果在DrawBitmap里边不会改变Bitmap的任何状态,也就是不会改变任何属性,那么就最好加上const关键字,最后的 DrawBitmap的声明应该是:
void DrawBitmap(const CBitmap & Bitmap); 

这个时候,在DrawBitmap里,只能调用CBitmap中声明为const的函数。让我们来看看代码

class CBitmap{
public:
    CBitmap();
    ~CBitmap();
    UINT32 GetHeight(void) const;
    void SetHeight(void);
private:
    const static UINT32 MAX_BUFFER_SIZE = 65536;
    UINT32 m_Height;
    UINT32 m_Width;
    BYTE    m_Buffer[MAX_BUFFER_SIZE];
};

UINT32 CBitmap::GetHeight(void) const
{
   return m_Height;
}

void CBitmap::SetHeight(UINT32 Height)
{
  m_Height = Height;
}

大家看到了,在 UINT32 GetHeight(void) const; 有个const,意思是这个函数不会改变任何CBitmap里的属性值。由于SetHeight()会改变m_Height,所以不能声明为const. 在DrawBitmap里边,由于参数是const类型,所以只能调用 const的方法。
void DrawBitmap(const CBitmap & Bitmap)
{
    Bitmap.GetHeight();        // 正确,没有问题
    Bitmap.SetHeight(100);   // 错误,Bitmap是const类型
}

值得注意的是,尽量把class的声明中,不改变属性的方法,声明为 const ,这就是所谓的良好的程序风格。

最后,如果在CBitmap里边有另外一个类,比如是CNormalMap,那么如果有个方法用来取得CNormalMap,code如下

class CBitmap {
.....
// 省略
Private: 
    CNormalMap NormalMap;
public: 
    CNormalMap GetNormalMap(void);
}

这是一种类做法,但是并没有充分的考虑效率。首先,返回的CNormalMap不是引用,这个是正确的做法,对象拷贝以后,即使改变内容,也不会影响 Class的状态。但是如果我们本来就不打算改变CNormalMap的状态呢?那么这个函数的调用效率就低下了,所以我们一般提供2个函数,代码如下:

class CBitmap {
.....
// 省略
Private: 
    CNormalMap NormalMap;
public: 
    CNormalMap GetNormalMap(void);
    const CNormalMap & GetStaticNormalMap(void);
}
或者利用C++的函数重载,做如下声明:
class CBitmap {
.....
// 省略
Private: 
    CNormalMap NormalMap;
public: 
    CNormalMap GetNormalMap(void);
    const CNormalMap & GetNormalMap(void) const;
}

如果我们不打算改变NormalMap的状态,那么就掉用GetStaticNormalMap() 或者 GetNormalMap() 的const调用,这样我们可以充分的利用reference的效率。

===============================================
C+ +真是内容多呀,一个const和reference就讲了一大堆。好了, 继续今天Design Pattern的内容。所谓 Design Pattern,翻译过来就是设计模式,是OO语言的一些基本运用。Aear会讲一些Design Pattern,并且给出在游戏中的可能的运用方式。今天第一课将会介绍Design Pattern中的两个基本概念,Inheritance 和 Delegation.

所谓Inheritance就是继承,我想学过C++的人都知道什么是继承。以上面的CBitmap为例子,如果我们想生成一个CTexture类,并且保留CBitmap的功能,比如GetBitmapHeight什么的,可以这么做:

class CTexture : public CBitmap {
public:
    CTexture();
    ~CTexture();
};

当时还有另外一种方法,并不使用继承,而是把CBitmap当做CTexture的一个成员,这就是Delegation。代码如下:

class CTexture {
public:
    CTexture();
    ~CTexture();
private:
    CBitmap InternalBitmap;
public:
    UINT32 GetHeight(void) {   return InternalBitmap.GetBitmapHeight();  };    
};

关于Inheritance和Delegation哪个更好,Aear不想在这里说,因为网上已经有太多的关于这个争论的文章。但是Aear的个人观点是能用Delegation的地方,就不要使用Inheritance。道理很简单,不同class层次的函数调用,很容易使程序员产生混乱。

举个简单的例子: 比如CTexture从CBitmap继承了GetBitmapHeight 方法,但是CTexture又提供了Bitmap的缩小功能,或者是mipmap,所以提供了一个函数 GetTextureHeight()。 只有GetTextureHeight能返回正确的 texture size的内容。 然后一个不明就里的程序员使用这个类,他发现了GetBitmapHeight这个函数,想当然的觉得是这个函数是用来取得texture的大小,那么。。。。。一切都错乱了。

所以在尽可能的情况下使用Delegation,在其他情况,比如一些Design Pattern和Interface的时候,使用Inheritance (纯个人观点).

 

重载、覆盖、多态与函数隐藏

例8-2

#include <iostream>

using namespace std;

 

class Base{

public:

         virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }

};

 

class Derive : public Base{

public:

         void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }

         void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }        

};

 

int main()

{

         Base *pb = new Derive();

         pb->fun(1);//Derive::fun(int i)

         pb->fun((double)0.01);//Derive::fun(int i)

         delete pb;

         return 0;

}

 

 

9

#include <iostream>

using namespace std;

 

class Base{

public:

         virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }

};

class Derive : public Base{

public:

        void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }

        void fun(char c){ cout <<"Derive::fun(char c)"<< endl; } 

        void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }        

};

int main()

{

         Base *pb = new Derive();

         pb->fun(1);//Derive::fun(int i)

         pb->fun('a');//Derive::fun(int i)

         pb->fun((double)0.01);//Derive::fun(int i)

 

         Derive *pd =new Derive();

         pd->fun(1);//Derive::fun(int i)

         //overload

         pd->fun('a');//Derive::fun(char c)         

         //overload

         pd->fun(0.01);//Derive::fun(double d)         

 

         delete pb;

         delete pd;

         return 0;

}

 

7-1和例8-1很好理解,我把这两个例子放在这里,是让大家作一个比较摆了,也是为了帮助大家更好的理解:本例的效果同例6,异曲同工。想必你理解了上面的这些例子后,这个也是小Kiss了。

n          7-1中,派生类没有覆盖基类的虚函数,此时派生类的vtable中的函数指针指向的地址就是基类的虚函数地址。

n          8-1中,派生类覆盖了基类的虚函数,此时派生类的vtable中的函数指针指向的地址就是派生类自己的重写的虚函数地址。

在例7-28-2看起来有点怪怪,其实,你按照上面的原则对比一下,答案也是明朗的:

n          7-2中,我们为派生类重载了一个函数版本:void fun(double d)  其实,这只是一个障眼法。我们具体来分析一下,基类共有几个函数,派生类共有几个函数:

类型

基类

派生类

Vtable部分

void fun(int i)

指向基类版的虚函数void fun(int i)

静态部分

 

void fun(double d)

 

我们再来分析一下以下三句代码

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

pb->fun((double)0.01);//Base::fun(int i)

 

这第一句是关键,基类指针指向派生类的对象,我们知道这是多态调用;接下来第二句,运行时基类指针根据运行时对象的类型,发现是派生类对象,所以首先到派生类的vtable中去查找派生类的虚函数版本,发现派生类没有覆盖基类的虚函数,派生类的vtable只是作了一个指向基类虚函数地址的一个指向,所以理所当然地去调用基类版本的虚函数。最后一句,程序运行仍然埋头去找派生类的vtable,发现根本没有这个版本的虚函数,只好回头调用自己的仅有一个虚函数。

 

这里还值得一提的是:如果此时基类有多个虚函数,此时程序编绎时会提示调用不明确。示例如下

#include <iostream>

using namespace std;

 

class Base{

public:

         virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }

                    virtual void fun(char c){ cout <<"Base::fun(char c)"<< endl; }

};

 

class Derive : public Base{

public:

    void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } 

};

 

int main()

{

         Base *pb = new Derive();

                    pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function

         delete pb;

         return 0;

}

好了,我们再来分析一下例8-2

n          例8-2中,我们也为派生类重载了一个函数版本:void fun(double d)  ,同时覆盖了基类的虚函数,我们再来具体来分析一下,基类共有几个函数,派生类共有几个函数:

类型

基类

派生类

Vtable部分

void fun(int i)

void fun(int i)

静态部分

 

void fun(double d)

 

从表中我们可以看到,派生类的vtable中函数指针指向的是自己的重写的虚函数地址。

 

我们再来分析一下以下三句代码

 

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun((double)0.01);//Derive::fun(int i)

 

第一句不必多说了,第二句,理所当然调用派生类的虚函数版本,第三句,嘿,感觉又怪怪的,其实呀,C++程序很笨的了,在运行时,埋头闯进派生类的vtable表中,只眼一看,靠,竞然没有想要的版本,真是想不通,基类指针为什么不四处转转再找找呢?呵呵,原来是眼力有限,基类年纪这么老了,想必肯定是老花了,它那双眼睛看得到的仅是自己的非Vtable部分(即静态部分)和自己要管理的Vtable部分,派生类的void fun(double d)那么远,看不到呀!再说了,派生类什么都要管,难道派生类没有自己的一点权力吗?哎,不吵了,各自管自己的吧^_^

 

!你是不是要叹气了,基类指针能进行多态调用,但是始终不能进行派生类的重载调用啊(参考例6)~~~

 

再来看看例9,

 

(篇幅所限,未完,待续)

 

 原文地址 http://blog.csdn.net/callzjy/archive/2004/01/04/20042.aspx

 

你可能感兴趣的:(C++,buffer,iostream,inheritance,reference,fun)