Effective C++笔记——31文件编译依存关系

C++

---

降低依存关系

• 依赖于声明式，而非定义式，尽量用class声明替代class定义。

#include <string>
#include <memory>       //STL不应当用于前置声明。此声明用于智能指针
class PersonImpl;       //Person的实现类的前置声明
class Date;
class Address;
class Person{
    public:
        Person(const std::string& name, const Date& birthday, const Address& addr);
        std::string name() const;
        std::string birtyday() const;
        std::string address() const;
        ...
    private:
        std::tr1::shared_ptr<PersonImpl> pImpl; //智能指针指向实现物

• 如果使用对象的引用或者指针可以完成任务，就不要使用对象本身。
• 为声明式和定义式提供不同的头文件：为促进严守上述准则，需要定义两个头文件：一个用于声明式，一个用于定义式。如下：

#include "datefwd.h"    //该头文件内声明但未定义Date类，这样就不需要做前置声明了
Date today();
void clearAppointments(Date d);

• 前置声明标准库并没有必要，直接包含这些文件并不会造成太大的编译依赖性问题。

//string是个typedef:basic_string<char>，该前置声明并不正确，事实上对STL中的类做前置声明也没有必    要，直接包含就可以了
namespace std{
    class string;                                
}
class Date;
class Address;
class Person{
...
};

---

实现方式

Handle classes（pimpl idiom，转交给相应的实现类，入PersonImpl类）

//////////////////////////////////////////////////////////////////
//person.h
#include <string> 
#include <memory> 
class PersonImpl; 
class Person{ 
public: 
    Person(const std::string& name, const std::string& birthday,const std::string& addr); 
    std::string getname()const; 
    std::string birthDate() const; 
    std::string address()const; 
private: 
    std::tr1::shared_ptr<PersonImpl> pImpl; //指向实现物的指针 
};
////////////////////////////////////////////////////////////
//person.cpp
#include "stdafx.h"
#include "Person.h"
#include "PersonImpl.h"
Person::Person(const std::string& name, const std::string& birthday,const std::string& addr)
:pImpl(new PersonImpl(name,birthday,addr))
{}
std::string Person::getname() const
{
    return pImpl->getname();
}
std::string Person::birthDate() const
{
    return pImpl->birthDate();
}
std::string Person::address()const
{
    return pImpl->address();
}
///////////////////////////////////////////////////////////////
//personImpl.h
#include <string> 
class PersonImpl{
public:
    PersonImpl(const std::string& name, const std::string& birthday, const std::string& addr)
    :mName(name),mBirthday(birthday),mAddr(addr){}
    std::string getname()const; 
    std::string birthDate() const; 
    std::string address()const; 
private:
    std::string mName;
    std::string mBirthday;
    std::string mAddr;
};
////////////////////////////////////////////////////////////////////
//personImpl.cpp
#include "stdafx.h"
#include "PersonImpl.h"
std::string PersonImpl::getname() const
{
    return mName;
}
std::string PersonImpl::birthDate() const
{
    return mBirthday;
}
std::string PersonImpl::address()const
{
    return mAddr;
}
//main.cpp
#include "stdafx.h"
#include "person.h"
int _tmain(int argc, _TCHAR* argv[])
{
    std::string lname = "name";
    std::string lDate = "1990";
    std::string lAddr = "beijing";
    class Person lper(lname,lDate,lAddr);
    return 0;
}

abstract base class（interface class）

抽象基类，即接口类，这种类的目的是描述派生类的接口，通常不含有成员变量，也没有构造函数，只有一个虚析构函数以及一组纯虚函数，用来描述整个接口。可以将Person类写成这种接口类：

class Person{
    public:
        virtual ~Person();
        virtual std::string name() const = 0;
        virtual std::string birtyday() const = 0;
        virtual std::string address() const = 0;
        ...
        static std::tr1::shared_ptr<Person> create(const std::string& name, const Date& birthday, const Address& addr);     //返回指针指向一个动态分配的Person“对象”,避免忘记delete
};

除非接口类的接口被修改，否则不需要重新编译。使用接口类时用引用或指针编写程序，通常的手段是使用工厂函数或虚构造函数，返回指向该类型的指针（或更为可取的智能指针）。

std::tr1::shared_ptr<Person> pp(Person::create(name, dateOfBirth, address));        //创建对象。注意静态函数的用法

完整例子：

 class  AClass: public  AClassFactory {
 public :
   AClass()  {} 
    void  interface_1();
   std:: string  interface_2();
    virtual   ~ AClass();
 // .. 
 } 
 class  AClassFactory {
 public :
    virtual   void  interface_1()  =   0 ;
    virtual  std:: string  interface_2()  =   0 ;
    // .. 
     virtual   ~ AClassFactory() { /* .. */ } 
     static  std::tr1::shared_ptr < AClassFactory >  Produce( /* .. */ )
    {
       // this factory function could be more complicated in practice.. 
        return  std::tr1::shared_ptr < AClassFactory > ( new  AClass);
   } 
 // .. 
 } 
 // AClassFactory could be used in this way.. 
 std::tr1::shared_ptr < AClassFactory >  pAClassObject;
pAClassObject  =  AClassFactory::Produce( /* .. */ );
 // pAClassObject->..

摘抄自：
http://blog.csdn.net/banguijun/article/details/7880485
http://www.cppblog.com/note-of-justin/archive/2012/10/02/105784.html
http://m.blog.csdn.net/blog/liyun123gx/25979259