return value by reference

[huangshan]

hi all

In what condition i need( or mast) a (templates)function return value by
reference?

can you give me a example

thanks

[Daniel T.]

"huangshan" <hu**************@hotmail.comwrote:

In what condition i need( or mast) a (templates)function return value by
reference?

can you give me a example

If I understand the question, have it return by reference when what it
is returning is something that the calling code legitimately already has
access to (e.g.; something that was passed to it as a reference
parameter, or when it's returning '*this',) or when it's a
member-function and the class guarantees that the object returned will
exist at least until the next member-function is called (make it return
a const reference in this case.)

--
To send me email, put "sheltie" in the subject.

[could.net]

class1& function1()
{
class1* c=new class1;
return *c;
}

huangshan wrote:

hi all

In what condition i need( or mast) a (templates)function return value by
reference?

can you give me a example

thanks

[Salt_Peter]

huangshan wrote:

hi all

In what condition i need( or mast) a (templates)function return value by
reference?

can you give me a example

thanks

If you had provided a simple example - the exercise would have been far
more relevent for you.
Template or not, the exact same rules apply.

The "conditions" are
a) that the object/variable returned must be valid (not destroyed)
b) when is a reference, or a const reference, required?

Lets take an example and perhaps dispell what "returning" means:
void increment(int& r_n)
{
++r_n;
}

This function looks like its not returning anything, but it actually is
in the sense that its modifying a supplied parameter, not a *local*
copy of that parameter. So "returning" a reference is often safely
accomplished by having a reference as a parameter.

int& increment(int n) // bad code
{
return n;
}
That function is undefined behavious since integer n (a local copy)
ceases to exist when the function returns. Returning a reference to
garbage is garbage (TM).

Finally, and perhaps a tad more relevent, a *const* reference is the
safe way to return a private member of a class - safely. In this case,
obviously, n is valid but the goal here is not to allow somebody to
accidentally modify the private member via get() - just because they
have a reference to it.

template< typename T >
class N
{
T t;
public:
N() : t() { }
const T& get() const { return t; }
};

Its important to note that the const specifiers are very important
here. If you were to implement get() without the const specifiers,
you'ld be able to something nasty like get() = 6 and accidentally
modify member t through the reference - very,very bad side effect.
So its not just about "when returning a reference is valid" anymore but
rather "when does it make sense" to return what type of reference
(const or not?).

[David Harmon]

On 23 Oct 2006 20:00:33 -0700 in comp.lang.c++, co*******@gmail.com
wrote,

>class1& function1()
{
class1* c=new class1;
return *c;
}

A reference to dynamic data that the caller will eventually have to
turn back into a pointer so that he can delete it? Can there be a
worse example?

[Salt_Peter]

[rearranged - please don't top post]

huangshan wrote:

hi all

In what condition i need( or mast) a (templates)function return value by
reference?

can you give me a example

thanks

co*******@gmail.com wrote:

template< typename class1 >

class1& function1()
{
class1* c=new class1;
return *c;
}

The above is probably a memory leak since the compiler has no
*guarenteed* way to recover that allocation. You should not show people
a new without supplying its delete anyways, specially an OP that is
having issues with undefined behaviour. Remember that the returned
reference can be used to assign or copy a completely unrelated instance
of myclass1 - thats a disaster because you've lost any hope to
deallocate.

The only way that such an allocation would be recoverable is by *only*
allowing a reference to be initialized - which cannot be guarenteed or
enforced by function1 in any way. You also have smart pointers
available - but that raises a whole set of new questions.
Change the code in main() below to assign a variable instead of a
reference and observe the output - and the compiler's diagnostic.

template< typename class1 >
class1& function1() // bad code - don't do this
{
class1* p = new class1;
std::cout << "p = " << p << std::endl;
return *p;
}

int main()
{
int& r_n(function1< int >());
int* p_n = &r_n;
std::cout << "p_n = " << p_n << std::endl;
delete p_n;

return 0;
}

/*
p = 0x501010
p_n = 0x501010 // // ok, but only valid if r_n is a reference
*/

We all make mistakes, i more often than others, but at least check your
code before posting.

[huangshan]

"Salt_Peter" <pj*****@yahoo.comwrote in message
news:11********************@i42g2000cwa.googlegrou ps.com...

[rearranged - please don't top post]

template< typename class1 >
class1& function1() // bad code - don't do this
{
class1* p = new class1;
std::cout << "p = " << p << std::endl;
return *p;
}

int main()
{
int& r_n(function1< int >());
int* p_n = &r_n;
std::cout << "p_n = " << p_n << std::endl;
delete p_n;

return 0;
}

/*
p = 0x501010
p_n = 0x501010 // // ok, but only valid if r_n is a reference
*/

#include <iostream>
using namespace std;

template< typename class1 >
class1& function1() // bad code - don't do this
{
class1* p = new class1;
std::cout << "p = " << p << std::endl;
return *p;
}
int main()
{
int* p_n = &function1< int >();
std::cout << "p_n = " << p_n << std::endl;
delete p_n;
system("pause");
return 0;
}

I modify your code as above,
are they same with your code?

i think they are same.

[benben]

A reference to dynamic data that the caller will eventually have to

turn back into a pointer so that he can delete it? Can there be a
worse example?

That's not too bad. A worse example can be:

class1& function2()
{
static class1 c1

if (function3())
return c1;

return *(new class1);
}

[Frederick Gotham]

benben posted:

That's not too bad. A worse example can be:

class1& function2()
{
static class1 c1

if (function3())
return c1;

return *(new class1);
}

<sarcasm>

Don't forget the obligatory global:

bool should_delete = false;

Class1 &Func2()
{
static Class1 obj;

if (Func3()) { should_delete = false; return obj; }

should_delete = true; return *new Class1;
}

</sarcasm>

--

Frederick Gotham

[Frederick Gotham]

Salt_Peter posted:

template< typename class1 >

>class1& function1()
{
class1* c=new class1;
return *c;
}

The above is probably a memory leak since the compiler has no
*guarenteed* way to recover that allocation.

Where there's a will, there's a way. . .

(Unchecked code)

template<class T>
void TypeSpecificDelete(void const *const p)
{
delete static_cast<T const*>(p);
}

struct PtrWithDel {
void const *p;
void (*Deletor)(void const*);
};

template<typename class1>
PtrWithDel function1()
{
PtrWithDel const a = { new class1, TypeSpecificDelete<class1};

return a;
}

--

Frederick Gotham

[Salt_Peter]

huangshan wrote:

"Salt_Peter" <pj*****@yahoo.comwrote in message
news:11********************@i42g2000cwa.googlegrou ps.com...

[rearranged - please don't top post]

template< typename class1 >
class1& function1() // bad code - don't do this
{
class1* p = new class1;
std::cout << "p = " << p << std::endl;
return *p;
}

int main()
{
int& r_n(function1< int >());
int* p_n = &r_n;
std::cout << "p_n = " << p_n << std::endl;
delete p_n;

return 0;
}

/*
p = 0x501010
p_n = 0x501010 // // ok, but only valid if r_n is a reference
*/

#include <iostream>
using namespace std;

template< typename class1 >
class1& function1() // bad code - don't do this
{
class1* p = new class1;
std::cout << "p = " << p << std::endl;
return *p;
}
int main()
{
int* p_n = &function1< int >();

BAD idea. Its dangerous code. even if int const * const was used.

std::cout << "p_n = " << p_n << std::endl;

What if the pointer was modified to point elsewhere here?

delete p_n;
system("pause");
return 0;
}

I modify your code as above,
are they same with your code?

i think they are same.

No, its not the same and just as BAD.

You are a programmer and YOU have responsabilities. One of those
responsabilities is to write code that is relatively safe. That means
you must enforce how clients use your classes and functions in such a
way that regardless what they throw at it, regardless how they use it,
the result is expected and relatively well defined. And that client,
one day, may very well be you.

One does not new over here and then delete overthere - that, on the
outset, breaks a fundamental rule. Allocation and deallocation is not
something you distribute or give away.

The fact that function1 allows assignment/copy to a variable is enough
to consign such code to the recycle bin. Writing code like the above is
dangerous, down-right unprofessional and guarenteed to generate bugs
down the line.

[Salt_Peter]

Frederick Gotham wrote:

Salt_Peter posted:

template< typename class1 >

class1& function1()
{
class1* c=new class1;
return *c;
}

The above is probably a memory leak since the compiler has no
*guarenteed* way to recover that allocation.

Where there's a will, there's a way. . .

yes there is. see below.

>
(Unchecked code)

--

Frederick Gotham
template<class T>
void TypeSpecificDelete(void const *const p)
{
delete static_cast<T const*>(p);
}

struct PtrWithDel {
void const *p;
void (*Deletor)(void const*);
};

template<typename class1>
PtrWithDel function1()
{
PtrWithDel const a = { new class1, TypeSpecificDelete<class1};

return a;
}

back to the basics...

#include <iostream>

template< typename N >
struct Capsule
{
Capsule() : n() { std::cout << "Capsule()\n"; }
Capsule(N& x) : n(x) { std::cout << "Capsule()\n"; }
~Capsule() { std::cout << "~Capsule()\n"; }
const N& function1() const { return n; } // <- our protagonist
private:
N n;
};

int main()
{
Capsule<intinstance;
int n = instance.function1();
const int& r_n = instance.function1();
const int * const p_n = &instance.function1();

return 0;
}

.... and no heap allocation needed.

[huangshan]

hello

thank you

now ,i know it is bad code like :

>>class1& function1() // bad code - don't do this
{
class1* p = new class1;
std::cout << "p = " << p << std::endl;
return *p;
}

i just want to know how different betwen

int& r_n(function1< int >());
int* p_n = &r_n;

and

int* p_n = &function1< int >();