Type im einer Klasse -> public erlaubt?

[Mokus]

Delphi-Quellcode:

type

  Twoerterzaehlen = class(Tobject)

  private
    procedure setFwort(const Value: String);

    procedure setFAnzahl(const Value: integer);
  protected
    fWort: string;
    fAnzahl: integer;
  public type
    arroftwoerter = array of Twoerterzaehlen;// möchte ich ich in anderen uniten verwenden
  constructor create(Anz: integer; Wor: String); overload;
  constructor create(Wor: String); overload;
  property Wort: String read fWort write setFwort;
  property Anzahl: integer read fAnzahl write setFAnzahl;

  function woerter_zaehlen(st_woerter: tstringlist): arroftwoerter;
  function toString(a_array: arroftwoerter): String;
  end;

Einen wunder schönen Guten Morgen,

der oben liegende Quellcode ist mein momentanes ergebniss von Aufgabe;
Ich arbeite über mehere Units und muss auf die hervorbehobene Zeile drauf zugreifen.
Deswegen ist Sie im Public.
In der nächsten Unit hab ich nun use woerter ( name der oben abgebildete Unit)
aber er sagt mir dann,
[FEHLER] [DCC Fehler] sortieren.pas(12): E2003 Undeklarierter Bezeichner: 'arroftwoerter' [/Fehler];

Delphi-Quellcode:

unit sortieren;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, woerter;

Type
  sort = class
    function sortieren(d_array: arroftwoerter): arroftwoerter;// FEHLER Zeile; 
  end;

implementation

Tut mir leid, für die warscheinlich doofe Frage; aber Delphi ist totales Neuland für mich ....

dank im vorraus :)

[mkinzler]

Deklariere ihn im Interface der Unit, vor der Klasse

Delphi-Quellcode:

type

  Twoerterzaehlen = class; //forward Deklaration

  arroftwoerter = array of Twoerterzaehlen;// möchte ich ich in anderen uniten verwenden
  
  Twoerterzaehlen = class(Tobject)

  private
    procedure setFwort(const Value: String);

    procedure setFAnzahl(const Value: integer);
  protected
    fWort: string;
    fAnzahl: integer;
  constructor create(Anz: integer; Wor: String); overload;
  constructor create(Wor: String); overload;
  property Wort: String read fWort write setFwort;
  property Anzahl: integer read fAnzahl write setFAnzahl;

  function woerter_zaehlen(st_woerter: tstringlist): arroftwoerter;
  function toString(a_array: arroftwoerter): String;
  end;

[DeddyH]

Nested Types gehören ja zu der Klasse, in der sie deklariert sind. Also muss es wohl lauten:

Delphi-Quellcode:

function sortieren(d_array: Twoerterzaehlen.arroftwoerter): Twoerterzaehlen.arroftwoerter;
//Dummy-Zeile für den DP-Highlighter

Oder Du machst es Dir einfach und machst einen "normalen" Typ daraus wie Markus gezeigt hat.

[Uwe Raabe]

Das es sich um einen Nested Type handelt, musst du ihn außerhalb der Klasse voll qualifizieren:

Delphi-Quellcode:

    function sortieren(d_array: Twoerterzaehlen.arroftwoerter): Twoerterzaehlen.arroftwoerter;

[Mokus]

Das ich diese vollständig weiter geben muss, war mir nicht bekannt.

Dank euch.

[himitsu]

Zitat:

Zitat von Uwe Raabe (Beitrag 1230412)

Das es sich um einen Nested Type handelt, musst du ihn außerhalb der Klasse voll qualifizieren:

Jain.

Also zumindesntens bis XE geht es auch ohne einen vollqualifizierten Typbezeichner.

irgendwann danach wurden dann (zumindestens weiß ich es von ENUMs) im Compiler eine Option eingebaut, bzw. standardmäßig aktiviert, welche die Angabe des Namespace (vollqualifizierten Typbezeichners) verlangt,
welches man aber auch wieder deaktivieren kann.

[Mokus]

Aber könnte durch das Deaktivieren nicht auch die Eindeutigkeit verloren gehen;
und somit eine verwechslung vorkommen?
Ich persönlich finde schon, dass es nützlich ist eine eindeutige qualifizieren "auszusprechen"

[himitsu]

Man kann es praktisch für jeden Typen einzeln angeben.

Nja, also wo es wirklich absolut unleserlich wird, ist da, wo z.B. mehrere/viele ENUMs als SET angegeben werden müssen und man da nicht viel als Bereich (..) zusammenfassen kann.

WITH mit Typen gibt es doch bestimmt noch nicht und wer kommt schon auf die Idee sich dafür einen lokalen Typen/Alias mit "kurzem" Bezeichner anzulegen und am Besten einbuchstabig?



Selbst wenn es dektiviert wurde, dann kann man immernoch per NameSpace zugreifen, wenn es nicht eindeutig ist.
Außerdem prüft ja der Compiler die Typkompatibilität, womit man sowieso keinen falschen Wert verwenden kann.

Praktisch ist das vorallem dadurch, daß man bei den Werten den Prefix weglassen kann.

Delphi-Quellcode:

type
  TEnumeration = (Onw, Two, Tree);

Wobei "kann" besser "sollte" heißen sollte, denn Namespace und Prefix zusammen sind ja ein bissl sinnlos.

[Mokus]

Zitat:

Wobei "kann" besser "sollte" heißen sollte, denn Namespace und Prefix zusammen sind ja ein bissl sinnlos.

hust,
doppelt hält besser ;-)

irgendwer muss immer drunter leiden...
arme performance :p