c++ - 如何为现有代码库创建公共(public) API？

Question

我正在尝试为同样用 C++ 编写的私有(private)代码库创建一个公共(public) C++ API。我尝试按如下方式执行此操作:

• 为每个私有(private)类创建一个包装器 API 类。
• 有一个公共(public) API 基类，该基类有一个指向私有(private)类的指针。
• API 类实现不包含任何功能，只是将方法调用转发给它们的私有(private)对应项。

这似乎是一种合理的方法。然而，实际上它很快就会产生非常笨拙的代码。这是一个代表我遇到的问题的示例。

(编辑:代码也可以查看here)。

私有(private)API类(这里没问题)

namespace Core {


// Base class for all Core classes.
class CoreObject
{
public:
    virtual ~CoreObject();
};    

class Interface;
class Stream;    

class Server : public CoreObject
{
public:
    Interface * createInterface();

private:
    std::vector<Interface*> mInterfaces;

};    

class Interface : public CoreObject
{
public:
    void addStream(Stream * stream);

    const Stream * getStreamByIndex(std::size_t index) const;

    std::size_t streamCount() const;

private:
    std::vector<Stream*> mStreams;
};    

class Stream : public CoreObject
{
public:
    void start();

    void stop();

private:
    std::string mStats;
};


} // Core

公共(public) API 类声明(到目前为止还不错)

namespace Core {
class CoreObject;
}


namespace API {


class APIStream;
class APIInterface;    

// Base class for all API classes.
class APIObject
{
public:
    APIObject(Core::CoreObject * inCoreObject);

    virtual ~APIObject();

    Core::CoreObject * getCoreObject();

    const Core::CoreObject * getCoreObject() const;

    void setCoreObject(Core::CoreObject * inCoreObject);

private:
    Core::CoreObject * mCoreObject; 
};    

class APIServer : public APIObject
{
public:
    APIServer();

    APIInterface * createInterface();
};    

class APIInterface : public APIObject
{
public:
    APIInterface();

    void addStream(APIStream * stream);

    const APIStream * getStreamByIndex(std::size_t index) const;

    APIStream * getStreamByIndex(std::size_t index);

    std::size_t streamCount() const;
};    

class APIStream : public APIObject
{
public:
    APIStream();

    void start();

    void stop();
};

API实现(转换太多，一般比较笨拙)

#include "API.h"
#include "Core.h"


namespace API {


APIObject::APIObject(Core::CoreObject * inCoreObject) :
    mCoreObject(inCoreObject)
{
}

APIObject::~APIObject()
{
}

Core::CoreObject * APIObject::getCoreObject()
{
    return mCoreObject;
}


const Core::CoreObject * APIObject::getCoreObject() const
{
    return mCoreObject;
}


void APIObject::setCoreObject(Core::CoreObject * inCoreObject)
{
    mCoreObject = inCoreObject;
}


//
// APIServer
//
APIServer::APIServer() :
    APIObject(new Core::Server)
{
}    

APIInterface * APIServer::createInterface()
{
    Core::Server * coreServer = static_cast<Core::Server*>(getCoreObject());
    Core::Interface * coreInterface = coreServer->createInterface();
    APIInterface * result(new API::APIInterface);
    result->setCoreObject(coreInterface);
    return result;
}


//
// APIInterface
//
APIInterface::APIInterface() :
    APIObject(new Core::Interface)
{
}    

void APIInterface::addStream(APIStream * apiStream)
{
    Core::Stream * coreStream = static_cast<Core::Stream *>(apiStream->getCoreObject());
    Core::Interface * coreInterface = static_cast<Core::Interface*>(getCoreObject());
    coreInterface->addStream(coreStream);
}


//
// APIStream
//
const APIStream * APIInterface::getStreamByIndex(std::size_t index) const
{
    const Core::Interface * coreInterface = static_cast<const Core::Interface*>(getCoreObject());
    const Core::Stream * coreStream = coreInterface->getStreamByIndex(index);

    // Now how I get the the APIStream object?
    return 0;
}

std::size_t APIInterface::streamCount() const
{
    const Core::Interface * coreInterface = static_cast<const Core::Interface*>(getCoreObject());
    return coreInterface->streamCount();
}    

APIStream::APIStream() :
    APIObject(new Core::Stream)
{
}    

void APIStream::start()
{
    static_cast<Core::Stream*>(getCoreObject())->start();
}       

void APIStream::stop()
{
    static_cast<Core::Stream*>(getCoreObject())->stop();
}    

} // API

如您所见，实现看起来不太好。非常感谢您对这些问题的回答或见解:

• 我哪里出错了？
• 我应该怎么做？

更新

John Dibling 的建议似乎 确实很有效。正如您在 improved code 中看到的那样，所有的问题都解决得干干净净。

我明天仍然必须将此解决方案应用于实际代码。我很想看看它在那里的表现如何。

Answer 1

在做这种事情时，API 和实现对象之间或多或少是一对一的关系，我通常会使用静态 factory method。 ，并让实现类派生自 API 类。像这样:

文件:api.h

class Interface
{
public:
  static Interface* Create();
  virtual void Foo() = 0;
};

文件:impl.h

class Concrete : public Interface
{
public:
  void Foo() {};
};

文件:impl.cpp

Interface* Interface::Create()
{
  return new Concrete;
}

这有很多好处。包括:

1. Create 可以构建很多不同的实现，Interface 的 ABI 不需要改变。
2. 返回类型依赖于语言的协变规则，因此不需要转换。
3. 调试稍微容易一些，因为您可以准确判断您拥有的是哪种Interface。