Need help ASAP with error client.cpp|58|error: passing 'const Fraction' as 'this' argument discards qualifiers [-fpermissive]|"

My program runs fine without my shortcut key input, but when I use my shortcut key input I get this error... its a multi project file so I am going to include, error is on line 58 in client.cpp, i'll post my code for the files down below. It does everything it is supposed to do I just would like advice on how to stop this weird const error. *NOTE I CANNOT CHANGE THE CLIENT PROGRAM I HAVE TO USE IT AS IS*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/*Client.cpp is set-up as a Fraction class implementation and test driver program - DO NOT CHANGE SOURCE CODE
All necessary class objects are declared and defined here to test various class related operations.
HINT: see comments for specific class related function calls*/

#include <iostream>
#include <cassert>
#include "Fraction.h"
using namespace std;

int main()
{
    Fraction f1(9,8); //calling a parameterized class constructor
    Fraction f2(2,3);
    Fraction result; //calling a default class constructor
    const Fraction f3(12, 8);
    const Fraction f4(202, 303);
    Fraction f5,f6;

    cout<<"C++ CLASS MULTI-FILE PROJECT"<<endl;
    cout<<"Client.cpp - testing a Fraction class implementation\n";
    cout<<"----------------------------------------------------\n\n";

    cout << "The result object starts off at ";
    result.showFraction(); //calling a void "observer" function
    cout << endl;


    cout<<"\nArithmetic operations with Fraction objects stored in the results class object\n";
    cout<<"------------------------------------------------------------------------------\n\n";

    cout << "The sum of ";
    f1.showFraction();
    cout << " and ";
    f2.showFraction();
    cout << " is ";
    result = f1.AddedTo(f2); //a class binary operation - a value-returning "observer" function
    result.showFraction();
    cout << endl;

    cout << "The difference of ";
    f1.showFraction();
    cout << " and ";
    f2.showFraction();
    cout << " is ";
    result = f1.Subtract(f2); //a class binary operation - a value-returning "observer" function
    result.showFraction();
    cout << endl;

    cout << "The product of ";
    f1.showFraction();
    cout << " and ";
    f2.showFraction();
    cout << " is ";
    result = f1.MultipliedBy(f2); //a class binary operation - a value-returning "observer" function
    result.showFraction();
    cout << endl;

    result = f3.DividedBy(f4); //a class binary operation - a value-returning "observer" function
    cout << "The quotient of ";
    f3.showFraction();
    cout << " and ";
    f4.showFraction();
    cout << " is ";
    result.showFraction();
    cout << endl;

    cout<<"\nInput and Output operations for two new class objects\n";
    cout<<"-----------------------------------------------------\n\n";

    f5.getFraction(); //a class input operation - a transformer or setter function
    f5.showFraction(); //a class output operation - an observer or getter function
    cout<<endl<<endl;
    f6.getFraction();
    f6.showFraction();
    cout<<endl<<endl;

    cout<<"\nA Boolean operation comparing two class objects\n";
    cout<<"------------------------------------\n\n";

    if (f5.isGreaterThan(f6))
    { //a class relational expression - boolean operation/function
        f5.showFraction();
        cout <<" is greater than ";
        f6.showFraction();
        cout<<endl;
    }
    else
    {
        f5.showFraction();
        cout <<" is less than ";
        f6.showFraction();
        cout<<endl;
    }

    cout<<"\n---------------------------------------------------------\n";
    cout<<"\nFraction class implementation test now successfully concluded\n";

// system ("PAUSE");

return 0;
}
Last edited on
Here is my implementation file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <iostream>
#include <cassert>
#include "Fraction.h"
using namespace std;

//Fraction class implementation

/*void Fraction::set(long newNumerator, long newDenominator)
{
        num = newNumerator;
        denom = newDenominator;
}   */

void Fraction::showFraction()
{
    cout << num << "/" << denom;
}

void Fraction::getFraction()
{
   cout << "\nEnter values for a fraction object\n";
   cout << "Numerator: ";
   cin >> num;          //validation check
   cout << "Denominator: ";
   cin >> denom;             //validation check

    Fraction(num, denom);
}

void Fraction::simplify()
{
    for(int i = num * denom; i > 1; i--)
    {
        if((num % i) == 0 && (denom % i) == 0)
        {
            num = num / i;
            denom = denom / i;
        }
    }
}

Fraction::Fraction()
{
    num = 0;
    denom = 1;
}

Fraction::Fraction(long newNumerator, long newDenominator)
{
        num = newNumerator;
        denom = newDenominator

        assert(newDenominator != 0);

}

Fraction Fraction::multipliedBy(Fraction result)
{
    Fraction f1;

    f1.num = num*result.num;
    f1.denom = denom*result.denom;

    f1.simplify();

    return f1;
}

Fraction Fraction::dividedBy(Fraction result)
{
    Fraction f1;

    f1.num = num*result.denom;
    f1.denom = denom*result.num;
    f1.simplify();


    return f1;
}

Fraction Fraction::addedTo(Fraction result)
{
    Fraction f1;

    f1.num = result.num * denom + num * result.denom;
    f1.denom = denom*result.denom;
    f1.simplify();

    return f1;
}

Fraction Fraction::subtract(Fraction result)
{
    Fraction f1;

    f1.num = num * result.denom - result.num * denom;
    f1.denom = denom * result.denom;
    f1.simplify();
    return f1;
}

/*bool Fraction::isEqualTo(Fraction somefract)
{
    if(denom*num == somefract.num*somefract.denom)
    {
        return true;
    }
    else
        return false;
}   */

bool Fraction::isGreaterThan(Fraction somefract)
{
    if(denom/num > somefract.num/somefract.denom)
    {
        return true;
    }
    else
        return false;
}
Last edited on
Here is my header file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//Class Specifier for Fraction
class Fraction
{
public:
    //Function members in class of the public section
    //void set(long, long);
    void showFraction();
    void getFraction();
    Fraction(); //Default Constructor
    Fraction(long, long);    //Constructor
    Fraction MultipliedBy(Fraction);
    Fraction DividedBy(Fraction);
    Fraction AddedTo(Fraction);
    Fraction Subtract(Fraction);
   // bool isEqualTo(Fraction);
    bool isGreaterThan(Fraction);

private:
    //Two long integer members in the private class section
     long num;
     long denom;

    void simplify();
};
Last edited on
I don't see anything about "shortcut keys" in your program.

However, it's important to make a member function const if you can (i.e., if it doesn't modify *this). All of your functions can be made const except for the ctors, getFraction and simplify.

1
2
3
4
5
6
7
8
// header
Fraction MultipliedBy(Fraction) const;

// impl
Fraction Fraction::multipliedBy(Fraction result) const
{
    //...
}

Note that some of your function names are apparently not capitalized properly.
It was my functioncapitalization omgggggg
Last edited on
Topic archived. No new replies allowed.