Question

//function declerations
void func_A();
void func_B();
void func_SubA();

//main
int main(){ ... }

//function definitions
void func_A(){ ... }
void func_B(){ ... }
void func_SubA(){ ... }

确保只能在 func_A（）内调用 func_SubA（）的最佳方法是什么？
如果 func_B（）试图调用 func_SubA（），我希望收到编译器错误。

Answer 1

您可以将要限制访问的函数声明为类的私有成员，然后使用friendship来授予访问权限。

class Balloon 
{
private: // private is the default. we just want to be explicit
    friend void Ken();
    friend void Barbie();

    static void Pop();
};

void Ken() {
    Balloon::Pop(); // We are allowed to pop it!
}

void Barbie() {
    Balloon::Pop(); // We are allowed to pop it too!
}

void Jack() {
    Balloon::Pop(); //  Access Denied! we must be in a time out!
}

Answer 2

另一种方法是将func_A()和func_SubA()的定义放在不同的翻译单元（cpp文件）中，并使func_SubA()在此文件外不可见，方法是static或将其放在匿名命名空间中：

// FILE main.cpp
//function declarations: possibly in a header file
void func_A();
void func_B();
// don't declare func_SubA() here
int main(){ /* ... */ }
void func_B(){ /* ... */ } // could also have its onw cpp file
// EOF main.cpp

// FILE func_A.cpp
static void func_SubA(){ /* ... */ }
/* or
namespace {
    void func_SubA(){ ... }
}
*/
void func_A(){ /* calls func_SubA() */ }
// EOF func_A.cpp

另一种方式，正如JesseTG所建议的那样，我只是在这里说清楚，是使用lambda表达式：

//function declarations
void func_A();
void func_B();
// don't declare func_SubA();

int main(){ /* ... */ }

//function definitions
void func_A(){
    // define func_SubA through a lambda
    auto func_SubA = [](){ /* the body of func_SubA */ };
    // ...
    func_SubA(); // calls func_SubA()
    // ...
}
void func_B(){ /* ... */}

Answer 3

您可以使用通常的面向对象方式（私有方法等），也可以使用lambda函数，这是C ++ 11中的一项新功能。您可以阅读它们here或here，它们并不难用。 Lambda函数允许您访问任何代码块所在的变量。

Answer 4

函数声明也可以是本地的。如果您将func_SubA 的前瞻性声明置于 funcA()内，那么您应该做得很好。

如何使函数只能从另一个函数调用？

4 个答案: