C++ reference & const pointers in C/C++

Question

Recently while I was explaining the basic difference between pointers and references(in context of C++ programming) to someone, I told the usual explanations which talk about different function argument passing conventions - Call by value, Call by pointer, Call by reference, and all the associated theory about references.

But then I thought whatever a C+ reference does in terms of argument passing,(Allows a memory efficient way of passing large structures/objects, at same time keeps it safe by not allowing the callee to modify any variables of the object passed as reference, if our design demands it)

A const pointer in C would achieve the same thing , e.g. If one needs to pass a structure pointer say struct mystr *ptr, by casting the structure pointer as constant -

func(int,int,(const struct mystr*)(ptr));

will ptr not be some kind of equivalent to a reference?

1. Will it not work in the way which would be memory efficient by not replicating the structure(pass by pointer) but also be safe by disallowing any changes to the structure fields owing to the fact that it is passed as a const pointer.

   In C++ object context, we may pass const object pointer instead of object reference as achieve same functionality)

2. If yes, then what use-case scenario in C++, needs references. Any specific benefits of references, and associated drawbacks?

thank you.

-AD

Answer 1

You can bind a const reference to an rvalue:

void foo(const std::string& s);

foo(std::string("hello"));

But it is impossible to pass the address of an rvalue:

void bar(const std::string* s);

bar(&std::string("hello"));   // error: & operator requires lvalue

References were introduced into the language to support operator overloading. You want to be able to say a - b, not &a - &b. (Note that the latter already has a meaning: pointer subtraction.)

References primarily support pass by reference, pointers primarily support reference semantics. Yes I know, the distinction isn't always quite clear in C++.