«

I know the below code is wrong:

Object & test(){ return Object() ;}
Object & v = test() ;

the Object is just a temporary variable,
so you the variable may be reference to
nothing.

And I try to this:

Object & test () { return * new Object(); }
Object & v = test () ;

But how can I destroy the Object's memery?

But, how to return reference safely?
Is there any principle to return by reference?

Bo Yang napsal:
> I know the below code is wrong:
>
> Object & test(){ return Object() ;}
> Object & v = test() ;
>
> the Object is just a temporary variable,
> so you the variable may be reference to
> nothing.
>
> And I try to this:
>
> Object & test () { return * new Object(); }
> Object & v = test () ;
>
> But how can I destroy the Object's memery?
>
> But, how to return reference safely?
> Is there any principle to return by reference?

By reference is usually returned
(1) *this (typically in overloaded operator=) or
(2) some class member instance or
(3) instance stored in some container

The main rule is "Instance must not be local variable of function,
which returns reference to it.

class Test
{
public:
Test(int data): data_(data) { }

// This example for case (1)
Test& operator=(const test& src)
{
data_ = src.data_;
return *this;
}

// This is example for case (2)
int& GetData() { return data_; }
};

Bo Yang wrote:
> I know the below code is wrong:
>
> Object & test(){ return Object() ;}
> Object & v = test() ;
>
> the Object is just a temporary variable,
> so you the variable may be reference to
> nothing.
>
> And I try to this:
>
> Object & test () { return * new Object(); }
> Object & v = test () ;
>
> But how can I destroy the Object's memery?

delete & v;

means delete the variable that v is a reference to which is the
unnamed Object created in test();


> But, how to return reference safely?
> Is there any principle to return by reference?

Usually you will also pass the object into the function by reference:

class Object{};
Object & test(Object &);


Object o;

Object & v = test(o);

v is 'another name' for o;

regards
Andy Little

Ondra Holub :
> Bo Yang napsal:
>> I know the below code is wrong:
>>
>> Object & test(){ return Object() ;}
>> Object & v = test() ;
>>
>> the Object is just a temporary variable,
>> so you the variable may be reference to
>> nothing.
>>
>> And I try to this:
>>
>> Object & test () { return * new Object(); }
>> Object & v = test () ;
>>
>> But how can I destroy the Object's memery?
>>
>> But, how to return reference safely?
>> Is there any principle to return by reference?
>
> By reference is usually returned
> (1) *this (typically in overloaded operator=) or
> (2) some class member instance or
> (3) instance stored in some container
>
> The main rule is "Instance must not be local variable of function,
> which returns reference to it.

And when I implement a '-' operator in a class,
I must to do

Test & operator -( Test & right ) ;

How to implement this function then ?
I must to new a Test in this function , mustn't I ?
>
> class Test
> {
> public:
> Test(int data): data_(data) { }
>
> // This example for case (1)
> Test& operator=(const test& src)
> {
> data_ = src.data_;
> return *this;
> }
>
> // This is example for case (2)
> int& GetData() { return data_; }
> };
>

Bo Yang wrote:
> I know the below code is wrong:
>
> Object & test(){ return Object() ;}
> Object & v = test() ;
>
> the Object is just a temporary variable,
> so you the variable may be reference to
> nothing.
>
> And I try to this:
>
> Object & test () { return * new Object(); }
> Object & v = test () ;
>
> But how can I destroy the Object's memery?
>
> But, how to return reference safely?
> Is there any principle to return by reference?

you can return Object by value

Object test(){ return Object(); }

and then bind the return to reference on use

Object & obj = test();

If carefull, you can avoid copying

or, if Object is too big for stack, use

std::auto_ptr<Object> test(){ return std::auto_ptr<Object>(new Object);
}

Bo Yang wrote:

>> By reference is usually returned
>> (1) *this (typically in overloaded operator=) or
>> (2) some class member instance or
>> (3) instance stored in some container
>>
>> The main rule is "Instance must not be local variable of function,
>> which returns reference to it.
>
> And when I implement a '-' operator in a class,
> I must to do
>
> Test & operator -( Test & right ) ;

Usually, you let that operator take a const reference as argument and return
an object instead of a reference.

> How to implement this function then ?
> I must to new a Test in this function , mustn't I ?

No. Well, you can, but shouldn't. You simply don't return by reference.

Rolf Magnus :
> Bo Yang wrote:
>
>>> By reference is usually returned
>>> (1) *this (typically in overloaded operator=) or
>>> (2) some class member instance or
>>> (3) instance stored in some container
>>>
>>> The main rule is "Instance must not be local variable of function,
>>> which returns reference to it.
>> And when I implement a '-' operator in a class,
>> I must to do
>>
>> Test & operator -( Test & right ) ;
>
> Usually, you let that operator take a const reference as argument and return
> an object instead of a reference.

I have take a look at the FAQ and found
the return type is usually a value but a reference.
I understand the principle, return by reference only
if the object you return is all at your control.

Thank you!
>
>> How to implement this function then ?
>> I must to new a Test in this function , mustn't I ?
>
> No. Well, you can, but shouldn't. You simply don't return by reference.
>