Need help overloading Polynomial class operators C++ - c++

Question

Ive been asked to overload this operator: p[d], to do two things,
Return the coefficiant of the polynomial where the degree is d so just p[d].
Change the coefficiant of the polyinomial where the degree is d so p[d]=c.
Im using linked list to make the polynomials.
This is th first one:
double Polynomial::operator[](const int num)
{
Monomial *ptr = NULL;
ptr = this->First;
while (ptr != NULL)
{
if (ptr->get_deg() == num)
{
return ptr->get_C();
}
ptr = ptr->GetNext();
}
return 0;
}
For the second one I was thinking of returning the adress of the monomial with the same degree and change its coefficiant but it doesnt work since both my functions need to get the same paramter( int degree).
This is my second function:
Monomial& Polynomial::operator[](const int num)
{
Monomial *ptr = NULL;
ptr = this->First;
while (ptr != NULL)
{
if (ptr->get_deg() == num)
{
return (*ptr);
}
ptr = ptr->GetNext();
}
return;
}
This is how its tested even though the second part isnt shown here:
cout << "p[0]=" << p[0] << ", p[1]=" << p[1] << ", p[2]=" << p[2] << ", p[4]=" << p[4] << endl;

Answer 1

You don't need two overloads here. Just change the return type of the first to double &.
p[d]=c;
will change the referenced value (the one stored in ptr) to c. This only works, when get_C() also returns a reference of course (Thanks to Holt for mentioning).
Another point, that might be worth mentionig are const instances, because you can't modify the values of const instances. So a one pattern for getters is the following:
class A {
private:
double d;
public:
// Overload for const instances, can't modify 'd' via the rturn value
const double &getD() const { return d; } const;
// for non-const instances
double &get() { return d; }
};
So for const instances (e.g. const A a)
a.getD() = 3;
won't compile, can't modify a const reference. For non-const instances of A this works and would change the actual value of the member d.
double d = a.getD();
will work for both and just copy the value to local variable.

Answer 2

The "canonical" implementation for operator[] can be seen on cppreference.com:
struct T
{
value_t& operator[](std::size_t idx) { return mVector[idx]; }
const value_t& operator[](std::size_t idx) const { return mVector[idx]; }
};
As you can see, the second overload is const-qualified. You cannot call the first overload on non-const object:
const T t;
t[0] = 1; // Error: t is not const, so the second overload is chosen, and you get
// a const value_type& you cannot assign to.
Depending on your implementation, it can make sense to return different type for the read and write overloads, so a correct version would be:
// Create a separate function to avoid duplicated code:
Monomial* Polynomial::get_monomial_or_throw(const int num) {
Monomial *ptr = this->First;
while (ptr != nullptr) {
if (ptr->get_deg() == num) {
return ptr;
}
ptr = ptr->GetNext();
}
throw std::out_of_range("");
}
// const-qualified version for read-only access:
double Polynomial::operator[](const int num) const {
return get_monomial_or_throw(num)->get_C();
}
// Not const-qualified version for write access:
Monomial& Polynomial::operator[](const int num) {
return *get_monomial_or_throw(num);
}