Call order

[sreeni]

Can anyone suggest some mechanism where i can control the order of
function calls

Example

Base class has some methods(say 3 methods) used by

both derived class 1 , derived class 2

in derived class1 & 2 all these methods are invoked but the order is
different

Is there mechanism of making generic interface saying

from derived class 1 (inside a function) call base class methods (1 ,
2 ,3)
from derived class 2 (inside a function) call base class methods (3 ,
1 ,2)

 

[Pascal J. Bourguignon]

Can anyone suggest some mechanism where i can control the order of
function calls

Example

Base class has some methods(say 3 methods) used by

both derived class 1 , derived class 2

in derived class1 & 2 all these methods are invoked but the order is
different

Is there mechanism of making generic interface saying

from derived class 1 (inside a function) call base class methods (1 ,
2 ,3)
from derived class 2 (inside a function) call base class methods (3 ,
1 ,2)

Yes. That mechanism is the operator semi-colon.

class derived_1ublic base{
public:
void function(void){
base::method_1() ; base::method_2() ; base::method_3() ;
}
}


class derived_2ublic base{
public:
void function(void){
base::method_3() ; base::method_1() ; base::method_2() ;
}
}

 

[sreeni]

Yes. That mechanism is the operator semi-colon.

class derived_1ublic base{
public:
  void function(void){
       base::method_1() ;  base::method_2() ;  base::method_3() ;
  }

}

class derived_2ublic base{
public:
  void function(void){
       base::method_3() ;  base::method_1() ;  base::method_2() ;  
  }

}

Is it possible to do something like if(base::method_3() fails) then
base::method_1() etc..

Here all methods will be called whether required or not right?

 

[Pascal J. Bourguignon]

Is it possible to do something like if(base::method_3() fails) then
base::method_1() etc..

Of course. Perhaps you should start to learn C++ programming?

Here all methods will be called whether required or not right?

Only when they don't fail. When a method fails, it should throw an
exception, and then it's the next handler (try/catch) that will take
over, not the following statements.

On the other hand, if you want to run the following methods only when
the method fails, you can write:

try{
base::method_3();
}catch(...){
// it failed.
base::method_1();
base::method_2();
throw; // or not
}

 

[James Kanze]

Of course. Perhaps you should start to learn C++ programming?

Only when they don't fail. When a method fails, it should
throw an exception,

That depends on how it fails. In a lot of cases, the most
appropriate method of reporting a failure is a return code (and
in some cases, it is to abort---one size doesn't fit all).

If the functions return something which converts to true in case
of success, and false in case of failure, and you don't need to
capture the cause of the failure, then you can write something
like:

method_1() && method_2() && method_3() ;

A very typical C++ idiom, I would think.

and then it's the next handler (try/catch) that will take
over, not the following statements.

On the other hand, if you want to run the following methods
only when the method fails, you can write:

try{
base::method_3();}catch(...){

// it failed.
base::method_1();
base::method_2();
throw; // or not
}

Which is a perfect example of how not to write C++. If there is
any chance that the immediate caller will do something in case
of an error, you should report it by a return code (except, of
course, in cases where you can't, like constructors). In which
case, the above could be written:

method_3() || (method_1(), method_2()) ;

Or in the more likely case where he wants to stop with the first
success:

method_3() || method_1() || method_2() ;

 

[Pascal J. Bourguignon]

Which is a perfect example of how not to write C++.
If there is
any chance that the immediate caller will do something in case
of an error, you should report it by a return code (except, of
course, in cases where you can't, like constructors). In which
case, the above could be written:

method_3() || (method_1(), method_2()) ;

Or in the more likely case where he wants to stop with the first
success:

method_3() || method_1() || method_2() ;

Do however you want, I don't care, but in MY code, errors are handled
with try/catch and logical expressions are written with && and ||, not
the reverse.

 

[James Kanze]

Do however you want, I don't care, but in MY code, errors are handled
with try/catch

If you like bad code, you like bad code, but C++ has several
ways of handling errors for a reason.

and logical expressions are written with && and ||, not
the reverse.

Exactly. Handling errors locally is a job for logical
expressions.