如何访问私人嵌套类C＆＃x2b;＆＃x2B;的公共构造函数

Question

我有一个嵌套的私有类嵌套和 key ，我希望我可以使用 add_new_object（key，nested）函数将对象添加到我的 my_mmap multimap。但是，当我试图称这些类构造函数称为无法访问时。我该如何解决问题。

class Enclosing
{
private:
    class Nested {
        string m_str;
        double m_dbl;
        bool m_boolean;
    public:
        Nested(string str, double dbl, bool boolean) :m_str(str), m_dbl(dbl), m_boolean(boolean) {};
    };
    class Key {
        int m_number;
        string m_name;
    public:
        Key(int num, string name) :m_number(num), m_name(name) {};
    };

    Enclosing* singleton;

    std::multimap<Key, Nested> my_mmap;
public:
    void add_new_object_to_mmap(Key k, Nested n) {}


    static Enclosing* get_singleton() {
        static Enclosing instance;
        return &instance;
    }
};

谢谢大家！

Answer 1

您似乎误解了在私人部分中声明类型的含义。或者至少您不知道这些类型作为公共成员功能的参数的含义。

这是您的代码添加的定义（键> 和 nested 的定义，您根本无法调用其构造函数）：

#include <map>


class Enclosing
{
private:
    class Nested {};
    class Key {};

    Enclosing* singleton;

    std::multimap<Key, Nested> my_mmap;
public:
    void add_new_object_to_mmap(Key k, Nested n) {}

    
    static Enclosing* get_singleton() {
        static Enclosing instance;
        return &instance;
    }
};

因为类型 key 和嵌套出现在 enclosing 的公共接口中，它们实际上不是私有的。只有他们的名字是私人的。可以从成员函数中推断两种类型：

template <typename F> struct get_types;

template <typename K,typename N> struct get_types< void(Enclosing::*)(K,N)> {
    using Key = K;
    using Nested = N;
};

现在您可以像调用其他类型的构造函数一样调用其构造函数：

int main()
{
    using Types = get_types<decltype(&Enclosing::add_new_object_to_mmap)>;
    using Key = Types::Key;
    using Nested = Types::Nested;
    Enclosing::get_singleton()->add_new_object_to_mmap(Key{},Nested{});
}

完整的示例

最后，请注意，呼叫者甚至不必为这两种类型提供名称。这也起作用（或在没有默认构造函数的情况下使用参数）：

Enclosing::get_singleton()->add_new_object_to_mmap({},{});

在公共界面中出现在另一类的私有部分中声明的类型不是私有的。如果您真的想从 enclosing 的用户中隐藏两种类型，那么您需要做其他事情。有关如何将仅传递给其构造函数的参数传递给public add_new_object_to_mmap 的方法，请参见TEDS答案。那么两种类型可以是真正的私人。

Answer 2

如果您只需要能够使用每个构造函数构造 key 嵌套每个构造函数每个参数，则可以将 add_new_object_to_mmap 在成员函数模板中制作并将论点转发给实际的构造函数：

#include <utility>

class Enclosing {
private:
    class Key {
    public:
        Key(int);
        bool operator<(const Key& rhs) const;
        // ...
    };

    class Nested {
    public:
        Nested(double);
        // ...
    };

    std::multimap<Key, Nested> my_mmap;

public:
    template<class Karg, class Narg>
    void add_new_object_to_mmap(Karg&& karg, Narg&& narg) {              
        my_mmap.emplace(std::forward<Karg>(karg), std::forward<Narg>(narg));
    }

    static Enclosing& get_singleton() {
        static Enclosing instance;
        return instance;
    }
};

int main() {
    /*here I want to call constructors*/
    Enclosing::get_singleton().add_new_object_to_mmap(1, 3.141);
}

demo

---

支持构建 和code 嵌套带有可变数量的参数，您可以使用 std :: pieceWise_construct ：

    template <class... Args>
    void add_new_object_to_mmap(Args&&... args) {
        my_mmap.emplace(std::piecewise_construct, std::forward<Args>(args)...);
    }

and 将参数作为元组：

int main() {
    Enclosing::get_singleton().
        add_new_object_to_mmap(std::forward_as_tuple(1, "Foo"),
                               std::forward_as_tuple("Str", 3.141, true));
}