如何让C++公共成员函数对特定类设置私有访问权限？

要让公共成员函数对特定类禁用，同时保留对其他类的访问权限，最可靠的方式是使用**编译期的权限令牌（Permission Token）**机制，直接在编译阶段阻止违规调用，从根源避免运行时bug。

核心思路 #

1. 定义一个私有构造的令牌类，仅允许合法类获取该令牌；
2. 修改目标函数（Location::getEveryonePresent），要求必须传入令牌才能调用；
3. 通过模板特化逻辑，禁止特定类（ApproachSomeone）获取令牌，从而让它无法调用目标函数。

修改后的完整代码示例 #

#include <list>
#include <type_traits>

// 前向声明
class Person;
class ApproachSomeone;

// 权限令牌类：私有构造，仅允许指定类获取
class LocationAccessToken {
private:
    LocationAccessToken() = default;

    // 模板友元：允许除ApproachSomeone外的所有类获取令牌
    template<typename T>
    friend std::enable_if_t<!std::is_same_v<T, ApproachSomeone>, LocationAccessToken> getLocationToken();
};

// 全局函数：供允许的类获取令牌
template<typename T>
std::enable_if_t<!std::is_same_v<T, ApproachSomeone>, LocationAccessToken> getLocationToken() {
    return {};
}

class Location {
    std::list<Person*> everyonePresent;
public:
    // 修改为必须传入令牌才能调用
    const std::list<Person*>& getEveryonePresent(LocationAccessToken) const {
        return everyonePresent;
    }
};

class Person {
private:
    Location loc;
public:
    const Location& getLocation() const { return loc; }
};

class DoSomething {
    Person& person;
    std::list<Person*> everyoneVisible;
public:
    DoSomething(Person& p) : person(p),
        everyoneVisible(p.getLocation().getEveryonePresent(getLocationToken<DoSomething>())) {
        // 移除隐藏人员的逻辑
    }

    void execute() {
        ApproachSomeone(person, everyoneVisible).execute();
    }
};

class ApproachSomeone {
    Person& target;
    std::list<Person*> visiblePeople;
public:
    ApproachSomeone(Person& p, std::list<Person*>& vp) : target(p), visiblePeople(vp) {}

    void execute() {
        // 编译错误：getLocationToken<ApproachSomeone>()不存在，无法获取令牌
        // auto& forbiddenList = target.getLocation().getEveryonePresent(getLocationToken<ApproachSomeone>());
    }
};

关键细节 #

• 编译期强制限制：ApproachSomeone尝试调用目标函数时，会因无法获取合法令牌直接触发编译错误，彻底避免误用；
• 低侵入兼容：原有需要调用该函数的类，仅需在调用时添加getLocationToken<当前类>()参数，改动极小；
• 灵活可扩展：后续调整允许/禁止的类，只需修改模板友元的条件即可。

备选轻量方案：重载+delete #

如果不想引入令牌类，也可以通过函数重载结合delete关键字实现（局限性：若调用者通过基类指针或编译器无法推导类型，可能绕过限制）：

class ApproachSomeone;

class Location {
    std::list<Person*> everyonePresent;
public:
    // 原公共函数，供大多数类使用
    const std::list<Person*>& getEveryonePresent() const { return everyonePresent; }

    // 针对ApproachSomeone的重载，直接标记为delete禁止调用
    template<typename T = ApproachSomeone>
    const std::list<Person*>& getEveryonePresent() const = delete;
};

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