从实现装饰者模式中思考C++指针和引用的选择

从实现装饰者模式中思考C++指针和引用的选择

 

最近在看设计模式的内容,偶然间手痒就写了一个“装饰者”模式的一个实例。该实例来源于风雪涟漪博客,我对它做了简化。作为一个经典的设计模式,本身并没有太多要说的内容。但是在我尝试使用C++去实现这个模式的实例的时候,出现了一些看似无关紧要但是却引人深思的问题。

首先,我想简单介绍一下这个实例的含义。实例的目的是希望通过装饰器类对已有的蛋糕类进行装饰补充,于是按照装饰者模式的设计结构,有类似图1的设计结构。

1 装饰者模式

蛋糕类和装饰器类都继承于一个公共的基类,该基类声明了一些公共接口。这里简单的使用getName来返回当前蛋糕的名称,而装饰器类可以对该蛋糕的名称进行修改补充。具体的蛋糕类都有自己的名称,比如CheeseCake返回的是“奶油蛋糕”。如果使用了装饰器类对该类进行装饰的话,返回的名字就发生了的变化,比如“装饰了花的奶油蛋糕”,这正是装饰器类的功能。实现这个功能的关键在于装饰器公共基类Decorator,它包含了一个Cake类型的成员cake。在定义装饰器的时候我们可以传递给装饰器一个已经建立好的蛋糕对象,比如CheeseCake对象。由于CheeseCakeCake的子类,因此该对象可以被cake成员记录下来。由于具体的装饰器继承于装饰器基类Decorator,因此保护乘员cake可以被看到,又因为装饰器本身也是继承与Cake的,因此也拥有getName的接口,这样在装饰器类内用getName调用cakegetName接口并添加额外的操作就能完成装饰的目的。另外,装饰器本身也是Cake的子类,因此装饰后的装饰器类对象同时也是一个具体的蛋糕对象,它可以被再次装饰!这样装饰器类反映在我们脑海里的情境就是一个原本的蛋糕对象外边包裹了一层层装饰器对象。

以上的说明如果还不够清楚的话,下边展示具体的实现代码。这里就需要考虑cake成员的类型问题,一般使用指针类型可能更符合C++的编程习惯。因为使用对象不仅消耗空间,还在每次构造对象的时候进行对象的复制,这都不是我们愿意看到的。当然,使用引用或许更合理,因为按照平常的经验,很多使用C++指针的地方都可以用引用代替,有人甚至建议多使用引用少使用指针(当然我也承认C++引用也有很多好处~。不过,当你读完本文或许你就不大这么认为了。首先,我们用Cake*pCake实现这个装饰器类内的成员,先具体了解一下这个代码的具体内容

#pragma once
#include <iostream>
using namespace std;
//Cake公共基类,提供装饰者和被装饰物的统一接口
class Cake
{
public:
    virtual string getName()const=0;
};

//一个具体的蛋糕
class CheeseCake:public Cake
{
public:
    virtual string getName()const
    {
        return string("奶油蛋糕");
    }
};

//一个装饰者基类
class Decorator:public Cake
{
protected:
    Cake *pCake;
public:
    Decorator(Cake*pc):pCake(pc){}
};

//一个具体的装饰器
class FlowerDecorator:public Decorator
{
public:
    FlowerDecorator(Cake*pc):Decorator(pc){}
    virtual string getName()const
    {
        string decName="装饰过花的";
        decName+=pCake->getName();
        return decName;
    }
};
int main()
{
    cout<<
        FlowerDecorator(
            &FlowerDecorator(
                &CheeseCake()
        ))
        .getName().c_str()
        <<endl;
    return 0;
}

代码中不难看出程序的输出结构应该是“装饰过花的装饰过花的奶油蛋糕”,事实也的确如此!从装饰器的使用格式来看FlowerDecorator(&FlowerDecorator(&CheeseCake()))倒也不至于十分麻烦。但是刚才讨论过,如果能使用引用代替会许会更“舒服”,至少不用传递参数之前还要使用&获取一下地址了~

既然如此,我们把成员修改为引用格式的:

#pragma once
#include <iostream>
using namespace std;
//Cake公共基类,提供装饰者和被装饰物的统一接口
class Cake
{
public:
    virtual string getName()const=0;
};

//一个具体的蛋糕
class CheeseCake:public Cake
{
public:
    virtual string getName()const
    {
        return string("奶油蛋糕");
    }
};

//一个装饰者基类
class Decorator:public Cake
{
protected:
    Cake &pCake;
public:
    Decorator(Cake&pc):pCake(pc){}
};

//一个具体的装饰器
class FlowerDecorator:public Decorator
{
public:
    FlowerDecorator(Cake&pc):Decorator(pc){}
    virtual string getName()const
    {
        string decName="装饰过花的";
        decName+=pCake.getName();
        return decName;
    }
};
int main()
{
    cout<<
        FlowerDecorator(
            FlowerDecorator(
                CheeseCake()
        ))
        .getName().c_str()
        <<endl;
    return 0;
}

修改后的代码看起来的确更“顺眼了”。因为调用的时候我们不用再写那个看着别扭的取地址运算符了,然后我们满怀欣喜的执行了程序,输出结果为:“装饰过花的奶油蛋糕”!你我的第一反应八成是觉得忘了多修饰一次了,但是我们认真的检查代码,发现的确一切都是符合逻辑的……

上边做了这么多铺垫就是为了引出这个奇怪的问题,我其实也被该问题困惑了很久。稍有编程经验的人都会跟踪调试这些构造函数的执行过程,结果发现FlowerDecorator只被执行了一次,因此少输出一次“装饰过花的”不足为奇。但是你我肯定好奇为什么会少输出一次呢?

再次再次的检查代码、调试、跟踪,或许你会像发现新大陆一样发现了一个隐藏的问题:第二次构造FlowerDecorator调用的是复制构造函数,而不是定义好的构造函数(虽然子类FlowerDecoratorCake的子类,但是编译器会自动最佳匹配函数参数类型)!由于复制构造函数值原模原样的拷贝出一个对象,所以只能完成一次装饰器装饰。非常完美的解释!因此我们可以自己重写复制构造函数来完成我们的装饰功能,这里先忽略原本的对象复制功能了。编译器为我们生成的复制构造函数应该是:

FlowerDecorator(const FlowerDecorator&pc):Decorator(pc.pCake){}

而我们应该将参数看作一个Cake对象进行装饰,因此修改为:

FlowerDecorator(const FlowerDecorator&pc):Decorator(const_cast<FlowerDecorator&>(pc)){}

同样,由于构造函数初始化了基类,所以基类的复制构造也需要重写:

Decorator(const Decorator&pc):pCake(const_cast<Decorator&>(pc)){}

即使传递的参数是FlowerDecorator对象和CakeDecorator不是一个类型,但是编译器或许认的匹配继承层次最近的类型!然后我们按照这样要求重写了代码,执行了程序,在期待结果的那一刻看到的是“装饰过花的奶油蛋糕”……或许此时的你都会感到灰心,但是你还是依然的坚强的按下了F5单步跟踪,结果你发现拷贝构造函数并没有被调用!难道以上的假设都错了吗?我可以确定的告诉读者,我们以上的假设都是正确的。

最终我也是没有办法,去StackOverFlow上求助,综合回答者的讨论,我终于把问题的原因锁定了——编译器优化!我觉得用一个最简单的例子来说明这个问题再合适不过了:

class A
{
public:
    A(int)
    {
        cout<<"构造\n";
    }
    A(const A&)
    {
        cout<<"拷贝\n";
    }
};

int main()
{
    A(0);
    cout<<"------------------------\n";
    A(A(0));
    cout<<"------------------------\n";
    A(A(A(0)));
    cout<<"------------------------\n";
    A(A(A(A(0))));
    cout<<"------------------------\n";
    A(A(A(A(A(0)))));
    cout<<"------------------------\n";
    return 0;
}

这个简单的例子结果或许大家都很明白,但是你亲自测试一下就可能要怀疑自己的判断能力了,程序输出

是不是有点世界被颠覆的感觉?需要声明一下,这个是Visual Studio 2010下的测试结果,因为这个程序的输出的确和编译器相关!为了确认我用gcc-4.4.3测试了该段代码输出结果为:

看来,还是gcc优化的比较彻底。因此我们可以得出结论,类似这种无名对象的构造(有名的是按照规矩来的),调用多少次构造函数要看编译器的“脾气”了。到这里,不知道你对引用参数的感觉如何?

讨论到这,或许有人说和本来要讨论的话题离得太远了。其实并不是,佛家说:“今日之果皆来自昨日之因”,一切的一切都是由于我们使用了本以为毫无悬念的引用导致的!如果使用指针就不可能发生和拷贝构造函数冲突的问题,也不会导致编译器优化的问题!回视本文刚开始举的例子和该文的主题,或许我们应该清楚有时候的确要好好区分一下指针和引用的差别了,当然本文也是从一个实践的例子中去发现和挖掘这一点。

原文地址:https://www.cnblogs.com/fanzhidongyzby/archive/2012/11/19/2777943.html

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐


对象的传值与返回说起函数,就不免要谈谈函数的参数和返回值。一般的,我们习惯把函数看作一个处理的封装(比如黑箱),而参数和返回值一般对应着处理过程的输入和输出。这种情况下,参数和返回值都是值类型的,也就是说,函数和它的调用者的信息交流方式是用过数据的拷贝来完成,即我们习惯上称呼的“值传递”。但是自从引
从实现装饰者模式中思考C++指针和引用的选择最近在看设计模式的内容,偶然间手痒就写了一个“装饰者”模式的一个实例。该实例来源于风雪涟漪的博客,我对它做了简化。作为一个经典的设计模式,本身并没有太多要说的内容。但是在我尝试使用C++去实现这个模式的实例的时候,出现了一些看似无关紧要但是却引人深思的问题
关于vtordisp知多少?我相信不少人看到这篇文章,多半是来自于对标题中“vtordisp”的好奇。其实这个关键词也是来源于我最近查看对象模型的时候偶然发现的。我是一个喜欢深究问题根源的人(有点牛角尖吧),所以当我第一次发现vtordisp的时候,我也是很自然的把它输进google查找相关资料,但
那些陌生的C++关键字学过程序语言的人相信对关键字并不陌生。偶然间翻起了《C++ Primer》这本书,书中列举了所有C++的关键字。我认真核对了一下,竟然发现有若干个从未使用过的关键字。一时间对一个学了六年C++的自己狠狠鄙视了一番,下决心一定要把它们搞明白!图1红色字体给出的是我个人感觉一般大家
命令行下的树形打印最近在处理代码分析问题时,需要将代码的作用域按照树形结构输出。问题的原型大概是下边这个样子的。图中给了一个简化的代码片段,该代码片段包含5个作用域:全局作用域0、函数fun作用域1、if语句作用域2、else语句作用域3和函数main作用域4。代码作用域有个显著的特点就是具有树形结
虚函数与虚继承寻踪封装、继承、多态是面向对象语言的三大特性,熟悉C++的人对此应该不会有太多异议。C语言提供的struct,顶多算得上对数据的简单封装,而C++的引入把struct“升级”为class,使得面向对象的概念更加强大。继承机制解决了对象复用的问题,然而多重继承又会产生成员冲突的问题,虚继
不要被C++“自动生成”所蒙骗C++对象可以使用两种方式进行创建:构造函数和复制构造函数。假如我们定义了类A,并使用它创建对象。Aa,b;Ac=a;Ad(b);对象a和b使用编译器提供的默认构造函数A::A()创建出来,我们称这种创建方式为对象的定义(包含声明的含义)。对象c和d则是使用已有的对象,
printf背后的故事 说起编程语言,C语言大家再熟悉不过。说起最简单的代码,Helloworld更是众所周知。一条简单的printf语句便可以完成这个简单的功能,可是printf背后到底做了什么事情呢?可能很多人不曾在意,也或许你比我还要好奇!那我们就聊聊printf背后的故事。 一、printf
定义 浮点数就是小数点位置不固定的数,也就是说与定点数不一样,浮点数的小数点后的小数位数可以是任意的,根据IEEE754-1985(也叫IEEE Standard for Binary Floating-Point Arithmetic)的定义,浮点数的类型有两种:单精度类型(用4字节存储)和双精度
在《从汇编看c++的引用和指针》一文中,虽然谈到了引用,但是只是为了将两者进行比较。这里将对引用做进一步的分析。1 引用的实现方式在介绍有关引用的c++书中,很多都说引用只是其引用变量的一个别名。我自己不是很喜欢这种解释,因为觉得这种解释会给人误解,好像引用和变量就是一回事,而且,书中也没有给出,为
今天写程序的时候,创建了一个结构体:struct BufferObj {char* buf;int bufLen;SOCKADDR_STORAGE addr;int addrLen;struct BufferObj* next;};该结构体有一个next指针,本意是这个指针初始的时候应该为NULL,
placement operator new是重载的operator new运算符,它允许我们将对象放到一个指定的内存中。下面来看c++源码:class X {private: int _x;public: X(int xx = 0) : _x(xx) {} ~X() {} void* operat
编码的目的,就是给抽象的字符赋予一个数值,好在计算机里面表示。常见的ASCII使用8bit给字符编码,但是实际只使用了7bit,最高位没有使用,因此,只能表示128个字符;ISO-8859-1(也叫Latin-1,或者直接8859)使用全8bit编码,可以看成是ASCII的超集,因为它的低128个字
在宏定义当中,常常可以看到宏的参数以及整个宏的定义都被小括号包围,就像下面的 MIN、MAX、ABS 宏一样: 上面的图截取自 iOS 的系统库,那为什么它们需要这些括号包围起来呢? 下面假如我们自定义了宏 ceil_div,代码如下: #define ceil_div(x, y) (x + y -
c++中,当继承结构中含有虚基类时,在构造对象时编译器会通过将一个标志位置1(表示调用虚基类构造函数),或者置0(表示不调用虚基类构造函数)来防止重复构造虚基类子对象。如下图菱形结构所示:当构造类Bottom对象时,Bottom构造函数里面的c++伪码如下(单考虑标志位,不考虑其他)://Botto
在C中,使用fopen打开文件有两种模式:一种是文本模式,一种是二进制模式。那这两种模式之间有什么区别,是不是使用文本模式打开的文件就只能使用文本函数比如fprintf来操作,而使用二进制打开的文件就只能使用二进制函数比如fwrite来操作呢? 答案是否定的。C里面之所以有文本模式和二进制模式,完全
尾数英文名叫mantissa,significand,coefficient,用于科学计数法中。科学计数法的表示方法为: Mantissa x Base^Exponent 举个例子,123.45用科学计数法可以表示为: 12345 x 10^(-2) 其中12345就是尾数Mantissa,10是基
定义宏时可以让宏接收可变参数,对于可变参数的定义,标准 C 和 GNU C(GNU 对 C的扩展)是不一样的。 标准 C 标准 C 对于可变参数的定义如下,使用...: #define eprintf(...) fprintf (stderr, __VA_ARGS__) 在宏定义中,__VA_ARG
宏分为两种,一种是 object-like 宏,比如: #define STR &quot;Hello, World!&quot; 另一种是 function-like 宏,比如: #define MIN(X, Y) ((X) &lt; (Y) ? (X) : (Y)) 对于 function-li
副作用(Side Effect) 在计算机当中,副作用指当调用一个函数时,这个函数除了返回一个值之外,还对主调函数产生了影响,比如修改了全局变量,修改了参数等等。 宏的重复副作用 对于求两个数中的最小数,常常可以定义一个宏 MIN,定义如下: #define MIN(X, Y) ((X) &lt;