struct triple
{
  triple(int) { printf("ctor\n"); }
  triple(triple const&) { printf("cctor\n"); }
  ~triple() { printf("dtor\n"); }
};

triple const& foo(triple const& rd){
 return rd;
}
int main () {
 triple& r = foo(5 + 10);
 printf("r is NOT valid");
}

const int &foo(const int &ri)
{
  return ri;
}

const int &bar(const int &ri)
{
  static int stub
  return stub;
}

int main()
{
  const int &ri1 = foo(10+2);//вроде как можно б и продлить..
  const int &ri2 = bar(10+2);//100% нельзя продливать

R>Так, я запутался... Как тогда понимать 12.2/5

except the temporary to which the reference is bound

except the temporary to which the reference is already bound

const int &foo(const int &i) { return i; }

int main()
{
  const int &ri1 = foo(1);
}

int i;
double const& foo(double const& rd){
  return rd;
}

double d = foo(static_cast<double>(i));

12.2/5
...
A temporary bound to a reference parameter in a function call (5.2.2) persists until the completion of the full expression containing the call. A temporary bound to the returned value in a function return statement (6.6.3) persists until the function exits. In all these cases, the temporaries created during the evaluation of the expression initializing the reference, except the temporary to which the reference is bound, are destroyed at the end of the full-expression in which they are created and in the reverse order of the completion of their construction.
...

R>Так, я запутался... Как тогда понимать 12.2/5

The
temporary to which the reference is bound or the temporary that is the
complete object to a subobject of which the temporary is bound per-
sists for the lifetime of the reference or until the end of the scope
in which the temporary is created, whichever comes first.

A temporary bound to a reference parameter in
a function call persists until the completion of the
full expression containing the call.

А>int i;
А>double const& foo(double const& rd){
А>  return rd;
А>}

А>double d = foo(static_cast<double>(i));
А>

struct Test
{
    Test()
    {
        cout<<"ctor"<<endl;
    }
    ~Test()
    {
        cout<<"dtor"<<endl;
    }

};
Test const &foo(Test const &rd)
{
    return rd;
}

int main(int argc, char* argv[])
{
    //оставте один вариант и посмотрите когда вызывается деструктор
    Test const & correct = Test();
    Test const & wrong = foo(Test());