c++ how to define constant function order that needs to be invoked for other developers

Question

The problem i have that i have several functions that needs to be invoked in defined order the order can't be breakable. now the code need to be continued and develop after i finish to code. im looking for some method to set the functions in some kind of unbreakable structure. for example i have:

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 

they all under the main() app function .

Answer 1

Create another function for public access, that guarantees the other three functions are called in the correct order. To prevent those functions are visible with the public API, you can hide them in an unnamed namespace.

In your header put

 bool function_4();

In your corresponding translation unit you create an unnamed namespace to prevent others from seeing those functions

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

And define function_4

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

Answer 2

You can create a wrapping function

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

The functions will be called in order, and it will short circuit if any of the functions fail. Assuming the functions return a bool indicating success/failure, if the function returns true all functions successfully completed, otherwise at least one of them failed.

Answer 3

One hack you can try is to have function_1() return a type that only it can construct and then use this as a parameter to 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) {
} 

Now you can only use function_2 if you first called function_1.

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

function_2(created_by_function_1()); // Compilation error

I would advise against using this :)

Answer 4

The simple case of ordering functions is to make a single function that is called by the user, that does all three of the subfunctions. However, this doesn't always work. The user may need to do some processing after function1 before calling function2. In that case, you need some kind of extra context, e.g.

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

I suppose that you have some solid reasons not to wrap all these three functions into one single function.

In this case the simplest approach, would be to manage a status that is shared between all the three functions:

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; 
    ...
}

As you see, this status gives you the opportunity to check very precisely if the flow of execution respects the logic that you want.