CODEWITHSUNDEEP
c++
user3215228
user3215228

Reputation: 313

returning reference and use of cascading function

Please tell me the use of cascading, and when to use & before function like this int &func() Where should i use that please give me small example, Thanks. I think it does return an address but no idea how to use.

Upvotes: 0

Views: 627

Answers (2)

4pie0
4pie0

Reputation: 29744

when to use &

Return by value vs return by reference

You usually return a reference when you want a caller to be able to change the original variable. Example can be returning elements of an array

struct Array
{
    int values[ 10];
};

// Returns a reference to the nIndex element of rArray
int& Value( Array &rArray, int nIndex)
{
    return Array.values[ nIndex];
}

int main()
{
    Array myArray;
    // Set the 10th element of sMyArray to the value 5
    Value( myArray, 10) = 5;

    assert( myArray.values[ 10] == 5);  // OK
    return 0;
}

Another example is returning reference to class member. You want to return original variable, not a copy of it. Consider:

struct A {
  int something;
  int f() { return something; }
  int& g() { return something; }
};

int main()
{
    A myA;
    int i = myA.f();  // return by value: not original 
                      // int but its copy with same value
    i = 200;  

    assert( myA.something == 200);  // fail
    return 0;
}

but:

int main()
{
    A myA;
    int& i = myA.g();  // return by reference: original 
                       // variable is referenced by i now
    i = 200;  

    assert( myA.something == 200);  // OK
    return 0;
}

Operator chaining

Operator chaining is made to allow for expressions like:

a = b + c + d;

or

std::cout << "this" << " and " << "this";

Usually there is choice between returning by value or by reference made by considering the meaning of the operator or independent factors like for example that std::istream and std::ostream are not copyable, so trying to return objects of those types by value is an error.

Upvotes: 1

Christian Hackl
Christian Hackl

Reputation: 27538

You are about to commit a very common newbie mistake in C++, namely returning references to dead objects.

int &GetNumber()
{
    int number = 123;
    return number;
}

int main()
{
    int x = GetNumber();
    int y = x + 1;
}

Looks innocent but will create so-called undefined behaviour. This means that the program may do whatever it wants to - it will likely crash, or it will sometimes crash. In any case, it won't be safe. Your compiler may even warn you if you attempt to do this. The reason is that by the time GetNumber has finished, the local number is destroyed, and you end up with a reference to a destroyed object.

Usually, you will want to return a copy instead of a reference. This is the "normal" thing to do in C++:

int GetNumber() // now OK
{
    int number = 123;
    return number;
}

int main()
{
    int x = GetNumber();
    int y = x + 1;
}

Returning references is only safe when you know that the object referred to will continue to exist after the function returns. One example is when you are just returning a reference you were passed:

int &MyFunction(int &number)
{
    // do something
    return number;
}

This then allows you to chain functions:

struct Example
{
    Example &MyFunction(Example &example)
    {
        // do something
        return example;
    }
};

int main()
{
    Example example;
    example.MyFunction(example).MyFunction(example).MyFunction(example);
}

Now, if this example strikes you as particularly useless (as it should), look at how the standard library handles << calls with std::ostream for a realistic use case.

std::cout << 1 << "a" << 0.5;

This syntax works because each operator<< call returns a reference to std::cout.

Upvotes: 1

Related Questions