CODEWITHSUNDEEP
c++loopsif-statementdo-while
luigi
luigi

Reputation: 160

Stuck with code using if statements

This might be a non-sense question, but i'm kind of stuck so I was wondering if someone can help. I have the following code:

bool while_condition=false;

do{

   if(/*condition*/){
      //code
   }
   else if(/*condition*/){
      //code
   }
   else if(/*condition*/){
      //code
   }
   ...//some more else if
   else{
      //code
   }

   check_for_do_while_loop(while_condition, /*other parameters*/);

}while(while_condition);

the various if and else if exclude with each other but each have other if inside; if a certain condition is met (which can't be specified in a single if statement), then the code return a value and the do while loop is ended. But if, after entering a single else if, the conditions inside aren't met the code exit without actually doing nothing, and the while loop restart the whole.

I want the program to remember where he entered and avoid that part of the code, i.e. to avoid that specific else if he entered without any result, so he can try entering another else if. I thought about associating a boolean to the statements but I'm not quite sure on how to do it. Is there a way which allows me not to modify the code structure too much?

Upvotes: 1

Views: 448

Answers (1)

Steve Kidd
Steve Kidd

Reputation: 366

To give an idea of one way of approaching this that avoid loads of variables, here is an outline of how you might data-drive a solution.

class TestItem
{
public:
    typedef bool (*TestFuncDef)(const state_type& state_to_test, std::shared_ptr<result_type>& result_ptr);
    TestItem(TestFuncDef test_fn_parm)
    {
        test_fn = test_fn_parm;
        already_invoked = false;
    }

    bool Invoke(const state_type& state_to_test, std::shared_ptr<result_type>& result_ptr)
    {
        already_invoked = true;
        return test_fn(state_to_test, result_ptr);
    }

    bool AlreadyInvoked() const {return already_invoked; }
private:
    TestFuncDef test_fn;
    bool already_invoked;
};


std::shared_ptr<result_type> RunTest(std::list<TestItem>& test_item_list, state_type& state_to_test)
{
    for(;;) {
        bool made_a_test = false;
        for (TestItem& item : test_item_list) {
            std::shared_ptr<result_type> result_ptr;
            if (!item.AlreadyInvoked()) {
                made_a_test = true;
                if (item.Invoke(state_to_test, result_ptr)) {
                    return result_ptr;
                }
                else
                    continue;
            }
        }
        if (!made_a_test)
            throw appropriate_exception("No conditions were matched");
    }
}

This is not supposed to be a full solution to your problem but suggests another way of approaching it.

The important step not documented here is to build up the std::list of TestItems to be passed to RunTest. Code to do so might look like this

    std::list<TestItem> test_item_list;
    test_item_list.push_back(TestItem(ConditionFn1));
    test_item_list.push_back(TestItem(ConditionFn2));

The definition of ConditionFn1 might look something like

bool ConditionFn1(const state_type& state_to_test, std::shared_ptr<result_type>& result_ptr)
{
    // Do some work
    if (....)
        return false;
    else {
        result_ptr.reset(new result_type(some_args));
        return true;
    }
}

Upvotes: 1

Related Questions