How to invoke struct member functions based on return value of a bool type member function?

Question

I want to do some conditional checks within a bool member function of a struct. How will my struct object struct1 know the bool member function has returned true, so that integers a & b can be used within the calc member function?

int main() {
    vector<Point> pt;
    pt.push_back(Point{ 1.5, 4.2 });
    pt.push_back(Point{ 2.4, 3.1 });

    doSth struct1;
    bool tempbool = struct1.memfuncbool(pt); //error starts here!
    if (tempbool) {int answer = struct1.calc(1);} //??
    std::cout << answer;

    return 0;
}

struct Point {
   double _x;
   double _y;
};

struct doSth {

    int a, b; //data members

    int calc(const int k) {
        return (a + b)*k;
    }

    bool memfuncbool(const vector<Point> &pts) {        

        //does stuff...

        a = var1;  //var1 = 1
        b = var2;  //var2 = 2

        return true;
    }
}

Answer 1

Your code has many issues that could easily be solved if you didn't try to do more than you know.

1 You're defining both Point and doSth structures AFTER the main function. So the main function has no way to know what your structures do. Normally you would use a header file to contain the declaration and the cpp file to contain the implementation, but since you're doing a small program you can just move the definitions of your structures to be above the main function. Alternatively you can declare your structures above main and implement them below, like this.

// Definition of struct Point
struct Point {
   double _x;
   double _y;
};

// Definition of struct doSth
struct doSth {
    int a, b; //data members

    // **Declaration** of doSth methods
    int calc(const int k);
    bool memfuncbool(const std::vector<Point> &pts);
};


int main() {
    ...
}

// Definition of calc method
int doSth::calc(const int k) {
    ...
}

// Definition of memfuncbool method
bool doSth::memfuncbool(const std::vector<Point> &pts) {        
    ...
}

2 In the main function you're using a variable called answer in a scope that doesn't know such variable.

if (tempbool) {
    int answer = struct1.calc(1);
}
std::cout << answer; // ERROR: answer is not a known variable

See, you're declaring a variable inside an if condition but using it outside. You have to declare the variable outside as well if you want to use it.

int answer = 0;
if ( tempbool ) {
    answer = struct1.calc(1);
}
std::cout << answer << std::endl; // OK

OR

if ( tempbool ) {
    int answer = strut1.calc(1);
    std::cout << answer << std::endl;
}
else {
    std::cout << "Invalid result!" << std::endl;
}

This is a fix to compile what you have done so far. But this is not a solution to your code design question.

3 Code Design Although I suggested quick fixes to your code your actual problem has to do with how you design your classes and structure your code. I've showed you what you did wrong in your code, but your problem can be solved using a better structured approach.

While writing my answer Beyeler already answered this part for you, so check his answer.

EDIT

In your code you are probably doing

using namespace std;

But you've written both vector< Point > and std::cout. You should not use the using line, to begin with, to avoid name collisions and to help YOU know where this vector is coming from.

However, if you insist on using this line so you don't have to write std:: (and it's OK if you know what you're doing), don't go typing std:: on one thing and then omit it in another. Be consistent, either use it or don't.

Answer 2

There are two approaches: encapsulation for caller safety and pure code discipline. In the later you yourself make sure that the code you write is always aware of the latest result of memfuncbool and when and where a and b are set.

In the first you can add a flag in your struct that you set once memfuncbool is called and check in calc (and handle it appropriately.) In that case you should also make sure that the flag is cleared when initialising your struct - either via constructor or again code discipline (like always zero your structs).

An information hiding approach (C++) in the first sense would look like this:

class DoSth {
    int a, b;
    bool valid;

public:
    DoSth() : valid(false) { }

    bool isValid() const { return valid; }

    /// returns calc if valid, otherwise 0
    int calc(int k) const {
        return isValid() ? (a + b) * k : 0;
    }

    void setSth(...) {
        a = ...
        b = ...
        valid = true;
        // instead of returning here the caller can check isValid() anytime
    }
};

Answer 3

I found three errors with your code:

1. "do" is a c++ keyword. You can't use it to name structs.

2. The parameter of the "memfuncbool" is missing its type. const& is not a type.

3. Missing semicolon after struct definition.

Also i supposed that var1, var2 and arg are well defined. If they are not even that is a error.

After correcting these errors maybe you can do something like-

if(tempbool) { /*statements*/ };