CODEWITHSUNDEEP
c++
NellerLess
NellerLess

Reputation: 965

In C++, what does & mean after a function's return type?

In a C++ function like this:

int& getNumber();

what does the & mean? Is it different from:

int getNumber();

Upvotes: 57

Views: 49048

Answers (11)

Tristram Gräbener
Tristram Gräbener

Reputation: 9711

Yes, it's different.

The & means you return a reference. Otherwise it will return a copy (well, sometimes the compiler optimizes it, but that's not the problem here).

An example is vector. The operator[] returns an &. This allows us to do:

my_vector[2] = 42;

That wouldn't work with a copy.

Upvotes: 12

Nick Meyer
Nick Meyer

Reputation: 40272

Yes, the int& version returns a reference to an int. The int version returns an int by value.

See the section on references in the C++ FAQ

Upvotes: 33

CppLearner
CppLearner

Reputation: 17040

It's a reference

Upvotes: 3

sergiom
sergiom

Reputation: 4877

It's different.

int g_test = 0;

int& getNumberReference()
{
     return g_test;
}

int getNumberValue()
{
     return g_test;
}

int main()
{
    int& n = getNumberReference();
    int m = getNumberValue();
    n = 10;
    cout << g_test << endl; // prints 10
    g_test = 0;
    m = 10;
    cout << g_test << endl; // prints 0
    return 0;
}

the getNumberReference() returns a reference, under the hood it's like a pointer that points to an integer variable. Any change applyed to the reference applies to the returned variable.

The getNumberReference() is also a left-value, therefore it can be used like this:

getNumberReference() = 10;

Upvotes: 51

T.E.D.
T.E.D.

Reputation: 44794

The difference is that without the & what you get back is a copy of the returned int, suitable for passing into other routines, comparing to stuff, or copying into your own variable.

With the &, what you get back is essentially the variable containing the returned integer. That means you can actually put it on the left-hand side of an assignment, like so:

getNumber() = 200;

Upvotes: 9

codaddict
codaddict

Reputation: 454930

int& getNumber(): function returns an integer by reference.

int getNumber(): function returns an integer by value.

They differ in some ways and one of the interesting differences being that the 1st type can be used on the left side of assignment which is not possible with the 2nd type.

Example:

int global = 1;

int& getNumber() {
        return global; // return global by reference.
}

int main() {

        cout<<"before "<<global<<endl;
        getNumber() = 2; // assign 2 to the return value which is reference.
        cout<<"after "<<global<<endl;

        return 0;
}

Ouptput:

before 1
after 2

Upvotes: 4

fredoverflow
fredoverflow

Reputation: 263078

The first version allows you to write getNumber() = 42, which is probably not what you want. Returning references is very useful when overloading operator[] for your own containers types. It enables you to write container[9] = 42.

Upvotes: 4

Ben Voigt
Ben Voigt

Reputation: 283624

It's a reference, which is exactly like a pointer except you don't have to use a pointer-dereference operator (* or ->) with it, the pointer dereferencing is implied.

Especially note that all the lifetime concerns (such as don't return a stack variable by address) still need to be addressed just as if a pointer was used.

Upvotes: 1

Simon
Simon

Reputation: 80759

It means it's returning a reference to an int, not an int itself.

Upvotes: 1

Shayan
Shayan

Reputation: 2828

It means that it is a reference type. What's a reference?

Wikipedia:

In the C++ programming language, a reference is a simple reference datatype that is less powerful but safer than the pointer type inherited from C. The name C++ reference may cause confusion, as in computer science a reference is a general concept datatype, with pointers and C++ references being specific reference datatype implementations. The declaration of the form:

Type & Name

where is a type and is an identifier whose type is reference to .

Examples:

  1. int A = 5;
  2. int& rA = A;
  3. extern int& rB;
  4. int& foo ();
  5. void bar (int& rP);
  6. class MyClass { int& m_b; /* ... */ };
  7. int funcX() { return 42 ; }; int (&xFunc)() = funcX;

Here, rA and rB are of type "reference to int", foo() is a function that returns a reference to int, bar() is a function with a reference parameter, which is reference to int, MyClass is a class with a member which is reference to int, funcX() is a function that returns an int, xFunc() is an alias for funcX.

Rest of the explanation is here

Upvotes: 3

jldupont
jldupont

Reputation: 96716

"&" means reference, in this case "reference to an int".

Upvotes: 3

Related Questions