Question

我有一个静态库。我已经完成了关于堆栈溢出的大部分问题，但无法得出正确的结论

我有以下文件

文件是myNew.h

#include <cassert>
#include <stdio.h>
void* operator new(size_t sz);

class myNew {
    public:
        myNew() {
            initialize();
        }
        static void* newPageCheck();
        static bool val;

    private:
        static void initialize();
};

档案myNew.c

#include "myNew.h"
static myNew   myNewObj __attribute__ ((init_priority (80)));  
bool   myNew::val = false;

// overload default new operator 
extern void* operator new(size_t sz) {
    return myNew::newPageCheck();
}

void myNew::initialize() {
    val = true;
}

void* myNew::newPageCheck() {
    assert(val == true); 
    int i ; 
    return &i 
 }

档案my_slib_new.h

#include <stdio.h>

class myFoo {
    public:
        myFoo() { 
            int *i = NULL;
            i = new int ;
            funS();
        }
        void funS();
 };

档案my_slib_new.cc

#include "my_slib_new.h"
static myFoo foo __attribute__ ((init_priority (2000)));

void myFoo::funS() {
    int *i = new int;
}

文件sample_open_new.cpp

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "my_slib_new.h" 
int main () {
    printf ("Your Program will run ... \n");
    int status = open("./libSharedNew.so",0);
    return 0;
 }

我做了以下步骤

步骤1：首先从myNew.cc

创建静态库

1) g++ -g -c -fPIC myNew.cc
2) ar rcs libStaticNew.a myNew.o

第2步：从my_slib_new.cc创建共享库

3) g++ -g -c -fPIC my_slib_new.cc
4) g++ -shared -o libSharedNew.so my_slib_new.o

第3步：

5) gcc  -Wall -o myTest sample_open_new.cpp -L . -lSharedNew -lStaticNew

当我运行myTest时，我得到以下断言错误

断言`MyNew :: val == true'失败是因为静态全局对象

静态myFoo foo 属性（（init_priority（2000）））;在静态全局对象

之前初始化

static myNew myNewObj 属性（（init_priority（80）））;

我的要求是我无法将linStaticNew.a更改为sharedLibrary .libStaticNew.a以仅保持静态

我试图通过在sample_open_new.cpp中使用开放系统调用来延迟加载共享库，但它不起作用。

有没有办法可以延迟加载共享库libSharedNew.so，这个想法是静态全局对象static myNew myNewObj attribute （（init_priority（80）））;应该先在静态全局myFoo对象

之前初始化

或者是否有任何我们可以指定静态库的静态全局对象libStaticNew.a应该首先初始化

Answer 1

简短的回答：不，不像你想要的那样。

更长的回答：是的，你应该阅读Static initialization order fiasco。基本上C ++给出了关于初始化顺序的无保证，并且最好的建议是避免在不同的编译单元中使用全局静态＆＃34;。但是还有其他选项（在上面链接的常见问题解答中提到 - here。

Answer 2

使用单身人士。迈尔斯＆＃39;单身很简单，就像这样：

auto some_object()
    -> Object&
{
    static Object the_object;  // Possibly constructor arguments here
    return the_object;
}

这里的对象是在第一次使用时构建的。

如何延迟共享库

2 个答案: