Return by reference

[Michael]

Ok,
When can i return by reference? For the sake of simplicity:
lets say I have a class MLine:

class mv3
{
public:
float x,y,z;
};

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK? I appreciate that in nots of cases this can be dangerous, eg if
I returned (Direction *4) as a tempory object would be created with local
scope then returning a reference to an invalid object.

Thanks
Mike

[Victor Bazarov]

Michael wrote:

When can i return by reference?
When the object a reference to which you're returning is still alive
and well after the function returns.
For the sake of simplicity:
lets say I have a class MLine:

class mv3
{
public:
float x,y,z;
};

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK?
Yes, perfectly OK.
I appreciate that in nots of cases this can be dangerous, eg if
I returned (Direction *4) as a tempory object would be created with local
scope then returning a reference to an invalid object.

Absolutely.

V

[JKop]

Michael posted:

Ok,
When can i return by reference? For the sake of simplicity:
lets say I have a class MLine:

class mv3
{
public:
float x,y,z;
};

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK? I appreciate that in nots of cases this can be dangerous,
eg if I returned (Direction *4) as a tempory object would be created
with local scope then returning a reference to an invalid object.

Thanks
Mike

You can use a reference where you can use a pointer.

Your code in the above is valid (save for a typo or two).
There are also other things you can do with references:

int main()
{
std::string const &blah = std::string("Hello!");
//blah is now valid until the end of main
std::string const &poo = FuncThatReturnsStringByVALUE(); //Note: by
value
//poo is now valid until the end of main
}

The above is referred (no pun intended) to as "binding a temporary to a
reference".
-JKop
-JKop

[Michael]

"Michael" <sl***********@hotmail.com> wrote in message
news:ck**********@hercules.btinternet.com...

Ok,
When can i return by reference? For the sake of simplicity:
lets say I have a class MLine:

class mv3
{
public:
float x,y,z;
};

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK? I appreciate that in nots of cases this can be dangerous, eg if I returned (Direction *4) as a tempory object would be created with local
scope then returning a reference to an invalid object.

Thanks
Mike

Sorry I didn't include all the mv3 operators but one of then allows me to
multiply by floats!

[Michael]

"JKop" <NU**@NULL.NULL> wrote in message
news:iP*******************@news.indigo.ie...

Michael posted:

Ok,
When can i return by reference? For the sake of simplicity:
lets say I have a class MLine:

class mv3
{
public:
float x,y,z;
};

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK? I appreciate that in nots of cases this can be dangerous,
eg if I returned (Direction *4) as a tempory object would be created
with local scope then returning a reference to an invalid object.

Thanks
Mike

You can use a reference where you can use a pointer.

Your code in the above is valid (save for a typo or two).
There are also other things you can do with references:

int main()
{
std::string const &blah = std::string("Hello!");
//blah is now valid until the end of main
std::string const &poo = FuncThatReturnsStringByVALUE(); //Note: by
value
//poo is now valid until the end of main
}

The above is referred (no pun intended) to as "binding a temporary to a
reference".
-JKop
-JKop

that is cool. Thanks!

[Ioannis Vranos]

Michael wrote:

Ok,
When can i return by reference? For the sake of simplicity:
lets say I have a class MLine:

class mv3
{
public:
float x,y,z;
};

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK? I appreciate that in nots of cases this can be dangerous, eg if
I returned (Direction *4) as a tempory object would be created with local
scope then returning a reference to an invalid object.

Yes, but don't do it with regular functions by returning temporaries.

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Siemel Naran]

"Michael" <sl***********@hotmail.com> wrote in message news:ckk4t0

class MLine
{
mv3 PtOnLine;
mv3 Direction

public:
MLine();
const mv3& GetDirection() const
{
return Direction;
}

};

is this OK? I appreciate that in nots of cases this can be dangerous, eg if I returned (Direction *4) as a tempory object would be created with local
scope then returning a reference to an invalid object.

It's fine and done often, as in vector<T>::operator[] which returns a T& or
const T&. Be aware of code like this and don't write it:

const mv3& f() {
MLine m;
return m.GetDirection();
}

int main() {
cout << f().x; // crash, memory access violation!
}