Re: object copy with reference
On Sep 25, 5:59 pm, Philipp Kraus <philipp.kr...@flashpixx.de> wrote:
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 i=
s
running.
OK, nothing strange here so far.
Anyway the method should be myclass::mythreadmethod( mysuperclass ), s=
o
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 c=
an
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
I think you should take a look at ICloneable in Java and .NET. What
you want is a copy of an object without knowing its type at
compilation time. You can add "clone" to abstract your base class,
however, you must create the object from there, that is, clone()
should be:
struct base
{
virtual base* clone() const = 0;
};
From there, a derived class simply does:
struct derived : public base
{
virtual base* clone() const { return new derived(*this); }
derived(const derived& rhs) { ... }
};
Finally, as I said, you should look at ICloneable. This is because
"cloning" you need happens so often that it's good to formalize it. It
requires that you know a base class (there's always one in e.g. Java,
and in a lot of C++ frameworks, too). So that's a good start, if
applicable.
One last thing: since you have threads, copy-construction must be
thread-safe (i.e, you need a mutex in derived(const derived& rhs)).
Goran.
Goran.