c++ - 如果初始化需要shared_from_this，如何在一次调用中构建一个类？

Question

我有一个类需要调用 shared_from_this() 进行初始化。由于无法在 ctor 中直接调用此函数，因此我必须分两步进行:

1. 使用静态工厂函数构建类
2. 调用类的初始化函数，以便对象可以使用

它的工作原理非常理想，我希望客户端代码只对其进行一次调用 - 并将 init 函数设为私有(private)，因为它是构造的一部分。

这可能吗？

exception: bad_weak_ptr while shared_from_this 后面的评论中也有一个旁注因为它在我的情况下不起作用(但也许这是另一个问题)

#include <iostream>
#include <memory>

class Foo;

void globalInit(std::shared_ptr<Foo> foo, int val)
{
    (void)foo;
    std::cout << __PRETTY_FUNCTION__ << val <<std::endl;
}

class Foo : public std::enable_shared_from_this<Foo>
{
public:
    static std::shared_ptr<Foo> create(int val) {
        return std::shared_ptr<Foo>(new Foo(val));
        /*
         * side note : if i use return std::make_shared<Foo>(val);
         * then i have a compiler error with g++ (Debian 6.3.0-18)
         * "Foo::Foo(int) is private within this context"
         */
    }

    // it should not be public ..
    void init() {
        // during init, i need to call shared_from_this()
        // and access private members
        globalInit(shared_from_this(), m_val);
    }

private:
    // i cannot call shared_from_this() in the ctor
    explicit Foo(int val) : m_val(val) {}

private:
    int m_val;
};

int main(int argc, char *argv[])
{
    (void)argc;
    (void)argv;

    // create the object
    std::shared_ptr<Foo> foo = Foo::create(0);
    // initialize it
    foo->init();

    // now it's ready to use
    // ...

    return 0;
}

谢谢。

Answer 1

您可以从您的工厂调用 init:

class Foo : public std::enable_shared_from_this<Foo>
{
private:
    class private_key{
    private:
        friend class Foo;

        private_key() {}
    };

public:
    static std::shared_ptr<Foo> create(int val) {
        auto p = std::make_shared<Foo>(private_key{}, val);

        p->init(); // Or directly globalInit(p, p->m_val);
        return p;
    }

private:
    void init() {
        // during init, I need to call shared_from_this()
        // and access private members
        globalInit(shared_from_this(), m_val);
    }

public: // But only callable internally thanks to private_key
    Foo(private_key, int val) : m_val(val) {}

private:
    int m_val;
};

Demo