std::shared_ptr becomes invalid when passing as an argument by value - c++

Question

Dear people of stackoverflow.
I have a class, named FcgiManager, that is intended to handle a proper ammount of fastcgi workers.
Currently it has a simple method to add a new worker to list:
bool FcgiManager::AddWorker() {
workers_.push_back(std::make_unique<FcgiWorker>(server_));
return true;
}
The "workers_" field is:
private:
// cut
std::list<std::unique_ptr<FcgiWorker>> workers_;
The program exits with "bad weak pointer" exception.
When I trace it i see that from this method it does reache FcgiWorkes constructor, here it is:
FcgiWorker::FcgiWorker(std::shared_ptr<Dolly> server) :
running_{false}, pool_{std::make_unique<FcgiRequestPool>()}, server_{server} {
// actual code is not important, because execution doesn't get here.
}
And i see, that the "server" argument shared_ptr has some martian values in it's structure, like count = 1443278, weak = -1.
But in the AddWorker() method, just before entering FcgiWorker constructor the "server_" field has appropriate values.
I have even added an "IsAlive()" method to server and tried calling server_->IsAlive() from AddWorker() and yes, it's alive.
I also tried to plainly create a worker like this:
Any advice appreciated.
bool FcgiManager::AddWorker() {
FcgiWorker test(server_);
return true;
}
To check if I am doing something wrong with make_unique, but the result was the same.
Any advice appreciated.
Update-1:
FcgiWorker::server_ is:
std::shared_ptr<Dolly> server_;
it is initialized in the FcgiWorker constructor's initialization list, see constructor code above.
Update-2
FcgiManager::server_ is:
std::shared_ptr<Dolly> server_;
Here is how it is created in main.cpp:
auto server = std::make_shared<Dolly>();
server->BindFcgiManagerToServer();
server->Run();
server.cpp:
Dolly::Dolly() : start_time_{std::time(nullptr)} {
fcgi_manager_ = std::make_unique<FcgiManager>();
}
void Dolly::BindFcgiManagerToServer() {
fcgi_manager_->set_server(self());
}
server.h:
class Dolly : public std::enable_shared_from_this<Dolly> {
private:
// cut
inline std::shared_ptr<Dolly> self() { return shared_from_this(); }
Update-3 & Update-4 & 5
Created MCVE, and, oh well - it compiles and does not throw. So i guess i'll have to solve my problem myself now :)
Thanks everyone!
(MCVE updated twice, since it was not complete the first time)
#include <memory>
#include <list>
#include <iostream>
class Dolly;
class FcgiRequestPool {
};
class FcgiWorker {
public:
FcgiWorker(std::shared_ptr<Dolly> server) :
pool_{std::make_unique<FcgiRequestPool>()}, server_{server} {
std::cout << "worker created" << std::endl << std::flush;
}
private:
std::shared_ptr<FcgiRequestPool> pool_;
std::shared_ptr<Dolly> server_;
};
class FcgiManager {
public:
inline void set_server(std::shared_ptr<Dolly> server) { server_ = server; }
bool InitWorkers() {
auto workers_num = 4;
auto created_workers_num = 0;
try {
for (created_workers_num = 0; created_workers_num < workers_num; created_workers_num++) {
AddWorker();
}
} catch (std::exception& e) {
std::cout << e.what() << std::endl << std::flush;
}
return true;
}
void Run() {
InitWorkers();
}
private:
bool AddWorker() {
workers_.push_back(std::make_unique<FcgiWorker>(server_));
return true;
}
std::list<std::unique_ptr<FcgiWorker>> workers_;
std::shared_ptr<Dolly> server_;
};
class Dolly : public std::enable_shared_from_this<Dolly> {
public:
Dolly() {
fcgi_manager_ = std::make_unique<FcgiManager>();
}
void BindFcgiManagerToServer() {
fcgi_manager_->set_server(self());
}
void Run() {
fcgi_manager_->Run();
}
private:
std::unique_ptr<FcgiManager> fcgi_manager_;
std::shared_ptr<Dolly> self() {
return shared_from_this();
}
};
int main() {
auto server = std::make_shared<Dolly>();
server->BindFcgiManagerToServer();
server->Run();
return 0;
}
Resolved
After creating MCVE and comparing it step-by-step with the actual program, I found out, that the shared_ptr exception was generated here:
pool_{std::make_unique<FcgiRequestPool>()}
And has no relation to the whole classes creation logic.
I am marking the answer with MCVE advice as valid, because it is actually a great advice and it did help me.
The root cause: I was creating a unique_ptr to a class, which was derived from std::enable_shared_from_this.