Как сделать функцию вызываемой только из другой функции?

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_SubA() может вызываться только внутри func_A ()?
Я хотел бы получить ошибку компилятора, если func_B() попыталась вызвать func_SubA().

Answer 1

Вы можете объявить функции, к которым вы хотите ограничить доступ, как частные члены класса, а затем использовать дружбу для предоставления доступа.

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 и проясняемый здесь, заключается в использовании лямбда-выражений:

//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

Вы можете сделать это обычным объектно-ориентированным способом (частные методы и т. Д.) Или использовать лямбда-функции, что является новой функцией в C++11. Вы можете прочитать их здесь или здесь, они не сложны в использовании. Лямбда-функции позволяют вам обращаться к переменным, которые являются локальными для любого блока кода, в котором они содержатся.

Answer 4

Объявления функций также могут быть локальными. Если вы поставите предварительную декларацию за func_SubA внутри funcA(), ты должен быть хорошим.