如何防止未定义引用我的API内部功能

如何解决如何防止未定义引用我的API内部功能

我创建了一个C ++模块，该模块具有一个API部分和一个内部部分。该API包含一长串（超过30个）多态类，这些多态类直接或间接从同一基类继承。在我的内部类/函数中，这些类的用法不同，因此我将某些功能移到了这些类中以进行政治使用。这些功能依赖于某些内部资源，而内部功能则取决于这些类，因此我通过在.h文件中声明必要的类并将其包括在.cpp文件中来打破了这种循环依赖。这样，我的模块可以编译并完美运行。

问题来了。当我从另一个模块中包含API时，会在API类策略化函数中得到内部函数的“未定义引用....”错误。我认为这是由于前瞻性声明。这些内部类在使用API​​的第二个模块中从未定义过。

我的模块大致如下：

InternalClass.h：

class ApiObjBase;
class InternalClass {
public:
  static InternalClass& get(); // singleton

  void processApiObjBase(ApiObjBase& apiObj);

  static const Resource& getResource1();
  static const Resource& getResource2();
  static const std::map<uint64_t,std::unique_ptr<ApiObjBase>>& getApiObjStorage();

  UacManager(const UacManager&) = delete; // singleton
  UacManager& operator=(const UacManager&) = delete; // singleton
private:
  InternalClass(); // singleton

  Resource resource1;
  Resource resource2;

  std::map<uint64_t,std::unique_ptr<ApiObjBase>> ApiObjStorage;
}

InternalClass.cpp：

#include "ApiObjBase.h"

void InternalClass::processApiObjBase(ApiObjBase& apiObj) {
  apiObj.internalPolyFunc1();
  apiObj.internalPolyFunc2();
  // ...
}

const Resource& InternalClass::getResource1() {
  return get().resource1;
}

const Resource& InternalClass::getResource2() {
  return get().resource2;
}

// Other implementations of member functions ...

ApiObjBase.h：

class InternalClass;
class ApiObjBase {
protected:
  int internalVariable1;
  int internalVariable2;
  
  int apiVariable1;
  int apiVariable2;

public:
  ApiObjBase() = default;

  // getters,setters

  void internalPolyFunc1() = 0;
  void internalPolyFunc2() = 0;

  void apiPolyFunc1() = 0;
  void apiPolyFunc2() = 0;
}

ApiObjBase.cpp：

#include "ApiObjBase.h"
// ...

ApiObjDerived1.h：

#include "ApiObjBase.h"
class ApiObjDerived1 : public ApiObjBase {
protected:
  int internalVariable3;
  int internalVariable4;
  
  int apiVariable3;
  int apiVariable4;

public:
  ApiObjDerived1() = default;

  // getters,setters

  void internalPolyFunc1() override;
  void internalPolyFunc2() override;

  void apiPolyFunc1() override;
  void apiPolyFunc2() override;
}

ApiObjDerived1.cpp：

#include "ApiObjDerived1.h"
#include "InternalClass.h"
void ApiObjDerived1::internalPolyFunc1() {
  Resource& res = InternalClass::getResource1(); // 
  // ...
}

void ApiObjDerived1::internalPolyFunc2() {
  Resource& res = InternalClass::getResource1();
  // ...
}

void ApiObjDerived1::apiPolyFunc1() {
  // ...
}

void ApiObjDerived1::apiPolyFunc2() {
  // ...
}
// ...

ApiObjDerived2.h：

#include "ApiObjBase.h"
class ApiObjDerived2 : public ApiObjBase {
protected:
  int internalVariable5;
  int internalVariable6;
  
  int apiVariable5;
  int apiVariable6;

public:
  ApiObjDerived2() = default;

  // getters,setters

  void internalPolyFunc1() override;
  void internalPolyFunc2() override;

  void apiPolyFunc1() override;
  void apiPolyFunc2() override;
}

ApiObjDerived2.cpp：

#include "ApiObjDerived2.h"
#include "InternalClass.h"
void ApiObjDerived2::internalPolyFunc1() {
  Resource& res = InternalClass::getResource2();
  // ...
}

void ApiObjDerived2::internalPolyFunc2() {
  // ...
}

void ApiObjDerived2::apiPolyFunc1() {
  // ...
}

void ApiObjDerived2::apiPolyFunc2() {
  // ...
}
// ...

SomeOtherModule.cpp：

#include "ApiObjDerived2.h"
void main(int argc,char** argv) {
  std::unique_ptr<ApiObjBase> apiObj = std::make_unique<ApiObjDerived2>();
  apiObj.get()->apiPolyFunc1();

  return EXIT_SUCCESS;
}

对于此示例，在链接SomeOtherModule时将出现以下错误：

(...) In function `ApiObjDerived2::internalPolyFunc1()': 
(...) undefined reference to `InternalClass::getResource2()'

我对这个问题的唯一想法是为每个多态类创建包装器类（ApiObjBaseWrapper，ApiObjDerived1Wrapper，ApiObjDerived2Wrapper）并将所有内部成员变量和函数移至它们。这些包装器类将包含原始派生类作为私有成员变量，可以由虚拟getter访问，该虚拟getter返回对ApiObjBase的引用或指针。这将使模块的内部和API部分分开，从而使API中不需要预声明，同时保持了多态性的所有优点。之后，InternalClass可以使用ApiObjBaseWrapper，而SomeOtherModule可以继续使用ApiObjBase。

我的想法是，这将需要大量新文件，类和代码（我将不得不使用.cpp和.h文件创建另一个〜30个类）。我不能再强调这个模块的大小了。

您有什么建议，我该怎么办？