auto_ptr<> as function return

[Kurt Stutsman]

I am developing a type that protects ownership of data with non-const
ref copy-constructor and assignment operator similiar to auto_ptr<>. I
read that auto_ptr<> uses auto_ptr_ref to fascilitate returning from a
functoin and managed to get that working. However, when I try to assign
a value returned from this function, it doesn't work. I looked at the
auto_ptr<> implementation and don't see clearly how it is handling it
either. Anyways here's a condensed version of my code that illustrates
what I'm doing:

struct A {
struct ARef {
int* value;

ARef(int* v) : value(v)
{}
};

int* m_value;

A(int* value) : m_value(value)
{}

A(ARef ref) : m_value(ref.value)
{}

A(A& a) : m_value(a.m_value)
{}

operator ARef ()
{ return ARef(m_value); }

A& operator = (A& a)
{
m_value = a.m_value;
return *this;
}
};

A func()
{
return A(0);
}

int main()
{
A a(0);
a = func();
return 0;
}

I realize it's failing because a = func(); is using a temporary which
cannot be given to a non-constant reference such as A::operator=()'s
argument. The thing is I don't see how this is done in auto_ptr<> either
but yet that expression would work for it.

[Howard]

"Kurt Stutsman" <ks*******@NOSPAM.sbcglobal.net> wrote in message
news:5i*****************@newssvr13.news.prodigy.co m...

I am developing a type that protects ownership of data with non-const ref
copy-constructor and assignment operator similiar to auto_ptr<>. I read
that auto_ptr<> uses auto_ptr_ref to fascilitate returning from a functoin
and managed to get that working. However, when I try to assign a value
returned from this function, it doesn't work. I looked at the auto_ptr<>
implementation and don't see clearly how it is handling it either. Anyways
here's a condensed version of my code that illustrates what I'm doing:

struct A {
struct ARef {
int* value;

ARef(int* v) : value(v)
{}
};

int* m_value;

A(int* value) : m_value(value)
{}

A(ARef ref) : m_value(ref.value)
{}

A(A& a) : m_value(a.m_value)
{}

operator ARef ()
{ return ARef(m_value); }

A& operator = (A& a)
{
m_value = a.m_value;
return *this;
}
};

A func()
{
return A(0);
}

int main()
{
A a(0);
a = func();
return 0;
}

I realize it's failing because a = func(); is using a temporary which
cannot be given to a non-constant reference such as A::operator=()'s
argument. The thing is I don't see how this is done in auto_ptr<> either
but yet that expression would work for it.

You don't say what about this is not working. Do you get a compiler error?

Why is the parameter for operator= non-const? You're not changing a, so why
not make it const?

-Howard

[Kurt Stutsman]

Howard wrote:

You don't say what about this is not working. Do you get a compiler error?
Yes, it's a compiler error. I've tested it with both g++ and comeau. g++
says:
test.cpp: In function `int main()':
test.cpp:38: error: no match for 'operator=' in 'a = func()()'
test.cpp:24: error: candidates are: A& A::operator=(A&)

func() returns an instance of A as a temporary which cannot be taken as
a non-const reference.
Why is the parameter for operator= non-const? You're not changing a, so why
not make it const?

It is a contrived example. In the real implementation, I do change A.
This code however shows enough to demonstrate the actual issue.

[Kurt Stutsman]

Kurt Stutsman wrote:

Howard wrote:

You don't say what about this is not working. Do you get a compiler
error?

Yes, it's a compiler error. I've tested it with both g++ and comeau. g++
says:
test.cpp: In function `int main()':
test.cpp:38: error: no match for 'operator=' in 'a = func()()'
test.cpp:24: error: candidates are: A& A::operator=(A&)

func() returns an instance of A as a temporary which cannot be taken as
a non-const reference.

Why is the parameter for operator= non-const? You're not changing a,
so why not make it const?

It is a contrived example. In the real implementation, I do change A.
This code however shows enough to demonstrate the actual issue.

No one has a solution for this? Or can at least explain how auto_ptr
does it?

Kurt

[Kurt Stutsman]

Well I found out that I was looking at the wrong header file on my
system (apparently I have 3 separate copies of memory in /usr/include).
I found there is an operator= that takes an auto_ptr_ref and explains
how "a = func();" works. Looking in the standard, I don't see that
operator specified for the std::auto_ptr<> spec though. Is this behavior
not guaranteed to work?