Hi,
I have objects (classes) derived from base one

TBaseObject = class(TObject)
public
   constructor Create; virtual;
   function Clone:TBaseObject;
end;

TMyObject = class(TBaseObject)
my fields here
end;

o1, o2:TmyObject;
o1  already created;
o2 := o1.Clone;

in Clone i want to create new object from TmyObject but in base object in Clone method,like this

TBaseObject.Clone:TBaseObject;
begin
  Result:=TBaseObject(ClassType).Create;//I know it is wrong here
end;

A
​ny good idea?​

Clone method,like this

You need to add a "Result.Assign(Self)" to your clone call and implement a virtually inherited "Assign" method in each class where you copy all fields. This is how "TPersistent" and its descendants do it as well.

Regards,
Sven

Sven Barth wrote

You need to add a "Result.Assign(Self)" to your clone call and implement a virtually inherited "Assign" method in each class where you copy all fields. This is how "TPersistent" and its descendants do it as well.

​Yes I added assign, but as example above, it is crashed when creating it

Result:=TBaseObject(ClassType).Create;

This is wrong. You are typecasting a class reference to an object instance.

The following works:

{$mode objfpc}
Type
   TBaseObject = class(TObject)
   public
   constructor Create; virtual;
   function Clone:TBaseObject;
   end;
   TBaseObjectClass = Class of TBaseObject;
constructor TBaseObject.Create;
begin
end;
Function TBaseObject.Clone:TBaseObject;
Var
   C : TBaseObjectClass;
begin
   C:=TBaseObjectClass(ClassType);
   Result:=C.Create;
end;
Type
   TMyObject = class(TBaseObject)
   //   my fields here
   end;
Var
o1, o2:TmyObject;
begin
   o1:=TMyObject.Create;
   o2 := o1.Clone as TmyObject;
end.

Michael.

What would happen if Result := Self.ClassType.Create were used instead?

Stephano

The wrong constructor would be called.
Classtype is equivalend to 'Class of TObject'.

The typecast is needed to ensure that the TBaseObject.Create constructor is called. Your basic polymorphism problem...

Michael.

On Mon, Sep 23, 2013 at 10:02 AM, Michael Van Canneyt <

​Yes, that help me, thanks.

Now about assigning I must repeat it (assign) for every child class copy its field members, is there any trick to copy the values like assigning record var to another record var?
I know it is kind of strange way :P

​Thanks​

​Zaher Dirkey​

There is no such safe mechanism.

The best you can do is make the properties published, and write an RTTI lookup routine that copies all Published values. I've done this several times, it works well for most situations.

Michael.

On Mon, Sep 23, 2013 at 12:46 PM, Michael Van Canneyt <

​It is not the fastest way like assigning a record, can we ask it as a feature in FPC ?​

Best Regards
Zaher Dirkey

Well, actually there is a safe mechanism. You use a record to store the class variables. But it looks clumsily:

type
 TMyClass = class(TPersistent)
 private
   type
     TMyClassVars = record
       a,b,c: string;
     end;
 private
   F: TMyClassVars;
 public
   procedure Assign(Source: TPersistent);
   property a: string read F.a write F.a;
 end;
procedure TMyClass.Assign(Source: TPersistent);
begin
  F:=TMyClass(Source).F;
  inherited;
end;

The best you can do is make the properties published, and write an RTTI lookup routine that copies all Published values. I've done this several times, it works well for most situations.

Mattias

It's impossible to do correctly.

Michael.

Michael Van Canneyt wrote

I've done this several times, it works well for most situations.

My I also suggest Zaher takes a look at tiOPF's code to see how they implement class cloning.

Also be careful about the pitfalls of cloning a class. eg: How you want to handle more complex cases. eg: Cloning a class with a reference to another class, or cloning a class with an embedded class (field), etc... tiOPF's implementation allows the developer to decided how such cases should be handled.

Regard,
Graeme.

2013/9/23 Mattias Gaertner

This wouldn't clone included objects. I mean: if the object to be cloned contains objects, those included objects should probably be cloned too, but putting them into a record wouldn't achieve that.

On Mon, Sep 23, 2013 at 12:57 PM, Mattias Gaertner <

​But in derived classes fields will not assigned​?

Best Regards
Zaher Dirkey

Derived classes can use the same technique.

Mattias

Anything that needs code to create needs code to clone. You can always creates cases where cloning need special code. But if you limit yourself you can use some of the existing frameworks like TReader/TWriter of tiopf.

Mattias

Yes. But that works only for 'simple' types and still requires you to write code.

For the more general case where you can have arrays, classes, interfaces and whatnot as fields of your object, there is simply no correct way.

Michael.

Can't the clipboard help in cloning? Similar to the IDE's copy and paste.

Stephano

2013/9/23 Michael Van Canneyt

Isn't there? Maybe it wouldn't be easy, but IIRC Delphi offers something related to this with TComponents and Streams. This Delphi mechanism I knew worked only for properties, but I found references that there existed a wider mechanism in D2010.

Even then you'd need to convert the fields to the format the clipboard expects. And if you managed to correctly "stream" all properties than you don't need the clipboard anyway...

Regards,
Sven

There is no GENERAL way.

The RTTI based mechanisms make special assumptions about how to reference components, tpersistents and whatnot.

If I have a field that is a stream. How are you going to correctly copy this ? Just the stream instance pointer ? The stream+Contents ?

The answer depends on how the classes are supposed to behave. The language itself cannot give you this mechanism.

Michael.

On Mon, Sep 23, 2013 at 12:58 PM, Graeme Geldenhuys <

​The idea is simply than needs to use a stream or RTTI, it is like a record, if looked at an object like as a record but it is inheritable. ​Compile can now every object body, and do the assigning as record assign. ​
That's the feature I like to have. ​

Best Regards
Zaher Dirkey

​This is a funny example about what in my mind about what I talk (I know it is stupid and unsafe)
If you look it is only for the class that not yet inherited yet, and work only for the top class, but the compiler can guss all inheited/derived classes and make the same assign.
If some understand it, maybe give more explain.
​----------------------------------------------------- type
TmyRec = record

    s: string;
    i: integer;
  end;
  PmyRec=^TmyRec;

  TmyObj = class(TObject)
    s: string;
    i: integer;
  end;
procedure TForm1.Button1Click(Sender: TObject);
var
  o1, o2: TmyObj;
begin
  o1 := TmyObj.Create;
  o2 := TmyObj.Create;
  o1.s := 'test1';
  o1.i := 122;
  PmyRec(@o2)^ := PmyRec(@o1)^;
  WriteLn(o2.s);
  WriteLn(o2.i);
end;
​-----------------------------------------------------​

Best Regards
Zaher Dirkey