scope of objects returned by value

bm,

The member function value() makes a copy of _value and returns this to the calling function using the standard return mechanism of the compiler. The code looks portable, however some of the design idioms such as the use of the volatile keyword seem a bit akward.

Sincerely, Chris.

:)

Hey dude,
What actually happens is the caller pushes an address onto the stack and the getA() method constructs the A object at that address.
So my question is whether or not this direct contruction in the caller's temporary is portable or not.
Otherwise shouldn't the copy constructor be called? :confused:

Thanks,
- BryanThe code you posted is OK. As long as the object being returned has proper copy semantics, the code works. The compiler is free to do any optimization it believes it can make on the return value. One such optimization is called Return-Value-Optimation or RVO, where there is no temporary at all that's created.

The only issue you must be concerned with is if your copy constructor or assignment operator has some sort of side-effect that depends on whether the copy constructor or assignment operator is called. Again, the reason being that the compiler can optimize away creation of temporaries if it sees fit. No C++ programmer would even write code like that, so I don't think you have anything to worry about.

Regards,

Paul McKenzie

The copy / assignment is within the scope of the function in which the copy / assignment statement exists.

And yes indeed, a particular misuse of C/C++ as you correctly pointed out can open up all kinds of problems if a pointer to a temporary object is returned from a function. The temporary object will go out of scope according to the scope of the function and the returned pointer will point to something which is undefined such as addressable stack space. The example below shows this kind of problem and this example can be expanded so as to pertain to your last question.

Sincerely, Chris.

const char* p_string(void)
{
auto const char strHelloWorld[] = "Hello World!";

// Not a good idea.
return &strHelloWorld[0];
}

Have you tried to compile your code? Your code will not compile if the destructor in Pointer is private:

#include <memory>
template <class T>
class Pointer {
public:

T * operator ->() { return _pointer; }

private:
Pointer(T *pointer) : _pointer(pointer) { /* acquire */ }
Pointer(const Pointer<T> &other) : _pointer(other._pointer) { }

~Pointer() { /* release */ }

friend class Manager;

T *_pointer;
};

class Foo {
public:
void doStuff() {}
};

class Manager {
public:
Manager() : _myFoo(new Foo) { }
// ...
Pointer<Foo> currentItem() { return Pointer<Foo>( _myFoo.get() ); }

private:
std::auto_ptr<Foo> _myFoo;
};
void testCode()
{
Manager manager;
manager.currentItem()->doStuff(); // valid

// Pointer<Foo> fooPtr1 = manager.currentItem(); // invalid
// Pointer<Foo> fooPtr2( manager.currentItem() ); // invalid
}

Comeau C/C++ 4.3.3 (Aug 6 2003 15:13:37) for ONLINE_EVALUATION_BETA1
Copyright 1988-2003 Comeau Computing. All rights reserved.
MODE:strict errors C++

"ComeauTest.c", line 35: error: "Pointer<T>::~Pointer() [with T=Foo]" is
inaccessible
manager.currentItem()->doStuff(); // valid
^

1 error detected in the compilation of "ComeauTest.c".

...does the currentItem() method make the copy of Pointer<Foo> or does the caller, testCode() make the copy? I know that my compiler makes the copy in currentItem() but can I rely on this?I think you're reading too much into this. The function manager.currentItem() returns a Pointer<foo> object. You are then accessing the doStuff() member function from the returned object. Honestly, I don't see how much more can be said about a simple concept of a function returning an object.

Regards,

Paul McKenzie

It was a VERY simple question, but no one answered it.
(does a copy via 'return' use the caller's access permissions or the callee?)The problem with the question is that it doesn't use familiar C++ nomenclature, even though it may sound simple. For example, what do you mean by "access permissions"? To a C++ programmer, an access specifier is private, public, or protected. A term such as "access permissions" just doesn't click or is not used in C++ discussions, which is why your question is confusing.

In any event, the called function, on return, creates a copy and returns the object. In some cases, the creation of the copy is not done and RVO optimization is used instead.

Regards,

Paul McKenzie