Static 共享 *.so 文件的对象

Question

In C++ project, we have the following dependency:

1. Package1.so - shared lib/functional having std::shared_ptr<T > getInstance() * static function which returns a static shared pointer. If the static pointer isn't initialized, it initializes then returns the pointer. It also uses static mutex to guarantee sync in case of MT mode call to getInstance

2. Package2, which depends on Package1.so and uses the getInstance function to fetch data

3. Package3, has dependency from Package1 and Package2 and also directly uses 'getInstance' function

It's expected that static object should be created only once and be shared between package 2& 3

However, seems the shared object is different for Package2 & 3 -> the object is created twice.

Question: Is static memory space is not shared in case of.so files?

// Package 1
// h1.hpp
#pragma once

class A {
public:
  static std::shared_ptr<A> get_instance();
  
 private:
  static std::mutex m_mtx;
  static std::shared_ptr<A> m_instance;
};

// Package 1
// h1.cpp
static std::mutex A::m_mtx;
static std::shared_ptr<A> A::m_instance;

std::shared_ptr<A> A::get_instance() {
  const std::lock_guard<std::mutex> lck{m_mtx);
  if (nullptr == m_instance) {
     m_instance = std::make_shared<A>();
  }
  return m_instance;
}


// Package 2 depending Package 1
#include <path/h1.hpp>

void f() {
   auto instance = A::get_instance(); // for first call creates new
}


// Package 3 depending Package 1 and Package 2
#include <path/h1.hpp>
void g() {
   auto instance = A::get_instance(); // for first call creates new
}



// Result - 2 instances are created of A - one thought Package 3 one through Package 2

// Expected - a single A should be created and static shared ptr should be shared.

Answer 1

This is expected.

The shared pointers themselves are different because they are different objects but they point to the same underlying object. This is by design.

I took your example and reran it, it produces the following.

$ ./main
Instance:0x7fb7001a00a0 Object:0x55ae9c53aec0
Instance:0x7fb70019b0a0 Object:0x55ae9c53aec0

I created a main.cpp that calls f and g

void f();
void g();

int main() {
        f();
        g();
}

f.cpp is in a different library libf.so . I assign it to a static object otherwise calling f() and g() could print the same address for same objects just by coincidence.

#include "h1.h"
void f() {
   static auto instance = A::get_instance(); // for first call creates new
   printf( "Instance:%p Object:%p\n", &instance, instance.get() );
}

Same thing for g.cpp

#include "h1.h"
void g() {
   static auto instance = A::get_instance(); // for first call creates new
   printf( "Instance:%p Object:%p\n", &instance, instance.get() );
}

Notice that on h1.h you are returning a copy of the static variable, not a reference to it. That is okay but it will generate a copy and perhaps that's not what you expect.

#pragma once

#include <memory>
#include <mutex>

class A {
public:
  static std::shared_ptr<A> get_instance();
private:
  static std::mutex m_mtx;
  static std::shared_ptr<A> m_instance;
};

On this file h1.cpp you had the keyword static prefixed to the implementation of the two variables. That is a bug and I commented out. It should not compile. Maybe that is the reason for your problem.

#include "h1.h"

/* static */  std::mutex A::m_mtx;
/* static */  std::shared_ptr<A> A::m_instance;

std::shared_ptr<A> A::get_instance() {
  const std::lock_guard<std::mutex> lck{m_mtx};
  if (nullptr == m_instance) {
     m_instance = std::make_shared<A>();
  }
  return m_instance;
}

CMakeLists.txt

cmake_minimum_required( VERSION 3.0 )
project(deps)

add_library( h1 SHARED h1.cpp )

add_library( f SHARED f.cpp )
target_link_libraries( f h1 )

add_library( g SHARED g.cpp )
target_link_libraries( g h1 )

add_executable( main main.cpp )
target_link_libraries( main h1 f g )