C++17外层模板类仅自身可构造内部类并暴露方法的实现方案

添加友元后仍然编译报错的核心原因，不是类模板的友元规则特殊，而是std::make_shared是独立的外部函数模板，不属于Outer<T>的成员：你给Outer<T>开放了Inner私有成员的访问权限，不代表make_shared也获得了这个权限，clang编译时检查到make_shared尝试调用Inner的私有构造函数，就会直接报错。

优先推荐保留嵌套类结构的实现，封装性最好，用C++常用的Passkey（访问令牌）模式做权限控制，不需要大范围开友元，也不会有权限泄漏问题。

方案1：保留Inner作为Outer的嵌套类（推荐） #

核心逻辑是给Inner的构造函数增加一个只有Outer能生成的空令牌参数，外部代码拿不到合法令牌，就没有任何办法构造Inner实例，make_shared这类工具函数也绕不开这个限制。
完整可编译的示例代码：

#include <memory>

// 替换为你代码中实际的Obj类型定义
struct Obj {};

template<typename T>
class Outer {
public:
    // 回调接口保持原有定义，外部拿到Inner指针即可正常调用公共方法
    virtual void callbackMethod(std::shared_ptr<typename Outer<T>::Inner> inner) = 0;

    class Inner {
    public:
        // 构造访问令牌：只有Outer<T>能生成该类的实例
        struct ConstructKey {
            friend class Outer<T>;
        private:
            ConstructKey() = default;
        };

        // 构造函数设为公有，但必须传入合法的ConstructKey才能调用
        explicit Inner(ConstructKey, /* 替换为你实际需要的构造参数 */) : obj(/* 初始化obj成员 */) {}
        ~Inner() = default;

        // 暴露给外部的公共方法完全保留原有逻辑
        void exposedMethod() {
            // 方法实现
        }

        // 禁用拷贝/赋值，避免外部通过拷贝绕过构造权限控制，可按需调整
        Inner(const Inner&) = delete;
        Inner& operator=(const Inner&) = delete;
    private:
        Obj obj;
    };

protected:
    // 原createInner逻辑移到Outer内部，只有Outer及其派生类可调用
    std::shared_ptr<Inner> createInner(/* 替换为实际构造参数 */) {
        // 这里Outer可以合法生成ConstructKey，make_shared可正常调用构造
        auto inner = std::make_shared<Inner>(Inner::ConstructKey{}, /* 传入构造参数 */);
        // 保留原createInner中的其他业务逻辑
        return inner;
    }
};

这个方案的特点：

• 权限控制严格：除了Outer<T>，没有任何类、函数能生成合法的ConstructKey，从语法层面杜绝了外部构造Inner的可能
• 不需要给标准库组件或者其他无关代码开友元，不会出现友元溢出导致的权限漏洞
• 完全兼容C++17标准，clang、GCC、MSVC下均可正常编译，没有模板友元的隐式实例化坑
• 外部拿到std::shared_ptr<Inner>后，调用Inner公共方法的逻辑完全不需要改动，和预期使用方式一致

方案2：将Inner改为顶级类 #

如果你接受将Inner从Outer中拆出来作为顶级类，也可以用同样的Passkey模式实现权限控制：

#include <memory>

struct Obj {};

// 前置声明Outer模板
template<typename T>
class Outer;

template<typename T>
class Inner {
public:
    struct ConstructKey {
        friend class Outer<T>;
        private:
            ConstructKey() = default;
    };

    explicit Inner(ConstructKey, /* 构造参数 */) : obj(/* 初始化 */) {}
    ~Inner() = default;

    void exposedMethod() {
        // 暴露方法实现
    }

    Inner(const Inner&) = delete;
    Inner& operator=(const Inner&) = delete;
private:
    Obj obj;
};

template<typename T>
class Outer {
public:
    virtual void callbackMethod(std::shared_ptr<Inner<T>> inner) = 0;
protected:
    std::shared_ptr<Inner<T>> createInner(/* 构造参数 */) {
        auto inner = std::make_shared<Inner<T>>(typename Inner<T>::ConstructKey{}, /* 构造参数 */);
        // 其他业务逻辑
        return inner;
    }
};

注意：不要为了让make_shared通过编译，直接给std::make_shared或者整个std命名空间开友元，这种做法会开放所有标准库组件访问Inner私有成员的权限，存在严重的安全和封装漏洞。

内容的提问来源于stack exchange，提问作者Aldo Laiseca