c++ unless wrapper construct for flow control

Question

I have a program part that works similar to the following:

X->updateA();
X->updateB();
X->updateC();
X->updateD();

Each function is supposed to return an integer indicating whether it ran successfully or not, say int ret_val=0 if successful and int ret_val=1 if not.

I am wondering if there exists any wrapper construct that processes each function consecutively as long as ret_val == 0. In my case it shall also call X->updateD(); regardless of the value of ret_val.

Right now I have:

int ret_val = 0;
ret_val = X->updateA();
if (ret_val == 0) ret_val = X->updateB();
if (ret_val == 0) ret_val = X->updateC();
X->updateD();

Which I think is not really readable. What I'd prefer is something similar to the while-loop, although it would have to check for the condition after each function call. Something along the lines of this:

int ret_val = 0;
unless(ret_val != 0)
{
  ret_val = X->updateA();
  ret_val = X->updateB();
  ret_val = X->updateC();
}
X->updateD();

Is there any such construct?

score 1 · Accepted Answer · answered Mar 01 '15 at 19:46

1

You should use exceptions. Effectively they are an external control flow mechanism which means that you do not have to litter your regular code with error handling and manually propagate every error and check for errors on every call. With exceptions, your original code is perfectly valid as-is and the compiler generates code to check for errors and propagate them to the caller if one occurred.

answered Mar 01 '15 at 19:46

Puppy

144,682
38
256
465

Do not use exceptions for control flow. _Ever_. – Lightness Races in Orbit Mar 01 '15 at 19:48
(But do use them for this.) – Lightness Races in Orbit Mar 01 '15 at 19:49
Well, strictly speaking, they *are* a control flow mechanism, it's just best kept external – Puppy Mar 01 '15 at 19:56
After rereading about exceptions I agree, the use of them is pretty much what should be used here. In fact, the `try() {...} catch() {...}` construct itself reads already very much like what I proposed. Thanks! – alex Mar 02 '15 at 16:15

score -1 · Answer 2 · answered Mar 01 '15 at 19:49

-1

You should store pointers to the functions you wish to invoke in a container, then iterate over the container. That way you can do whatever you like with the result, and it'll be the same for each function call, without having to repeat that logic n times.

answered Mar 01 '15 at 19:49

Lightness Races in Orbit

378,754
76
643
1,055

@Puppy: Yes, or `std::function`. That is the conventional way to do `X` over _n_ function calls. – Lightness Races in Orbit Mar 01 '15 at 19:57
1

It's the "or `std::function`" part that's important. Also, it's only really conventional where X is very large or dynamic. – Puppy Mar 01 '15 at 19:57
@Puppy: `std::function` is effectively a function pointer. I don't think it's constructive to quibble over that. – Lightness Races in Orbit Mar 01 '15 at 19:59
1

There's a large mile of difference between a function pointer and std::function. As in, a function pointer is the `new` and `delete` of the "Store a function" world. – Puppy Mar 01 '15 at 20:02

c++ unless wrapper construct for flow control

2 Answers2