Overloaded operator in derived class

Question

I am studying Lafore's 4th editing of C++ book and I am stuck with this problem.

I have these two classes, CountDn derives from Counter. In CountDn I want to overload the prefix for decrement operator and the postfix for both increment and decrement.

It works with all the operators except when I try to do ++c11.

I get these errors from the compiler:

50:10: error: no match for 'operator++' (operand type is 'CountDn')

50:10: note: candidate is:

41:13: note: CountDn

CountDn::operator++(int)

41:13: note: candidate expects 1 argument, 0 provided

Even though get_count() works fine I do not understand why the prefix operator does not work.

My thoughts here is if CounterDn class derives from Counter all the functions that are public should be accessible. What can I revise so I can understand the solution for this problem better?

#include <iostream>
using namespace std;

class Counter{
protected:
    unsigned int count;                //count
public:
    Counter() : count(0)               //constructor, no args
    {  }
    Counter(int c) : count(c)          //constructor, one arg
    {  }
    unsigned int get_count() const     //return count
    {
        return count;
    }
    Counter operator ++ ()             //incr count (prefix)
    {
        return Counter(++count);
    }
};


class CountDn : public Counter{
public:
    CountDn() : Counter()              //constructor, no args
    { }
    CountDn(int c): Counter(c)       //constructor, 1 arg
    { }
    CountDn operator -- ()             //decr count (prefix)
    {
        return CountDn(--count);
    }

    CountDn operator --(int){
        return CountDn(count --);
    }
    CountDn operator ++(int)
    {
        return CountDn(count++);
    }
};

int main() {
    CountDn c1(10),c2;
    c2 = ++c1;
    cout << c1.get_count() << endl;
    return 0;
}

i edited the error list, also i have not been taught virtual functions yet, just classes, with ctor, dctor, inheritance and operator overloading — Stef, Aug 20 '18 at 17:20
Redefining non-virtual functions in a class hierarchy is almost always an error. Public inheritance without a virtual destructor is also rather suspicious. — n. m. could be an AI, Aug 20 '18 at 17:25
`operator++(int)` in the derived class *hides* `operator++()` from tge base class. If you want to use it in the derived class, you have to define it there, or say `using CountDn::operator++;`. — n. m. could be an AI, Aug 20 '18 at 17:30

R Sahu · Answer 1 · 2018-08-20T17:41:56.150

4

operator++() and operator++(int) are two overloads of the operator++ function.

When the compiler sees the operator++(int) function in the derived class, it does not look for other overloads of the function. Hence, operator++() is not found when trying to compile the line

c2 = ++c1;

Consequently, the pre-increment operator is not found from the base class. You can use the using declaration to bring the pre-increment overload from the base class into the derived class.

class CountDn : public Counter{
  public:

    using Counter::operator++;

    CountDn() : Counter()              //constructor, no args
    { }
    CountDn(int c): Counter(c)       //constructor, 1 arg
    { }
    CountDn operator -- ()             //decr count (prefix)
    {
        return CountDn(--count);
    }

    CountDn operator --(int){
        return CountDn(count --);
    }
    CountDn operator ++(int)
    {
        return CountDn(count++);
    }
};

Now, both the overloads of operator++ are usable for a CountDn object.

However, the following would still be a problem

c2 = ++c1;

since the pre-increment operator returns a Counter object, not a CountDn object. You can use:

++c1;
c2 = c1;

to get around that problem.

edited Aug 20 '18 at 17:41

answered Aug 20 '18 at 17:30

R Sahu

204,454
14
159
270

i tried this solution and doing ++c1; works, however when i do c2= ++c1; this is the errors i get In function 'int main()': 47 5 [Error] no match for 'operator=' (operand types are 'CountDn' and 'Counter') 47 5 [Note] candidate is: 22 7 [Note] CountDn& CountDn::operator=(const CountDn&) 22 7 [Note] no known conversion for argument 1 from 'Counter' to 'const CountDn&' – Stef Aug 20 '18 at 17:37
2

i guess this is because the prefix++ operator returns a Counter object and c2 is a CountDn object – Stef Aug 20 '18 at 17:40
@Stef, that's exactly right. See the updated answer. – R Sahu Aug 20 '18 at 17:42
thanks alot, this solved my question and u help with understanding the problem, i have never used using command before but i will look a bit into it – Stef Aug 20 '18 at 17:58

Swapnil · Answer 2 · 2018-08-20T17:28:39.727

0

CountDn operator ++(int) // For Postfix operator
{
    return CountDn(count++);
}

CountDn operator ++() // For prefix operator
{
    return CountDn(count++);
}

Add both the version prefix operator is with no argument and postfix operator is with argument. You have used the prefix operator in your main function hence need to add the without argument function.

edited Aug 20 '18 at 17:28

answered Aug 20 '18 at 17:21

Swapnil

1,424
2
19
30

1

if i remove the int argument, how does the compiler distunguish between postfix and suffix? – Stef Aug 20 '18 at 17:23
@Stef add both the version. Without Argument is for prefix operator (which is used in your program) and with argument is for postfix operator. – Swapnil Aug 20 '18 at 17:29

Overloaded operator in derived class

2 Answers2