BorlandTalk.com

Morten Taarland · Guest

Hi, I am trying to get into delphi7, haven't used any kind of pascal for
years. This may be stupid question, but I am struggling, so any help would
be appreciated.

I want to create my own class.
In a unit I do

TTest = class
private
Definition: String;

public
procedure Set_Definition(NewDef: String);
end;

var
myTest: TTest; (actually, this is declared and called from another unit,
but just to show there is an instance of the class created)

implementation

procedure TTest.Set_Definition(NewDef: String);
begin
Definition:=NewDef;
end;

To me that is a simple example of encapsulation of the class property
Definition which is not accessible outside the object. To change its value,
call Set_Definition.
However when I do this, I get an EAccessViolation, and it happens when I try
to assign a value to Definition. Comment it out and it runs fine.

So what am I doing wrong already? I didn't even get started yet, hehe.
Appreciate your attention, ladies and gents.

Morten

Rob Kennedy · Guest

Morten Taarland wrote:

Jamie · Guest

Morten Taarland wrote:

alanglloyd@aol.com · Guest

I'm not sure where you're coming from (what languages) but some basic
concepts of Delphi OO construction and use are ...

A class is a template for a actual instance of an object. The instance
is made by a class's Create constructor method which allocates memory
for that object. The instance's memory is freed by a Destroy destructor
method, which is not called externally. That is done by a Free method
(called externally) which checks for non-nullity of the instance before
calling Destroy.

Classes "descend" from other classes, and the single original
pre-historic ancestor of all classes is TObject (note that " = class;"
is the same as " = class(TObject)").

Classes have methods (procs & functions), properties and fields.

A single chunk of executable code is provided for all instances of an
object (a reference to the instance is provided by a hidden parameter
named "Self"). Properties have separate storage for every instance.
Properties are accessed either directly of via an "accessor method".
Field are variable internal to the object.

So your class should/could be ...

TTest = class(TObject)
private
FSomeDef : string;
FDefinition : string;
function GetDefinition : string; // accessor get method
procedure SetDefinition(AValue : string); // accessor set method
public
property Definition : string read GetDefinition write
SetDefinition; // access by accessor method
property SomeDef : string read FSomeDef write FSomeDef; // direct
access
end;

constructor TTest.Create;
begin
inherited Create; // not necessary for Tobjec descendants but for
every other descendant of TObject
end;

function TTest.GetDefinition : string;
begin
Result := FDefinition;
end;

procedure TTest.SetDefinition(AValue : string);
begin
if AValue <> FDefinition then
FDefinition := AValue;
end;

var
MyTest : TTest; // variable to hold an instance reference

procedure TForm1.Button1Click(Sender : TObject); // some initiating
event handler
begin
MyTest := TTest.Create;
MyTest.Definition := 'MyDefinition';
MyTest.SomeDef := 'Some Def';
end;

procedure TForm1.Button2Click(Sender : TObject); // some other
displaying event handler
begin
ShowMessage('Definition : ' + MyTest.Definition + #13 +
'SomeDef : ' + MyTest.SomeDef);
end;

procedure TForm1.FormClose(Sender : TObject);
begin
MyTest.Free; // free the instance you have created - a TObject (your
class' parent) has a Free method
end;

The form you are doing this test on is assumed to be Form1. "Get",
"Set", "F", and "T" are prefixes used by convention in Delphi.

You will see that the set & get methods or the "F"-prefixed field
variables are used to hide direct access to the property. The "private"
and "public" keywords are used by the compiler to limit access to the
fields and methods (hiding access to elements of the object are
paradigms of OO).

Enjoy <g>.

Alan Lloyd