Declaring multiple instances of a c++ class which uses C code - c++

Question

I have some C libraries which I would love to be able to be able to wrap in a c++ class and create multiple, completely separate instances of. I tried doing this but the problem is that the variables in the C code are simply shared among all c++ class instances.
I've tried making a static library and referencing that but to no avail. Does anyone know how one can do this?
Code example below: I have a C file called CCodeTest which simply adds some numbers to some variables in memory. I have a class in MathFuncsLib.cpp, which uses this. I want to be able to create multiple instances of the MyMathFuncs class and have the variables in the C code be independent
CCodeTest.h
#ifndef C_CODE_TEST_H
#define C_CODE_TEST_H
extern int aiExternIntArray[3];
#if defined(__cplusplus)
extern "C" {
#endif
#define CCODE_COUNT 3
void CCodeTest_AddToIntArray(int iIndex_);
int CCodeTest_GetInternInt(int iIndex_);
int CCodeTest_GetExternInt(int iIndex_);
#if defined(__cplusplus)
}
#endif
#endif //defined(C_CODE_TEST_H)
MathFuncsLib.cpp
#include "MathFuncsLib.h"
#include "CCodeTest.h"
using namespace std;
namespace MathFuncs
{
void MyMathFuncs::Add(int iNum_)
{
CCodeTest_AddToIntArray(iNum_);
}
void MyMathFuncs::Print(void)
{
for(int i = 0; i < CCODE_COUNT; i++)
{
printf("Intern Index %i: %i\n", i, CCodeTest_GetInternInt(i));
printf("Extern Index %i: %i\n", i, CCodeTest_GetExternInt(i));
}
}
}
Any help would be much appreciated!

Answer 1

You have a global variable called aiExternIntArray. That is the problem. Each instance of your C++ class operates on that array.
What you need to do is create a struct that holds an int[3] so that you can create separate instances of this type.
typedef struct
{
int aiIntArray[3];
} CodeTestStruct;
void CCodeTest_AddToIntArray(CodeTestStruct* ct, int iIndex_);
int CCodeTest_GetInternInt(CodeTestStruct* ct, int iIndex_);
int CCodeTest_GetExternInt(CodeTestStruct* ct, int iIndex_);
In C++, your class should encapsulate the CodeTestStruct.
class CodeTestClass
{
public:
void AddToIntArray(int iIndex_)
{
CCodeTest_AddToIntArray(&m_ct, iIndex_);
}
int GetInternInt(int iIndex_)
{
CCodeTest_GetInternInt(&m_ct, iIndex_);
}
int GetExternInt(int iIndex_)
{
CCodeTest_GetExternInt(&m_ct, iIndex_);
}
private:
CodeTestStruct m_ct;
};

Answer 2

Thank you for the answers - the suggestions above are all very valid.
My problem is an uncommon one as the C code I'm trying to run will be on an embedded system with very limited resources and so I am trying to minimize pointer dereferencing and state management etc...
I am using this C code in a computer exe to simulate multiple microprocessors running this code in parallel. So I've decided to create two DLLs that both share the same C source but have slightly different interfaces so that the C code, when loaded by importing the DLLs will be in a separate memory space and allow me to simulate multiple micros in one execution stream.

Answer 3

This is why you should never use global variables. That includes euphemisms for global variables like "singletons". There are exceptions to this rule, but they almost all involve systems-level programming and are not applicable to applications or (non-system-level) libraries.
To solve the problem, fix the C code so that it operates on an argument passed to it rather than a global variable.

Answer 4

If you're okay with with providing your own version of the library, you can refactor out the global variables fairly trivially. This might annoy your users if the library is large enough, though.
Similarly to the above, you can use a different library or write your own.
If you don't want want to do that, and the library can be dynamically linked (ie: libfoo.so) you might be able to load the libary multiple times (one for each instance), although this will probably mean guzzling memory is likely to be unacceptably slow in any serious program
If you have to use this version of this library and it is staticly linked, then you're pretty much screwed.