This thread may be too much for a newbie without additional context.

I think that the design questions being discussed are extremely important.

I've provided some source that may give a newbie enough context to follow along without necessarily understanding the finer points.

The small details, such markup as names and layout, are optional of course; it is the concepts shown that are center to the discussion.

Soma

Code:`// The preferred approach whenever possible.`

double Calculator::run()

{

// ...

switch(lOperation)

{

// ...

case Add:

{

// ...

// We are going to perform the addition operation.

// The addition operation is a binary operation.

// We know we need two values in the stack.

// We know that the operation can't fail if the precondition is valid.

// We have a way to get the size of the stack. (Precondition.)

// ...

if(2 <= lValues.size())

{

double lLHS(lValues.top());

lValues.pop();

double lRHS(lValues.top());

lValues.pop();

// ...

}

// ...

}

// ...

}

// ...

}

Code:`// This is not as clean as the above, but it is usually possible.`

double Calculator::run()

{

// ...

switch(lOperation)

{

// ...

case Add:

{

// ...

// We are going to perform the addition operation.

// The addition operation is a binary operation.

// We know we need two values in the stack.

// We know that the operation can't fail if the precondition is valid.

// We have no way of knowing how many items are in the stack.

// We can check if the stack is empty. (Precondition.)

// ...

double lLHS(0.0);

double lRHS(0.0);

if(!lValues.empty())

{

lLHS = lValues.top();

lValues.pop();

if(!lValues.empty())

{

lRHS = lValues.top();

lValues.pop();

// ...

}

else

{

// ...

// We have to deal with the error in some fashion.

// ...

}

}

// ...

// ...

}

// ...

}

// ...

}

Code:`// This is a totally unacceptable approach which no one is advocating and included only for completeness.`

double Calculator::run()

{

// ...

switch(lOperation)

{

// ...

case Add:

{

// ...

// We are going to perform the addition operation.

// The addition operation is a binary operation.

// We know we need two values in the stack.

// We know that the operation can't fail if the precondition is valid.

// We have no way of knowing how many items are in the stack.

// We will not check if the stack is empty for this example. (Precondition.)

// We know that the operation does nothing in the face of a precondition violation.

// We know that the operation does not do any notification in the face of a precondition violation.

// ...

double lLHS(0.0);

double lRHS(0.0);

lLHS = lValues.top();

lValues.pop();

lRHS = lValues.top();

lValues.pop();

// ...

// We have no way of knowing if an error occurred.

// ...

}

// ...

}

// ...

}

Code:`// The approach centered around returning a boolean value.`

double Calculator::run()

{

// ...

switch(lOperation)

{

// ...

case Add:

{

// ...

// We are going to perform the addition operation.

// The addition operation is a binary operation.

// We know we need two values in the stack.

// We know that the operation can't fail if the precondition is valid.

// We have no way of knowing how many items are in the stack.

// We will not check if the stack is empty for this example. (Precondition.)

// We know that the operation does nothing in the face of a precondition violation.

// We know that the operation does notification in the face of a precondition violation.

// ...

double lLHS(0.0);

double lRHS(0.0);

lLHS = lValues.top();

if(lValues.pop())

{

lRHS = lValues.top();

if(lValues.pop())

{

// ...

}

else

{

// ...

// We have to deal with the error in some fashion.

// ...

}

}

}

// ...

}

// ...

}

Code:`// The approach centered around raising an exception.`

double Calculator::run()

{

// ...

switch(lOperation)

{

// ...

case Add:

{

// ...

// We are going to perform the addition operation.

// The addition operation is a binary operation.

// We know we need two values in the stack.

// We know that the operation can't fail if the precondition is valid.

// We have no way of knowing how many items are in the stack.

// We will not check if the stack is empty for this example. (Precondition.)

// We know that the operation raises an exception in the face of a precondition violation.

// ...

double lLHS(lValues.top());

lValues.pop();

double lRHS(lValues.top()); // We know the `pop' operation was successful or we wouldn't have gotten to this point in code.

lValues.pop();

//

// We know the `pop' operation was successful or we wouldn't have gotten to this point in code.

// ...

}

// ...

}

// ...

}

// ...

void Calculator::apply

(

const char * fExpression

)

{

// ...

try

{

// ...

run();

// ...

}

catch(...)

{

// ...

// We have to handle the error in some fashion.

// ...

}

// ...

}

// ...