CODEWITHSUNDEEP
delphiaccess-modifiers
bAN
bAN

Reputation: 13835

Difference between "strict private" and "protected" Access Modifiers in Delphi?

but I learn programming and after structured programming with Pascal language, I'm beginning to learn about OOP with Delphi.

So, I don't really understand the difference between the strict private instruction and the protected one.. So here is my code, it's about a "bag" creation, it's just the introduction of my Delphi's lesson, teacher show us how we can create objects:

    uses
  SysUtils;

Type

  Tbag= class (Tobject)                                                          
    strict private                                                                
      FcontenM : single;
      Fcontent : single;
    protected
      function getisempty : boolean;
      function getisfull: boolean;
    public
      constructor creer (nbliters : single);
      procedure add     (nbliters : single);
      procedure clear   (nbliters : single);
      property contenM : single read FcontenM;
      property content : single read Fcontent;
      property isempty : boolean read getisempty;
      property isfull : boolean read getisfull;
    end;


function Tseau.getisempty;
  begin
    result := Fcontent = 0;
  end;

function Tseau.getisfull;
  begin
    result := Fcontent = FcontenM;
  end;

constructor Tseau.creer(nbliters: Single);
  begin
    inherited create;
    FcontenM := nbliters;
  end;

procedure Tbag.add (nbliters: Single);
  begin
    if ((FcontenM - Fcontent) < nbliters) then fcontent := fcontenM
      else Fcontent := (Fcontent + nbliters);
  end;

procedure Tbag.clear (nbliters: Single);
  begin
    if (Fcontent > nbliters) then Fcontent := (Fcontent - nbliters)
      else Fcontent := 0;
  end;

So it's just an example of object creation; I understand what is public declaration (interface approachable by the outside) but I don't see what's the difference between private and protected declarations.. Thanks for trying to help me..

Upvotes: 22

Views: 20387

Answers (5)

LU RD
LU RD

Reputation: 34929

One other case missing in the other answers. There are possibilities to "extend" the class encapsulation rules.

With class helpers, introduced in Delphi 8 (for .NET compatibility), it is possible to circumvent the difference in visibility between private,protected and public (and even the strict notations). The class helper declaration can be in another unit than the original class.

This is an example :

type
  TMyOrgClass = class
  strict private
    FMyPrivateProp: Integer;
  strict protected
    property MyPrivateProp: Integer read FMyPrivateProp;
  end;

  TMyClassHelper = class helper for TMyOrgClass
  private
    function GetMyPublicProp: Integer;
  public
    property MyPublicProp: Integer read GetMyPublicProp;
  end;

function TMyClassHelper.GetMyPublicProp: Integer;
begin
  Result:= Self.FMyPrivateProp;  // Access the org class members with Self
end;

See this post for more information :access-a-strict-protected-property-of-a-delphi-class.

Upvotes: 3

mjn
mjn

Reputation: 36664

One case is missing in the other answers: private and even strict private fields of other instances can be accessed from code within their class:

type
  TSO1516493= class
  strict private
    A: Integer;
  public
    procedure ChangeOther(Param: TSO1516493);
  end;

{ TSO1516493 }

procedure TSO1516493.ChangeOther(Param: TSO1516493);
begin
  Param.A := -1; // accessing a strict private variable in other instance !
end;

(This is the same behavior as in Java.)

Upvotes: 5

Svein Bringsli
Svein Bringsli

Reputation: 5748

The difference between private, protected and public is pretty straightforward:

  • Private members/methods are only visible within the class that declares them.
  • Protected members/methods are visible within the class, and to all subclasses.
  • Public members and methods are visible to all other classes.

In Delphi there's a "bug" that makes the visibility of all members public within the same unit. The strict keyword corrects this behaviour, so that private is actually private, even within a single unit. For good encapsulation I would recommend always using the strict keyword.

Example code:

type
  TFather = class
  private
    FPriv : integer;
  strict private
    FStrPriv : integer;
  protected
    FProt : integer;
  strict protected
    FStrProt : integer;
  public
    FPublic : integer;
  end;

  TSon = class(TFather)
  public
    procedure DoStuff;
  end;

  TUnrelated = class
  public
    procedure DoStuff;
  end;

procedure TSon.DoStuff;
begin
  FProt := 10;       // Legal, as it should be. Accessible to descendants.
  FPriv := 100;      // Legal, even though private. This won't work from another unit!
  FStrictPriv := 10; // <- Compiler Error, FStrictPrivFather is private to TFather
  FPublic := 100;    // Legal, naturally. Public members are accessible from everywhere.
end;

procedure TUnrelated.DoStuff;
var
  F : TFather;
begin
  F := TFather.Create;
  try
    F.FProt := 10;     // Legal, but it shouldn't be!
    F.FStrProt := 100; // <- Compiler error, the strict keyword has "made the protection work"
    F.FPublic := 100;  // Legal, naturally.
  finally
    F.Free;
  end;
end;

Upvotes: 37

smok1
smok1

Reputation: 2950

strict private - visible and accesible only from within this class.

private - visible and accesible only from within this class AND this class unit.

protected - the same as private PLUS from within descendant classes

You can read more about and idea of encapsulation here: http://en.wikipedia.org/wiki/Encapsulation_%28computer_science%29#Encapsulation

Upvotes: 6

jpfollenius
jpfollenius

Reputation: 16620

You could have looked this up everywhere (the keyword would be "access modifiers")

Basically, protected means that the members will be visible in child classes and throughout the unit. strict private means you have access to the member in member methods of this class ONLY.

Upvotes: 5

Related Questions