[Problem] Avoid having negative answers for subtraction.

[NovaPrimeveera]

Dear C++ community

I am currently faced with a problem with how to avoid receiving a negative number for subtraction.

My objective is to randomly generate a mathematical equation and save the answer to ,then check if the user is entering the correct answer.

My attempts:
------------

1) I tried to have two temp variables to store two random numbers ,then allocate the larger number to 'x' and smaller on to 'y'.

2) I also tried to have one temp variable to hold the value of 'x' (if larger than 'y') then switch the x and y variables, with temp holding the 'x' variable.

*Error encountered (in both attempts) *
---------------------------------------

7208908 (black square) 1961740832 = -2

2] Code :
==========

  struct MathEq{
    public:
    int x;
    int y;
    char symb[4] = {'+','-','/','\*'};
    char s;

    MathEq();
    int answer(int x,int y,int s);


int getX(){
   return x;
}

int getY(){
    return y;
}

char getSymbol(){
    return s;
}

};

MathEq::MathEq(){
    srand(time(NULL));
    int temp=0;

    int index = (rand() % 4) +1;
    s = symb[index];

    if(s == '/' || s == '*'){
        x = (rand() % 12) +1;
        y = (rand() % 12) +1;
    }

    if(s == '+' || s == '-'){
        x = (rand() % 100) +1;
        y = (rand() % 100) +1;
    }
}

int answer(int x,int y,char s){
    int a =0;

    switch(s){
        case '+':
            a = x + y;
            break;

        case '-':
            a = x - y;
            break;

        case '/':
            a = x / y;
            break;

        case '*':
            a = x * y;
            break;

    return a;
    }
}

int main(){
    MathEq  m;

    int answerM = answer(m.getX(),m.getY(),m.getSymbol());

    cout<< "Result is: "<<m.getX()<<" "<< m.getSymbol()<<" "<< m.getY() << " = "<< answerM<<endl;

}

[jonnin]

int index = (rand() % 4) +1;
s = symb[index];

this says take an number from 0-3 and add 1, its now 1-4.
symb is [4].
arrays are zero indexed. so symb supports [0], [1], [2], and [3]. 4 is out of bounds and zero is unreachable, the +1 is not correct.