What's the most effecient way to pass a copy of std::shared_ptr into a C function/API/thread that takes only a const void* parameter?

Say, if I have a C function (or an API) that invokes a callback in a different thread and accepts an old-school C parameter in a form of const void*. What's the most efficient way to pass a copy of the std::shared_ptr into that callback?

So far, I've been using the following method:

(I'll use a thread to simulate what I'm asking.)

struct My1
{
    My1()
    {
        std::cout << "My1 constructor" << std::endl;
    }
    
    ~My1()
    {
        std::cout << "My1 destructor" << std::endl;
    }
    
};

void* thread1(void* pParam)
{
    std::shared_ptr<My1>* pp1 = (std::shared_ptr<My1>*)pParam;
    
    std::cout << "thread1 ref count: " << pp1->use_count() << std::endl;
    
    delete pp1;

    return 0;
}

int main(int argc, const char * argv[])
{
    if(1)
    {
        std::shared_ptr<My1> p1 = std::make_shared<My1>();
        
        std::cout << "ref count: " << p1.use_count() << std::endl;
        
        std::shared_ptr<My1>* pp1 = new std::shared_ptr<My1>(p1);
        pthread_t thr1;
        if(pthread_create(&thr1, nullptr, thread1, (void*)pp1) != 0)
        {
            //Failed to start thread
            delete pp1;
        }
        
        std::cout << "ref count: " << p1.use_count() << std::endl;
    }
    
    int i;
    std::cin >> i;

    return 0;
}

Since you want a copy, just create an instance in thread1 using the copy constructor. Also, don't create the shared_ptrs using new. It doesn't make much sense.

Example:

#include <pthread.h>

#include <iostream>
#include <memory>

struct My1 {
    My1() { std::cout << "My1 constructor\n"; }
    ~My1() { std::cout << "My1 destructor\n"; }
};

void* thread1(void* pParam) {
    // copy construct:
    std::shared_ptr<My1> pp1 = *static_cast<std::shared_ptr<My1>*>(pParam);
    std::cout << "thread1 ref count: " << pp1.use_count() << '\n';
    return nullptr;
}

int main() {
    std::shared_ptr<My1> p1 = std::make_shared<My1>();
    std::cout << "ref count: " << p1.use_count() << '\n';

    pthread_t thr1;
    if (pthread_create(&thr1, nullptr, thread1, &p1) != 0) {
        // Failed to start thread
    } else {
        pthread_join(thr1, nullptr); // wait for the thread to finish
    }
    std::cout << "ref count: " << p1.use_count() << '\n';
}

Output:

My1 constructor
ref count: 1
thread1 ref count: 2
ref count: 1
My1 destructor

I am going to assume that the lifetime of the callback thread may exceed the lifetime of the original shared_ptr used when calling into the API. If this is not the case and the original shared_ptr is guaranteed to live longer than the callback thread, you can dispense with the smart pointer and just pass in a raw pointer and not worry. I presume this is not the case.

This is not aesthetically pleasing code, but I think it is a reasonable (only?) option for the situation you describe of calling into an API that invokes a callback you provide.

Do not dynamically allocate shared pointers; work with automatic storage duration here; otherwise the whole point of using smart pointers is basically lost.

Furthermore since you do delete pp1; on the main thread, it's in no way guaranteed that the shared pointer object is still alive when you access it in the background thread.

What you need here is a way of communicating the fact that the background thread has taken ownership of the object and doing so in a way that establishes a happens before relationship between the context object and the background thread taking ownership of the shared pointer.

std::latch happens to be something that can accompilish this. You can work around the const-ness of the context by using mutable (. Note: pthread does not receive the context as pointer to const).

Note: I'm using std::thread here for simplicity, but since it's used with a function pointer and a void pointer, you should easily be able to adjust the logic for use with pthread or other C multithreading logic.

struct ThreadContext
{
    mutable std::latch m_latch{1};
    mutable std::shared_ptr<std::string> m_ptr = std::make_shared<std::string>("Hello World");
};

void BackgroundThreadLogic(void const* context)
{
    std::shared_ptr<std::string> ptr;

    {
        auto const tk = static_cast<ThreadContext const*>(context);
        ptr = std::move(tk->m_ptr);
        tk->m_latch.count_down(); // after this the context may become a dangling pointer any time, but we've taken ownership of the important stuff already
    }

    std::cout << "Message received on background thread: " << *ptr << '\n';
}

int main() {
    std::thread t;

    {
        ThreadContext context;
        t = std::thread(&BackgroundThreadLogic, static_cast<void const*>(&context));
        context.m_latch.wait();
        // now we can delete the context
    }

    t.join(); // still need to join the thread in the end
}