C++ 类的前置声明

时间:2023-03-08 16:22:44
http://www.2cto.com/kf/201311/260705.html
 
 今天在研究C++”接口与实现分离“的时候遇到了一个问题,看似很小,然后背后的东西确值得让人深思!感觉在学习的过程中有太多的为什么,而每一个为什么背后都隐藏着一些原理和目的,所以得多问自己”为什么“,这样才不仅知其然,更知其所以然,才能举一反三、融会贯通,这也是我以前学习不够重视的一个问题,好在”亡羊补牢,犹未晚也!“。
        C++中将”接口与实现分离“的两个重要目的就是”降低文件间的编译依存关系“和”隐藏对象的实现细节“,都是考虑到C++的高效和安全。而实现这一目的的关键技术就是”Pimpl模式(pointer to implementation)”,也即是”把一个类所有的实现细节都“代理”给另一个类来完成,而自己只负责提供接口“,而实现”Pimpl模式”的关键又是“依赖对象的声明(declaration)而非定义(definition)”,这样就引出了今天的话题:为什么通过“依赖对象的声明”可以实现Pimpl模式“,进而实现”接口与实现分离“?我们一步步来抽丝剥茧吧!
什么是“前置声明”?
        ”前置声明“和”include“就是一对冤家!我们先看一个例子:
[cpp]  
// A.h  
#include "B.h"  
class A  
{  
public:  
    A(void);  
    virtual ~A(void);  
private:  
    B b;  
};  
// B.h  
#include "A.h"  
class B  
{  
private:  
    A a;  
public:  
    B(void);  
    ~B(void);  
};  
        一编译,就出现了一个互包含的问题了,A中有B类型的成员变量所以需要include<b.h>,而B中又有A类型的成员变量也需要include<a.h>,这就导致了循环include,编译是肯定通过不了的!
        解决办法就是使用”前置声明“,在A.h中加上class B的声明:
[cpp] 
// A.h  
#include "B.h"  
class B;  
class A  
{  
public:  
    A(void);  
    virtual ~A(void);  
private:  
    B b;  
};  
// B.h  
#include "A.h"  
class B  
{  
private:  
    A a;  
public:  
    B(void);  
    ~B(void);  
};  
        但是,有人知道问题是为什么就被解决的吗,也就是说,加了个前置声明为什么就解决了这样的问题。下面,让我来探讨一下这个前置声明。
        前置声明是什么?举个形象点的例子,就是我要盖一个屋子(CHOuse),光有屋子还不行啊,我还得有床(CBed)。但是屋子还没盖好,总不能先买床吧,床的大小我定了,改天买。先得把房子盖好,盖房子的时候我先给床留个位置,等房子盖好了,我再决定买什么样的床。前置声明就是我在声明一个类(CHouse)的时候,用到了另外一个类的定义(CBed),但是CBed还没有定义呢,而且我还先不需要CBed的定义,只要知道CBed是一个类就够了。那好,我就先声明类CBed,告诉编译器CBed是一个类(不用包含CBed的头文件):
        class CBed;
        然后在CHouse中用到CBed的,都用CBed的指针类型代(因为指针类型固定大小的,但是CBed的大小只用知道了CBed定义才能确定)。等到要实现CHouse定义的时候,就必须要知道CBed的定义了,那是再包好CBed的头文件就行了。
[cpp] 
// House.h  
class CBed; // 盖房子时:现在先不买,肯定要买床的  
class CHouse  
{  
    CBed& bed; // 我先给床留个位置  
    // CBed bed; // 编译出错  
public:  
    CHouse(void);  
    CHouse(CBed& bedTmp);  
    virtual ~CHouse(void);  
    void GoToBed();  
};  
// House.cpp  
#include "Bed.h"  
#include "House.h" // 等房子开始装修了,要买床了  
CHouse::CHouse(void)  
    : bed(*new CBed())  
{  
    CBed* bedTmp = new CBed(); // 把床放进房子  
    bed = *bedTmp;  
}  
CHouse::CHouse(CBed& bedTmp)  
    : bed(bedTmp)  
{  
}  
CHouse::~CHouse(void)  
{  
    delete &bed;  
}  
void CHouse::GoToBed()  
{  
    bed.Sleep();  
}  
“前置声明”的作用?
        “前置声明”的作用有2:
        (1)解决两个class的相互依赖问题,也就是两个文件相互include,减少头文件的包含层次。比如以上的几个例子!
        (2)降低文件之间的“编译依存关系”,从第一个例子我们看到,当我们在类A使用类B的前置声明时,我们修改类B时,只需要重新编译类B,而不需要重新编译a.h的(当然,在真正使用类B时,必须包含b.h)。如果使用include的话,一个文件改变,所有include这个文件的文件都得重新编译,这是非常耗时的!
        (3)通过“前置声明”可以实现“接口与实现分离“。我们将需要提供给客户的类分割为两个classes:一个只提供接口,另一个负责实现!例如以下实例:
[cpp]  
//XYZ.h  
class X{  
public:  
    X();  
    void Print();  
};  
class Y{  
public:  
    Y();  
    void Print();  
};  
class Z{  
public:  
    Z();  
    void Print();  
};  
//XYZ.cpp  
#include "stdafx.h"  
#include "XYZ.h"  
#include <iostream>  
X::X(){}  
void X::Print(){  
    std::cout<<"X::Print"<<std::endl;  
}  
Y::Y(){}  
void Y::Print(){  
    std::cout<<"Y::Print"<<std::endl;  
}  
Z::Z(){}  
void Z::Print(){  
    std::cout<<"Z::Print"<<std::endl;  
}  
// AImpl.h  
#include "stdafx.h"  
#include "XYZ.h"  
class AImpl    
{    
public:    
    AImpl();  
    ~AImpl();  
    X* getX();    
    Y* getY();    
    Z* getZ();    
    void doSth();  
private:    
    X* x;    
    Y* y;    
    Z* z;    
};   
//AImpl.cpp  
#include "stdafx.h"  
#include "Aimpl.h"  
#include <iostream>  
AImpl::AImpl(){  
    x = new X();  
    y = new Y();  
    z = new Z();  
}  
AImpl::~AImpl(){  
    if (x)  
    {  
        delete x;  
    }  
    if (y)  
    {  
        delete y;  
    }  
    if (z)  
    {  
        delete z;  
    }  
}  
X* AImpl::getX(){  
    return x;  
}  
Y* AImpl::getY(){  
    return y;  
}  
Z* AImpl::getZ(){  
    return z;  
}  
void AImpl::doSth(){  
    x->Print();  
    y->Print();  
    z->Print();  
}  
// A.h    
#include "stdafx.h"  
#include <memory>  
class AImpl;    
class X;  
class Y;  
class Z;  
class A    
{    
public:    
    A();  
    X* getX();  
    Y* getY();  
    Z* getZ();     
    void doSth();  
private:    
    std::shared_ptr<AImpl> pImpl;    
};   
//A.cpp  
#include "stdafx.h"  
#include "A.h"  
#include "Aimpl.h"  
A::A(){  
    pImpl = std::shared_ptr<AImpl>(new AImpl());  
}  
X* A::getX(){  
    return pImpl->getX();  
}  
Y* A::getY(){  
    return pImpl->getY();  
}  
Z* A::getZ(){  
    return pImpl->getZ();  
}  
void A::doSth(){  
    pImpl->doSth();  
}  
//PreDeclaration.cpp  
#include "stdafx.h"  
#include "A.h"  
int main()  
{  
    A a;  
    a.doSth();  
    return 0;  
}  
        在这个例子中,A.h是提供给客户使用的头文件,在该文件中定义了class A,其中只含有一个指针成员(pImpl),指向其实现类(AImpl)。在这样的设计之下,使用class A的客户端就完全与X、Y、Z以及AImpl的实现细节分离了,同时实现了“实现细节”的隐藏,这样,无论这些classes的任何实现修改都不需要A的客户端重新编译。
使用“前置声明”的注意事项
        (1)在前置声明时,我们只能使用的就是类的指针和引用,自然也就不能调用对象的方法了!
          像我们这样前置声明类A:
          class A;
          是一种不完整的声明,只要类B中没有执行"需要了解类A的大小或者成员"的操作,则这样的不完整声明允许声明指向A的指针和引用。
          而在前一个代码中的语句
          A a;
          是需要了解A的大小的,不然是不可能知道如果给类B分配内存大小的,因此不完整的前置声明就不行,必须要包含A.h来获得类A的大小,同时也要重新编译类B。
          再回到前面的问题,使用前置声明只允许的声明是指针或引用的一个原因是:只要这个声明没有执行“需要了解类A的大小或者成员”的操作就可以了,所以声明成指针或引用是没有“执行需要了解类A的大小或者成员的操作”的。
          我们将上面这个例子的A.cpp稍作修改:
[cpp]  
//A.cpp  
#include "stdafx.h"  
#include "A.h"  
#include "Aimpl.h"  
A::A(){  
    pImpl = std::shared_ptr<AImpl>(new AImpl());  
}  
X* A::getX(){  
    return pImpl->getX();  
}  
Y* A::getY(){  
    return pImpl->getY();  
}  
Z* A::getZ(){  
    return pImpl->getZ();  
}  
void A::doSth(){  
    //pImpl->doSth();  
    getX()->Print();  
    getY()->Print();  
    getZ()->Print();  
}