providing a reference-type argument for pass-by-reference c++ function

Question

I have a very boring question.

I thought, when you do pass-by-reference for a C++ function, you literally have to pass a reference-type argument (or parameter?). But I saw in the resource that I am learning from, and all over the web basically, that I was wrong.

So, what is the real difference between these two and why both of them work?

scenario_1

#include <iostream>

int sum(const int& a, const int& b)
{
    return (a + b);
}

int main()
{
    const int a1 {2};
    const int a2 {20};
    
    std::cout << sum(a1, a2) << "\n";
}

scenario_2

#include <iostream>

int sum(const int& a, const int& b)
{
    return (a + b);
}

int main()
{
    const int& a1 {2};
    const int& a2 {20};
    
    std::cout << sum(a1, a2) << "\n";
}

Do you understand [What is a reference variable in C++?](https://stackoverflow.com/questions/2765999) — JaMiT, Aug 16 '21 at 01:30
Do you understand why `int& a1 {2};` (omitting the `const`) does not work even if you don't call `sum()`? — JaMiT, Aug 16 '21 at 01:32
If you changed the definition of `a1` and `a2` to `int a1 {2};` and `const int& a2 {a1};`, would you understand what that means? *Calling `sum(a1, a2)` in this scenario works, by the way.* — JaMiT, Aug 16 '21 at 01:35
`const int& a` means that `a`, the local variable of the function `sum`, is a `const` reference to an `int. The `int` it refers to does not, itself, have to be a reference to anything. It doesn't even need to be `const`. When you call `sum(a1, a2)`, it's making `a` a reference to `a1` and `b` a reference to `a2` without imposing requirements on whether or not `a1` and `a2` are, themselves, reference types. — Nathan Pierson, Aug 16 '21 at 01:35
(Sorry if my questions seem odd. The difference between the two scenarios is a bit technical, so giving an understandable answer might depend on your current level of understanding.) — JaMiT, Aug 16 '21 at 01:41
@JaMiT, thank you for taking the time to guide me towards definitions that I need to understand better (I always try to read the texts assuming that it has a positive and friendly-ish tone. If not like that, then we are gonna infer some tone from the comment/text based on our current mood :D; not productive). — Alireza Amani, Aug 16 '21 at 15:56
It looks like Sam was able to give an acceptable answer, from which I'll infer it was understandable ;). I'll leave my earlier comments, though, since they might be helpful to some future readers, perhaps as a "review quiz" to self-assess their current knowledge. — JaMiT, Aug 16 '21 at 23:38

score 1 · Answer 1 · answered Aug 16 '21 at 01:41

A reference refers to an object instance somewhere else. When you use a reference to an object, all uses of that reference are as though you are using that original object. This allows one T& to reference another T&, etc -- but eventually it will have to reference an existing T object from somewhere.

This answers the "why does it work" part of your question; because a reference simply refers to the instance itself.

The answer to your other question of "what is the real difference between these two" is a little more complicated. const references in C++ are a little weird in that they are capable of extending the lifetime of temporary objects.

All objects in C++ have lifetime. Ordinarily, the lifetime of an object starts when they are created, and ends at the end of their scope -- whether this is just all part of an expression, or up to the literal ending } scope. References view that lifetime, but don't normally affect the lifetime (which means that returning a reference to a temporary, for example will produce a dangling reference to an object that is no more).

const references, on the other hand, extend the lifetime to the length of the enclosing scope. So when you have:

const int& a1 {2};
const int& a2 {20};

What you are actually doing is creating two temporary unnamed objects with values 2 and 20, and the const int& is extending the lifetime of these variables.

This is as if you did something like:

const int __unnamable_value_1 = 2;
const int __unnamable_value_2 = 20;

const int& a = __unnamable_value_1;
const int& b = __unnamable_value_2;

For the most part, I would recommend not thinking about this weirdness of C++. If you want to create a named value, create it by value (e.g. const T). If you want to refer to an object possibly not constructed in the same place, use a reference (const T&).

Sam Varshavchik · Accepted Answer · 2021-08-16T16:57:14.487

C++ has a lengthy, and occasionally confusing list of rules by which objects of one type are automatically converted to objects of some other, related type.

For example, you might have a function that takes a const char * as a parameter, such as:

size_t strlen(const char *);

Despite that its parameter is a const char *, you have excellent chances of success passing a non-const char array to this function:

char buffer[256];

// Some code.

size_t l=strlen(buffer);

Your question regarding references is exactly the same thing. A modifiable lvalue is automatically convertable to a reference to a const object of the same type. You don't have to worry about it, the compiler will do it for you.

There are many other rules too. This might be your first introduction to C++'s automatic conversion rules (or implicit conversion rules). It won't be your last.

So, what is the real difference between these two and why both of them work?

There's no practical difference. There are some pedantic differences between the two versions, but they produce identical logical results.

providing a reference-type argument for pass-by-reference c++ function

2 Answers2