could not convert from 'unsigned int' to 'unsigned int&'

Question

I'm creating a method and one parameter of that method asks for a reference of an unsigned int, but I want to put a default value on that parameter. For example:

#include <iostream>

using namespace std;

class A {
public:
    void sender();
private:
    unsigned int score = 10;
};

class B {
public:
    void receiver(unsigned int & score);
};

void A::sender() {
    cout << "Before: " << score << endl;
    B b;
    b.receiver(score);
    cout << "After: " << score << endl;
}

void B::receiver(unsigned int & score) {
    score = 100;
}

int main() {
    A a;
    a.sender();
    return 0;
}

Live demo: in here

The error happen when I do this:

void receiver(unsigned int & score = 10u);

And the compiler returns:

error: could not convert ‘10u’ from ‘unsigned int’ to ‘unsigned int&’

Live demo: in here

Answer 1

You cannot assign a literal¹ to a non-const reference.

There are two scenarios where one will suit your situation:

You intend to modify the argument being passed to receiver()

If that is the case, the use a non-const reference (unsigned int & score) without the default parameter. In situations where you pass a literal or temporary object to it, then it will result in a compiler error.

a.receiver(10);  // Error

The above wouldn't make any much sense considering that you want to modify that argument (you wouldn't see the modification if C++ had allowed that²).

You intend to just use the parameter in a read-only fashion

Just use plain, non-reference, unsigned int, because const unsigned int& score is just a pain to write. In cases where you determine that an object is expensive to copy, then that is the time where you should have the parameter a const reference.

UPDATE: There are some cases where you want to modify something, but that something may or may not exist. In cases like that, you may want to use a non-owning pointer as the parameter.

   // Declaration
   void receiver(unsigned int* score = nullptr);

void B::receiver(unsigned int* score) {
    if(score) *score = 100;
}

...

a.receiver();    // Uses the default parameter

unsigned int x;
a.reciever(&x);

In this case, it only assigns to score when it points to some (assumed) valid variable. Pointers aren't that bad at all.

UPDATE 2: However, as @Potatoswatter have pointed out, you may be better off with function overloading.

void B::receiver() {
    // Do something else
}

void B::receiver(unsigned int& score) {
    score = 100;
}

You should use this in cases where you want your overloads to behave differently on different parameters.

However again, I prefer the first, non-default parameter option, rather than the pointer option and the overloading option, as it requires that the caller provide a parameter, which is much better when you are modifying something through a function.

UPDATE 3: You should also consider to have your function return the value instead of modifying it through a parameter. In cases where you don't need the current state of the object being modified, having a function return a value is much more intuitive. One caveat though is that the caller may forget to capture (assign) the return value, which could be dangerous if you are using that value as some resource ID to free something up.

---

¹ And in general, a temporary object.

² _{And the universe would probably blow up if 10 was magically transformed into 100 ;)}

Answer 2

You want the argument type to be const unsigned int&. Otherwise, you can do something crazy, like try to assign 10 = 20, which doesn't make sense.

And that happens to be exactly that you did. The score = 100 line doesn't seem to be what you actually meant.

Answer 3

the value "10" isn't a reference- it's a value. By having a by-reference parameter, it must be called with a reference. Using a default parameter means you could call the function without specifying the parameter and the compiler would use the default.

Similarly, calling b.receiver(10); is not valid, but

int someInt = 10;
b.receiver(someInt);

is valid.