Re: object copy with reference

From:

Philipp Kraus <philipp.kraus@flashpixx.de>

Newsgroups:

comp.lang.c++

Date:

Sun, 25 Sep 2011 17:59:44 +0200

Message-ID:

<j5nj5g$mj$1@online.de>

On 2011-09-25 15:44:09 +0200, Victor Bazarov said:

On 9/25/2011 7:43 AM, Philipp Kraus wrote:

I have a class method that is run in different threads:
myclass::mythreadmethod( mysuperclass& )

Is there any relationship between 'myclass' and 'mysuperclass'?

mysuperclass is a reference variable, that is used during the thread is
running.

OK, nothing strange here so far.

Anyway the method should be myclass::mythreadmethod( mysuperclass ), so
that
each running thread has a own local copy of the object, but I can't
switch the parameter
because the method is derivated of another class.

So, the other class (from which your 'myclass' is derived) requires the
argument to be a reference to a non-const object. Seems OK. You can
implement your own

    myclass::mythreadmethod_impl(mysuperclass)

by overriding the 'mythreadmethod' this way:

    returntype myclass::mythreadmethod(mysuperclass& o)
    {
       => mysuperclass local_o(o); <=
       return this->mythreadmethod_impl(local_o);
    }

the marked => <= call is my problem, bevause mysuperclass is pure
virtual, so I can't do exactly this. I would like to clone "o"
(deep-copy) to a local
variable, but I know that o is a derivate object of mysuperclass. So I
have add a pure virtual method "clone" to the superclass mysuperclass,
that
must be implementated within the derivate class like:

mysuperclass& local_o = o.clone()

so local_o gets now a fully own reference to a new o object. The
problem is the returning type of clone, if I return a mysuperclass& and
do within
clone something like
mysuperclass& clone( void ){
    return myderivateclass; // call the default constructor and
returns the object with myderivateclass : public mysuperclass
}
the compiler breaks with the error temporary assignment, because the
object is create on the local stack frame and after the clone the
object is removed.

If I implementate the clone like
void clone( mysuperclass& ref) {
     ref = myderivateclass;
}

and call the clone in the context:
mythreadmethod( mysuperclass& o) {
     mysuperclass local_o; //*
     o.clone(local_o);
}

the * creates the warning that local_o isn't initialisized, if I use a
mysuperclass& the compiler create the error, that I can't use
an empty reference

Thanks

Phil