Question

问题我有几个函数需要按定义的顺序调用，顺序不能破坏。现在代码需要继续并在我完成代码后开发。我正在寻找一些方法来设置某种牢不可破的结构中的功能。例如我有：

function_1() { //do some stuff ..} ;  // must be first  
function_2() { //do some stuff based on function_1()..};  // must be second 
function_3() { //do some stuff based on function_1() and function_2()..};;  // must be third

他们都在main（）应用程序功能下。

Answer 1

为公共访问创建另一个函数，保证以正确的顺序调用其他三个函数。为了防止这些函数在公共API中可见，您可以将它们隐藏在未命名的命名空间中。

在标题栏中

 bool function_4();

在相应的翻译单元中，您可以创建一个未命名的命名空间，以防止其他人看到这些功能

 namespace {
     bool function_1() {
     }
     bool function_2() {
     }
     bool function_3() {
     }
 }

并定义function_4

 bool  function_4() {
     return function_1() &&
            function_2() &&
            function_3();
 }

Answer 2

您可以创建包装功能

bool execute()
{
    return function_1() && function_2() && function_3();
}

将按顺序调用这些函数，如果任何函数失败，它将会短路。假设函数返回bool表示成功/失败，如果函数返回true所有函数成功完成，否则至少其中一个函数失败。

Answer 3

您可以尝试的一个方法是让function_1()返回只能构造的类型，然后将其用作function_2()的参数

class created_by_function_1 {
   created_by_function_1() { /* private constructor */ }
   friend created_by_function_1 function_1();
 };

created_by_function_1 function_1() { 
  // do stuff
  return created_by_function_1();
}

void function_2(created_by_function_1) {
}

现在，如果您第一次调用function_2，则只能使用function_1。

auto proof = function_1();
function_2(proof); // OK

function_2(created_by_function_1()); // Compilation error

我建议不要使用它：）

Answer 4

排序函数的简单情况是创建一个由用户调用的单个函数，它执行所有三个子函数。但是，这并不总是有效。在调用function1之前，用户可能需要在function2之后进行一些处理。在这种情况下，您需要某种额外的上下文，例如

class Context
{
   friend Function1, Function2, Function3;
   enum State 
   {
     f0, f1, f2, f3 
   } state;
public:
   Context() { state = f0; }
   ~Context() { if (state != f3) { ... may need to do stuff... }
}

void Function1(Context &ctxt)
{
   assert(ctxt.state == f0);
   ctxt.state = f1;
   ... 
}


void Function2(Context &ctxt)
{
   assert(ctxt.state == f1);
   ctxt.state = f2;
   ... 
}

void Function3(Context &ctxt)
{
   assert(ctxt.state == f2);
   ctxt.state = f3;
   ... 
}

int main()
{
   Context c;

   Function1(c);
   ...
   Function2(c);
   ...
   Function3(c);
   // c will be destroyed and check that state is f3.
}

Answer 5

我认为你有一些坚实的理由不将所有这三个功能都包含在一个单一的功能中。

在这种情况下，最简单的方法是管理在所有三个功能之间共享的状态：

static int function_status=0;    // shared status:  nothing was called 

function_1() { 
    if (status>0) 
       throw exception ("function_1 MUST be called first and only once");
    status=1;  // function_1 was called
    ...
}   
function_2() {
    if (status<1) 
       throw exception ("function_1 MUST be called before 2");
    else if (status>2) // I suppose function 2 could be called several times
       throw exception ("function_2 CANNOT be called after 3");
    status = 2;   
    ...
}
function_3() {
    if (status<2) 
       throw exception ("function_2 MUST be called before 3");
    else if (status==3) 
       throw exception ("function_3 CAN ONLY BE CALLED ONCE");
    status = 3; 
    ...
}

如您所见，如果执行流程遵循您想要的逻辑，此状态使您有机会检查非常精确。

c ++如何定义需要为其他开发人员调用的常量函数顺序

5 个答案: