下面的escenario很吸引我。

(A)源代码库。

(B)是一个包含(A)的共享库

(C)一个包含(A)的静态库

(D)，一个与(B)和(C)链接的顶级程序。

以前我读过下面的答案，并理解如果链接是静态的，那么变量是真正的静态的，并且在整个程序中只存在一次，但如果链接是动态的，那么静态变量的存在次数与库包含的次数一样多。当库静态链接时，静态变量会发生什么

例如，如果我用以下代码包含N次静态库，则__immediately_lambda_call被触发N次，但访问相同的gMyClass。

static MyClass& GetSingleton() {
static std::once_flag flag;
static MyClass* gMyClass;
std::call_once(flag, [&]() { gMyClass = new MyClass(); });
return *gMyClass;
}
static const auto __immediately_lambda_call = []() {
auto& gMyClass = GetSingleton();
return true;
}();

但是，当动态库和静态库包含相同的代码时会发生什么呢。

可以忽略下一段我更关心静态库和动态库之间如何共享内存。

问题是，顶级程序(D)在一个更复杂的代码中随机向我抛出了一个double free memory错误，我将其总结为以下代码，我不明白为什么，但在编译动态库时添加__attribute__((visibility( hidden ))似乎可以解决这个问题。

static const int gMyArr[2] = {1,2};
static const int gMyNum = 1;
class API_STATIC_DYNAMIC MyOtherClass
{
public:
MyOtherClass()
: mMatrix(new int[20])
{}

MyOtherClass()
{
delete[] mMatrix;
}

void doSomething()
{
int d = gMyArr[0];
}
static int gMatrix[10];
static int gNumber;

private:
int *mMatrix;
}

编辑库：

API.h

#if defined(STATIC_LIB)
#define API_STATIC_DYNAMIC 
#else
#define API_STATIC_DYNAMIC __attribute__((visibility("hidden"))) // removed "default"
#endif

MYLIB.h

class MyLibApi
{
public:
void doSomething();

private:
class MyLibImp;
MyLibImp *mPimpl;
}

MYLIB.cpp

class MyLibImp()
{
public:
MyOtherClass myOther;
}
void MyLibApi::doSomething()
{
mPimpl->myOther->doSomething();
}

编辑APP：

int main()
{
MyLibApi api;
api.doSomething();
MyOtherClass other;
other.doSomething();
return 0;
}