C++ C 库的包装器

Question

最近我发现了一个我想在我的 C++ 项目中使用的 C 库。 该代码配置了全局变量，并将其输出写入静态指针指向的内存。 我希望运行 C 程序的 2 个实例：一个具有配置 A，一个具有配置 B。我不能运行我的程序两次，所以我认为有 2 个选项：

• 当我执行我的项目时， >C++ 包装器：这里的问题是包装器类应该包含 C 库拥有的所有全局/静态变量。由于 C 库中的函数使用这些变量，我必须为这些函数创建非常大的参数列表。
• 复制粘贴 C 库：这里我必须调整 C 库中每个函数和每个变量的名称。

哪一种是最快的解决方案？ 是否有其他可能性来运行同一 C 源代码的 2 个实例？

谢谢，

麦克斯

Answer 1

C++ - 包装器
通过将“整个库”（仅稍作修改）粘贴到类中，您可以更轻松地完成任务。

// C
static char resultBuffer[42];
void ToResult(int x) { ... }
char const * GetResult() { return resultBuffer; }

变成

// C++
class CMyImportantCLib
{
  private:
    char resultBuffer[42];
    void ToResult(int x) { ... } // likely, no code changes at all
    char const * GetResult() { return resultBuffer; }
} ;

主要是声明性的改变（比如“杀死”静态和外部声明）。不过，您需要在方法内寻找静态变量，并将它们也转换为成员

单独的命名空间
这是一个丑陋的解决方案，但对您来说可能已经足够了：

// impMyLib.h
namespace A 
{
  #include "c-lib.h"
}
namespace B
{
  #include "c-lib.h"
}

// impMyLib.cpp
namespace A 
{
  #include "c-lib.c"
}
namespace B
{
  #include "c-lib.c"
}

如果幸运的话，优化器/链接器会成功折叠相同的代码。但是，A:: 和 B:: 中的类型不相关。

Answer 2

如果你无法承担运行两次的费用，那么运行 3 次怎么样？您可以想象编写一个小型前端进程来启动 C 程序的两个单独实例。从使用的角度来看，它仍然看起来像一个仅运行一次的 .exe，但在幕后您将有一个带有两个子进程的父进程。我不知道这种方法是否适合您的实际需求，但它几乎肯定比其他两种选择更快。

Answer 3

IIUC，基本上，您所拥有的是：

extern int a;
extern int b;

void f();
void g(); 

其中 a 和 b 修改 f() 和 g() 的行为。这是正确的吗？

如果你有这个并且你想用 C++ 包装它，那么你可以这样做：

class the_library {
public:
  the_library(int a, int b) : a_(a), b_(b) {}

  void f() {a=a_; b=b_; ::f();}
  void g() {a=a_; b=b_; ::g();}
private:
  int a_;
  int b_;

};

根据您所拥有的而不是 a 和 b，这可能不是非常有效。

当然，正如 Raki 在评论中所说，由于这是使用全局变量，所以它根本不是线程安全的。

Answer 4

也许有一些事情让我困惑，但是

......全局变量在线程之间共享，而不是进程之间......

这意味着在你的情况下，你可以让同一个C程序的两个进程工作，并且它们不会除非它们以某种方式使用进程共享内存，否则它们会相互干扰。

...如果您需要在同一进程中运行两个 C 代码实例...

那么您就完蛋了。

TLS，也许？

您可以在单独的线程中启动它们并将全局变量声明为线程本地存储变量。例如，在 Visual C++ 上，以下代码：

int myGlobalVariable = 42 ;                 // Global variable
__declspec(thread) int myTLSVariable = 42 ; // Thread local variable

每个线程都有自己的变量版本。这样，在线程末尾，您可以将内容复制到其他地方。

重写代码...

您不需要添加 C++ 层。您可以保留 C 代码，并在结构中声明所有全局变量：

/* C global variable */
int iMyGlobalVariable = 42 ;
const char * strMyGlobalString = NULL ;
short iMyShortData = 7 ;

/* C struct */
typedef struct MyStruct
{
   int iMyGlobalVariable ;
   const char * strMyGlobalString ;
   short iMyShortData ;
}
MyStruct ;

然后修改函数的原型以接受指向该结构的指针作为第一个参数，然后修改该结构而不是修改全局变量member :

/* old function */
int foo(char *p)
{
   /* fudge with the global variables */
   iMyShortData = 55 ;

   /* etc. */
   fooAgain("Hello World", 42) ;
}

变成：

/* new function */
int foo(MyStruct * s, char *p)
{
   /* fudge with the struct variables */
   s->iMyShortData = 55 ;

   /* etc. */
   fooAgain(s, "Hello World", 42) ;
}

然后，在 main 中，您不调用第一个函数，而是通过给它指向正确结构的指针来调用它。而不是 :

int main(int argc, char * argv[])
{
   bar(42, 55) ;
}

你可以写 :

int main(int argc, char * argv[])
{
   MyStruct A = { /* initialize A's members if needed */ }  ;
   MyStruct B = { /* initialize B's members if needed */ }  ;

   bar(&A, 42, 55) ;
   bar(&B, 42, 55) ;

   return 0 ;
}

在上面的例子中，两者被一个接一个地调用，但是你可以启动线程。

拯救全局状态？

如果您的代码是单线程的，您可以通过保存/重置全局状态来交错第一个实例的调用和第二个实例的调用。让我们使用上面相同的结构：

/* C global variable */
int iMyGlobalVariable = 42 ;
short iMyShortData = 7 ;

void saveState(MyStruct * s)
{
   s->iMyGlobalVariable = iMyGlobalVariable ;
   s->iMyShortData = iMyShortData ;
}

void resetState(const MyStruct * s)
{
   iMyGlobalVariable = s->iMyGlobalVariable ;
   iMyShortData = s->iMyShortData ;
}

然后，在需要时调用 save 和 reset 函数：

int main(int argc, char * argv[])
{
   MyStruct A = { /* initialize A's members if needed */ }  ;
   MyStruct B = { /* initialize B's members if needed */ }  ;

   resetState(&A) ; /* now, we work on A */
   bar(42, 55) ;
   saveState(&A) ;  /* we save the progress on A */

   resetState(&B) ; /* now, we work on B */
   bar(42, 55) ;
   saveState(&B) ;  /* we save the progress on B */

   resetState(&A) ; /* now, we work on A */
   foo("Hello World", 3.14159) ;
   saveState(&A) ;  /* we save the progress on A */

   resetState(&B) ; /* now, we work on B */
   foo("Hello World", 3.14159) ;
   saveState(&B) ;  /* we save the progress on B */

   /* etc. */
   return 0 ;
}

这可以由 C++ 代码包装，以自动包装 resetState/saveState 函数。例如：

struct MyWrapper
{
    void foo(const char * p, double d)
    {
       resetState(&m_s) ;
       foo(p, d) ;
       saveState(&m_s) ;
    }

    void bar(int i, short i2)
    {
       resetState(&m_s) ;
       bar(i, i2) ;
       saveState(&m_s) ;
    }

    MyStruct m_s ;
} ;

您可以将 main 重写为：

int main(int argc, char * argv[])
{
   MyWrapper A ;
   MyWrapper B ;

   A.bar(42, 55) ;
   B.bar(42, 55) ;

   A.foo("Hello World", 3.14159) ;
   B.foo("Hello World", 3.14159) ;

   // etc.

   return 0 ;
}

这看起来比 C 版本好很多。不过，MyWrapper 不是线程安全的...

结论

第一个解决方案（TLS）是快速但肮脏的解决方案，而第二个解决方案是重构代码以正确编写它（有充分的理由不赞成全局变量，显然，您偶然发现了其中一个），第三个是“黑客”，使您能够交错这两个调用。

在所有三个解决方案中，只有第二个解决方案可以轻松地将这些代码包装在健壮的、线程安全的 C++ 类中（如果仍然需要）。

Answer 5

我喜欢这里的想法。但我应该为我需要修改的每个变量创建一个指针。
这是一个示例：

lib.h:

void f();
int g();

lib.c:

#include "lib.h"
extern int a;
extern int * output;

void f(){
    *output=(*output+6)*a;
}
int g(){
    return *output;
}

object.cc:

#include "lib.h"
#include <iostream>
using namespace std;

int a;
int * output;

class the_library {
public:
  the_library(int a, int * output) : a_(a), output_(output) {}

  void f() {a=a_; output=output_; ::f();}
  int g() {a=a_; output=output_; ::g();}
private:
  int a_;
  int * output_;

};

int main(){

    int out1=2;
    the_library icache(3,&out1);
    icache.f();
    cout<<"icache.f() -> icache is "<<icache.g()<<endl;
    icache.f();
    cout<<"icache.f() -> icache is "<<icache.g()<<endl;

    int out2;
    out2=8;
    the_library dcache(7,&out2);
    dcache.f();
    cout<<"dcache.f()\t-> icache is "<<icache.g()<<endl;
    cout<<"\t\t-> dcache is "<<dcache.g()<<endl;
    return 0;
}