What is definition of reference type?

Question

How do you define (explain) in a formal and strict way what is reference type in C++?

I tried to google, and looked into Stroustrup\'s \"The C++ Programming Language

Answer 1

A major difference between C and C++ (other than Objects and Classes!) is references. A reference is like a const pointer to a variable. Assigning a reference is a bit like using a pointer but with & not * and you don't need to difference. The difference is that you assign an address to a pointer but a variable to a reference variable. The line below suggests that the value of a is copied into aref. But it is not, instead aref is a reference to the variable a. Once assigned, aref is the same as a. Any changes to aref are changes to a as example below shows

int & aref = a;

 #include <stdio.h>
 #include "stdafx.h"

  int main()
   {
      int a=9;
      int & aref = a;
      a++;
      cout << "The value of a is %i\n" << aref;
      return 0;
    }

Also remember that

1. A reference must always refer to something.NULLs are not allowed.

2. A reference must be initialized when it is created. An unassigned reference can not exist.

3. Once initialized, it cannot be changed to another variable.

If it help you please inform me, thanx

Answer 2

A reference is an alias, an alternate name for an object. It is not an object itself (and in that way is not a pointer, even if some of their uses overlap with uses of pointers).

References have certain limitations to their handling, related to their non-objectness. For example, you can't create an array of references. They have to be initialized (bound, seated) as soon as they are declared, since they can't possibly exist without an object to alias.

You can however store them, and they obey the rules of automatic variables or member variables. One of their uses is to poke through C++'s pass-by-value function calls.

Note that const references have a neat side-effect of being aliases : when bound to a temporary (i.e unnamed) object, they give said object a name, and therefore extend its lifetime to that of the reference itself.

{ // Block scope
     Foo fooVal = makeFoo(); // Say makeFoo() returns a (temporary, unnamed) Foo
     // Here the temporary Foo is dead (fooVal is a copy).

     // Foo &fooRef = makeFoo(); // Error, reference is non-const
     Foo const &fooCRef = makeFoo(); // All good

     // ...

     // The second temporary is still alive
     fooCRef.doSomethingFunny(); // Works like a charm !

} // The second temporary dies with fooRef

Beware though, it is possible (though contrived) to have an object go out of scope with references still pointing to it. You will then have dangling references, which are not to be used anymore (doing so would be Undefined Behaviour).

Foo *fooPtr = new Foo; // Here is a Foo
Foo &fooRef = *fooPtr; // Here is an alias for that Foo

delete fooPtr; // Here is the end of that Foo's life

fooRef.doSomethingFunny(); // Here comes trouble...

Answer 3

According to some experts' views reference types are not C++ references per se, but in contrast to value types. I present two slightly differing definitions - of value types and of reference types.

https://abseil.io/blog/20180531-regular-types

The first is a blog post by Titus Winters, chair of the C++ subcommittee responsible for the C++ standards library.

According to Titus Winters, the difference between a value type and a reference type is the copy behaviour. When you copy value type, you get two independent objects, which are equal first, but may differ after the modification of one of both. When you copy a reference type, you get two objects, which refer to the same data.

Reference types do not own their data. Some reference types allow modifying the referred-to data (e.g. span), some do not (e.g. string_view). Both examples given are quite useful for function parameter passing. The caller of the function assures that the underlying data of the reference types is not destructed during the duration of the function call (as is the case with plain C++ references).

https://docs.microsoft.com/en-us/cpp/cpp/value-types-modern-cpp?view=vs-2019

The Microsoft documentation puts reference types as synonymous to polymorphic types (types with at least one virtual function or member variable), and value types as non-polymorphic. (Non-polymorphic types are called concrete types by Bjarne Stroustrup.)

Value types are about memory and layout control, reference types are about identity.

Value types allow the compiler direct access to the members, reference types need an indirection due to runtime polymorphism.

Reference types according to Microsoft are non-copyable (to prevent slicing).

So the semantics differ, as Titus Winters defines reference types by their actual copy behaviour.

Answer 4

Regarding

” How do you define (explain) in a formal and strict way what is reference type in C++?

the C++11 standard gives the following formal and strict definition of a reference type in its

§8.3.2/1

” In a declaration T D where D has either of the forms
      & attribute-specifier-seq_opt D1
      && attribute-specifier-seq_opt D1
and the type of the identifier in the declaration T D1 is “derived-declarator-type-list T,” then the type of the identifier of D is “derived-declarator-type-list reference to T.”

---

However, if you’re more interested in what a C++ reference practically is (apart from the colloquial use of the term), then check the definition of its meaning in an expression,

§5.5

” If an expression initially has the type “reference to T” (8.3.2, 8.5.3), the type is adjusted to T prior to any further analysis. The expression designates the object or function denoted by the reference, and the expression is an lvalue or an xvalue, depending on the expression

Effectively this means that a reference acts as an alias.

You can think of a reference as an automatically dereferenced const pointer, which explains most of the behavior except that a reference doesn't necessarily occupy storage (the compiler may be able to optimize it away completely).