Parent and Child objects in Pascal - object

Question

I have Parent object
type PNode=^Node;
Node=Object
Left,Right:PNode;
Balance:integer;
Function Is_Greater(Node1:PNode);
end;
and a child object of object Node
Type ChildNode=object(Node);
X:integer;
end;
and I have 2 pointers P,Q:PNode and use command
P^:=Q^;
but it doesn't change the X value of node P.
Is there a way I can do that, without using pointers to child objects ?

Answer 1

Use a virtual method that you override in the child.
type
PNode = ^TNode;
TNode = object
Constructor Init;
procedure assign(t:pNode); virtual;
end;
PChildNode=^TChildNode;
TChildNode = Object(TNode)
x:integer;
procedure assign(t:pNode); virtual;
end;
Constructor TNode.Init;
begin
end;
procedure TNode.Assign(t:pNode);
begin
// assign the tnode fields in t to the fields of self
end;
procedure TChildNode.Assign(t:pNode);
begin
inherited Assign(t); // parent's fields first
// we don't have Delphi's "IS" here, so can't test if t really is a pchildnode.
x:=pchildnode(t)^.x;
end;
function CreateChildNode(x:integer):PNode;
var chld : pChildNode;
begin
chld:=new(PChildNode,Init); chld^.x:=x;
createchildnode:=chld;
end;
// below this no knowledge of TChildnode except for printing.
var p1,p2 : PNode;
begin
p1:=createchildnode(10);
p2:=createchildnode(5);
// p2^ must be equal to P1^ or derive from it.
// See comment in TChildNode.assign
p1^.assign(p2);
writeln(pchildnode(p1)^.x);
end.
Note that in the equivalent Delphi dialect (CLASS) code, which you SHOULD use, you can test if the incoming element of assign really is a tchildnode using the IS operator
Looking at FPC's packages/tv and objects unit sources is a good resource to learn the older TP dialect.

Answer 2

The X field was not changed because PNode (and TNode) have not X field. Here is working code with some explanations and use cases:
program Project1;
type
{ TNode }
PNode = ^TNode;
TNode = object
a: Integer;
procedure assign(t:TNode);
end;
{ TChildNode }
PChildNode = ^TChildNode;
TChildNode = object(TNode)
x: Integer;
// Overload parent method for the new type
// Parent method still available via inherited (see below)
procedure assign(t:TChildNode); overload;
end;
{ TNode }
procedure TNode.assign(t: TNode);
begin
a := t.a;
end;
{ TChildNode }
procedure TChildNode.assign(t: TChildNode);
begin
inherited assign(t); // Call parent method to assign inherited fields values
x := t.x;
end;
var
n: TNode;
cn1, cn2: TChildNode;
pn, pcn2: PNode;
pcn1: PChildNode;
begin
n.a := 10;
cn1.a := 11;
cn1.x := 12;
cn2.a := 21;
cn2.x := 22;
Writeln(cn1.a: 10, cn1.x: 10);
cn1.assign(n);
//cn1 := n; // Error here, type incompatibility
Writeln(cn1.a: 10, cn1.x: 10);
cn1.assign(cn2);
Writeln(cn1.a: 10, cn1.x: 10);
cn2.x := 44;
// Actually this code works like previous
cn1 := cn2;
cn2.a := 55;
Writeln(cn1.a: 10, cn1.x: 10);
Readln;
pn := New(PNode);
pcn1 := New(PChildNode);
pcn2 := New(PChildNode); // Here we assign PChildNode object to the variable with type PNode
pn^.a := 10;
pcn1^.a := 11;
pcn1^.x := 12;
pcn2^.a := 21;
PChildNode(pcn2)^.x := 22; // This explicit conversion is necessary because PNode type of the pcn2 variable
Writeln(pcn1^.a: 10, pcn1^.x: 10);
//pcn1^.assign(pn^);
//pcn1^ := pn^; // Error here, type incompatibility
PNode(pcn1)^ := pn^;
Writeln(pcn1^.a: 10, pcn1^.x: 10);
// Here is X value does not changed because it is absent in the pcn2^ have TNode type
// and assign method of the TNode will be called
pcn1^.assign(pcn2^);
Writeln(pcn1^.a: 10, pcn1^.x: 10);
// This code works well
pcn1^ := PChildNode(pcn2)^;
pcn2^.a := 55;
Writeln(pcn1^.a: 10, pcn1^.x: 10);
Readln;
end.
You can play with this code to learn more about objects behavior.