Question

我目前正在编写一个如下所示的弱引用资源管理器，并且编译器抱怨该管理器具有私有构造函数。

我的问题是：为什么我不能在静态函数中访问私有成员函数？

#ifndef TENSOR_MANAGER_H
#define TENSOR_MANAGER_H

#include <memory>
#include <functional>
#include <map>
#include <iostream>

template<typename key_t, typename model_t>
class Manager : public std::enable_shared_from_this<Manager<key_t, model_t> > {
public:
    using self_t = Manager<key_t, model_t>;

public:
    static auto Create() {
        return std::make_shared<self_t>();
    }

public:

    std::shared_ptr<model_t> GetOrAdd(const key_t &&key, const char *data, size_t size) {
        auto pos = m_resources.find(key);
        std::shared_ptr<model_t> tmp;
        if (pos != m_resources.end()) {
            tmp = pos->second.lock();
        }
        if (!tmp) {
            model_t *p = new model_t();

            auto deletor = std::bind(&self_t::releaseItem,
                                     std::weak_ptr<self_t>(this->shared_from_this()),
                                     key,
                                     std::placeholders::_1);

            tmp = std::shared_ptr<model_t>(p, deletor);

            m_resources[key] = std::weak_ptr<model_t>(tmp);
        }
        return tmp;
    }

public:
    void Print() {
        std::cout << "Content: ";
        for (const auto &item : m_resources) {
            std::cout << item.first << " ";
        }
        std::cout << std::endl;
    }

private:
    static void releaseItem(std::weak_ptr<self_t> self, const key_t &key, model_t *p) {
        std::shared_ptr<Manager<key_t, model_t>> mgr = self.lock();
        if (mgr) {
            mgr->m_resources.erase(key);
        }
        delete p;
    }

private:
    std::map<key_t, std::weak_ptr<model_t> > m_resources;

    Manager() = default;
};

#endif //TENSOR_MANAGER_H

现在编译器给出错误：

/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/memory:2043:66: error: field of type 'Manager<std::__1::basic_string<char>, int>' has private default constructor
_LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() : __value_() {}

Answer 1

因为调用私有构造函数的是库函数std::make_shared。

Answer 2

根据Cppreference，make_shared上的注释明确指出：

如果
std::shared_ptr<T>(new T(args...))在可访问的上下文中执行，则可以调用T的非公共构造函数，而 std::make_shared 需要 公开访问选定的构造函数。

由于在这种情况下选择的构造函数为private，所以编译失败。
如果您仍然希望保留private，请使用std::shared_ptr<T>(new T(args...))函数static中的Create形式。

编辑：
如果您打算使用make_shared和private构造函数，则可以使用此技巧，该技巧使用空的嵌套class和explicit构造函数。

一个最小的例子。

#include <memory>

class Bar : public std::enable_shared_from_this<Bar> 
{

private:
    class Foo {};
    Bar() = default;

public:
    static auto Create() {        
        return std::make_shared<Bar>(Foo());
    }  
    explicit Bar(Foo);    
};

int main()
{
    auto i = Bar::Create();
}

请参见DEMO。

您可以根据需要调整以上内容。

为什么不能按如下所示在我的静态函数中访问私有构造函数？

2 个答案: