接口需求
在软件开发这个行业中，一个较大的软件项目，一般由几个小组共同开发完成，为了将小组之间的影响降低到最低，定义好接口势在必行，如若要求短时间开发完成，定义好接口更是如此。或者说你的客户要求为其提供实现某个功能的接口，然后再在这些接口的基础上进行二次开发，如何定义才能定义好的接口呢? 第一，接口名字和实际的功能相符合；第二、接口要对数据进行封装，不允许客户直接操作接口之下的数据，尤其是使用new和delete在堆上操作内存数据。因为客户很容易由于操作不当造成错误，误以为是设计的接口有问题。
接口与实现分离
c++中实现对接口与实现进行分离有两种方法，一种是将对象的实现细目隐藏于指针背后，简单的说就是将其分成两个类，一个类只提供接口，另一个负责实现该接口，这种设计手法常称为Pimpl Idiom(pointer to implementation)。
另一种方法就是将接口定义为抽象类，接口全被定义为纯虚函数（纯虚函数没有具体的实现方法），派生类的成员函数负责实现这些接口。这种设计手法称为Object Interface。千万不要忘记把抽象接口类的析构函数定义为virtual函数，可能会造成内存泄漏。
Pimpl Idiom手法
下面举个简单的例子，要求实现一个Person接口，其要包含如下四个函数：
string& getName() const;
void setName(string& name);
int getAge() const;
void setAge(int age);
它们的功能是设置获取名字和年龄。其声明在Person.h文件中，具体接口如下：
#include<string>
class PersonImpl;
using namespace std;
class Person {
public:
Person(string& name, int age);
virtual ~Person();
string& getName() const;
void setName(string& name);
int getAge() const;
void setAge(int age);
private:
PersonImpl *mPersonImpl;
};
Person.cpp文件中定义了具体函数接口，其内容如下：
#include "Person.h"
#include "PersonImpl.h"
Person::Person(string& name, int age):
mPersonImpl(new PersonImpl(name, age))
{
std::cout << "construct Person" << std::endl;
}
Person::~Person()
{
delete mPersonImpl;
std::cout << "deconstruct Person" << std::endl;
}
string& Person::getName() const
{
return mPersonImpl->getName();
}
void Person::setName(string& name)
{
mPersonImpl->setName(name);
}
int Person::getAge() const
{
return mPersonImpl->getAge();
}
void Person::setAge(int age)
{
mPersonImpl->setAge(age);
}PersonImpl.h声明了实现接口背后所需细目的函数接口，其内容如下：
#include<string>
#include <iostream>
using namespace std;
class PersonImpl
{
public:
PersonImpl(string& name, int age);
virtual ~PersonImpl();
string& getName() const;
void setName(string& name);
int getAge() const;
void setAge(int age);
private:
string& mName;
int mAge;
};PersonImpl.cpp中负责实现这些接口背后的细目函数，其内容如下：
PersonImpl::PersonImpl(string& name, int age):mName(name),mAge(age)
{
}
PersonImpl::~PersonImpl()
{
}
string& PersonImpl::getName() const
{
return mName;
}
void PersonImpl::setName(string& name)
{
mName = name;
}
int PersonImpl::getAge() const
{
return mAge;
}
void PersonImpl::setAge(int age)
{
mAge = age;
}从上面的例子中可以发现，在对外提供的接口函数中，只包含操作背后细目数据的接口方法，致使客户无法直接操作接口背后的细目数据，因此最大限度地降低了客户错误使用的可能性。
Object Interface手法
同样我们参照上面那个例子，要求实现一个Animal接口，其由如下四个接口组成：
string& getName() const;
void setName(string& name);
int getAge() const;
void setAge(int age);
它们的功能也是设置和获取名字和年龄，不同的是类不一样罢了，其声明在Animal.h文件中，具体接口如下：
#include <string>
using namespace std;
class Animal
{
public:
Animal(){};
virtual ~Animal(){};
virtual string& getName() const = 0;
virtual void setName(string& name) = 0;
virtual int getAge() const = 0;
virtual void setAge(int age) = 0;
};
Animal* creat(string& name, int age);真正实现Animal类声明的接口函数，声明在RealAnimal.h中，具体细节如下：
#include "Animal.h"
class RealAnimal: public Animal
{
public:
RealAnimal(string& name, int age);
virtual ~RealAnimal();
string& getName() const;
void setName(string& name);
int getAge() const;
void setAge(int age);
private:
friend Animal* creat(string& name, int age);
private:
string& mName;
int mAge;
};在RealAnimal类中，除了继承的接口函数的声明之外，还多了一个友元函数，其有点类似于工厂函数，其作用就是实例化一个对象。下面看一下接口真正的实现细节，具体如下：
#include "RealAnimal.h"
RealAnimal::RealAnimal(string& name, int age):mName(name),mAge(age)
{
}
RealAnimal::~RealAnimal()
{
}
string& RealAnimal::getName() const
{
return mName;
}
void RealAnimal::setName(string& name)
{
mName = name;
}
int RealAnimal::getAge() const
{
return mAge;
}
void RealAnimal::setAge(int age)
{
mAge = age;
}
Animal* creat(string& name, int age)
{
return new RealAnimal(name, age);
}如前面所说，Animal* creat(string& name, int age)确实只是实例化一个RealAnimal对象，返回的却是Animal接口对象，所以必须将类Animal 的析构函数声明为虚函数，不然会造成内存泄漏。
总结
无论是Impl Idiom手法，还是Object Interface手法都实现了同样的接口，而且它们有一个共同的目的，降低用户（被提供接口的小组也称为客户）直接操作数据造成不必要错误的可能性。其实它们有一个重要的优点就是将模块的依赖性降到了最低，举个例子吧，假如客户在使用这些接口的时候，如果这些接口内部的实现细目变更了，客户也不需要再重新编译自己的代码，因为客户只依赖接口声明的头文件。如果客户依赖接口的代码量非常大，那么，这个时候，这样定义接口就非常有必要了，毕竟客户在不修改自己代码的前提下，不需要重新编译自己的代码，这样可以提高客户的效率。
其实，这样来设计接口还是有缺点的，虽然接口定义在一个类中，但是真正实例化接口类的过程中，编译器会自动替我们生成必需的成员函数（比如构造函数、拷贝构造函数等），显然Animal也不例外。虽然有这样的缺点，但还是瑕不掩瑜。
