Inkompatible Typen: 'Array' und 'Pointer' (E2010)

Entwicklungsumgebung: BDS 2005 Personal
Sprache: Delphi
Plattform: Win32

procedure SetNames(const PNames: array of PAnsiString);
begin
...
end;

...

constructor Create(const Number: Integer; const Names: array of AnsiString);
var
...
begin
SetNames(@Names);
...
end;

...

Zum Vergrößern anklicken....

Wenn ich versuche, die Adresse des Arrays Names an die Prozedur SetNames zu übergeben, tritt jener Fehler (siehe Titel) auf. Die Fehlermeldung hilft mir jedoch nicht wirklich weiter.

Passe doch entweder beim Constructor oder bei SetNames den Parameter an, so daß Du entweder "array of PAnsiString" oder halt "array of AnsiString" hast.

Wenn Du @Names schreibst, bekommst Du nur einen Pointer, nämlich die Start-Adresse des Names-Parameters. Der ist nicht zu einem Array kompatibel.

Danke für deinen Beitrag, O Love. Da offenbar keine Adresse eines kompletten Arrays übergeben werden kann, habe ich die Adresse von jedem Array-Index übergeben:

procedure SetNames(const PPlayer: PInteger; const PName: PString);
begin

end;

...

constructor Create(const Number: Integer; const Names: array of string);
var
Player: 1..9
begin
for Player := 1 to FNumber do
SetNames(@Player, @Names [Player]);
end;

Zum Vergrößern anklicken....

Und warum willst Du unbedingt Pointer auf Deine Parameter übergeben? Ein Integer hat 32 bit, ebenso der Pointer drauf. Beim Pointer auf den String gibt es auch keine Unterschiede, weil der Compiler bei Verwendung von const eh einen Zeiger übergibt.

Naja, bis jetzt habe ich keine Zeiger verwendet, weil ich davon noch nichts wusste. Jedenfalls wollte ich außer Delphi noch C++ lernen. In dem ANSI C++ Handbuch hatte ich erfahren, dass bei Parameterübergabe immer Kopien übergeben werden (ausgenommen Zeiger und Referenzen). Und um sinnlose Kopien zu vermeiden, wende ich deshalb vorzugsweise Zeiger an.

Also entweder habe ich nicht genau gelesen oder die Übergabe von Parametern ist von Sprache zu Sprache semantisch verschieden.

Nun, bei Delphi wird es beim Standard-Datentyp string interessant:
Hier wird der String auf den Stack geworfen, innerhalb der Prozedur arbeitest Du also mit einer Kopie. Dies ist ineffizient, vor allem bei langen Strings.
Bei dieser speziellen Schreibweise wird nur ein Zeiger übergeben, zudem wird durch den Compiler dafür gesorgt, daß nichts am String-Inhalt geändert werden kann.
Diese Variante entspricht der 2., allerdings wirkt sich eine Änderung des Strings auch auf den aufrufenden Teil aus.

Alle numerischen Datentypen bis zur Länge 32 bit werden in Registern übergeben, benutzt werden dabei EAX und EDX. Hast Du längere Datentypen oder mehr als vorhandene Register, geht das über den Stack. Aber das ist auch im Falle von Pointern so.

Wie es jetzt mit komplexen Strukturen, wie Arrays und Records ist, kann ich im Moment nicht sagen, das hab ich noch nicht ausprobiert. Kann schon sein, daß da die Daten als Kopie auf den Stack geworfen werden. Allerdings relativiert sich das Problem, weil man heutzutage eher mit Listen/Collections arbeitet, und da werden von Haus aus wieder Pointer benutzt.

Danke, O Love, jetzt verstehe ich. Bei const und var werden also automatisch Zeiger übergeben. In der Schule erfuhr ich nämlich nur die halbe Wahrheit, dass die Werte von Konstantenparameter nicht verändert, von Variablenparametern verändert werden können, was ja eigentlich ohnehin schon logisch ist. Das es sich hierbei wichtigerweise um Zeiger handelt, hat mein Informatiklehrer also einfach unterschlagen. Aber das Thema Zeiger wie vieles andere auch (z. B. Klassen...) wurde ja sowieso nicht behandelt... Traurig... :tr

Bei Delphi (und anderen modernen Programmiersprachen) versucht man mittlerweile, Zeiger zu vermeiden. Sie sind für eine Menge Fehler verantwortlich. Stell Dir nur mal vor, Du greifst auf einen Datenpuffer mittels Zeiger zu. Nun vergißt Du aber, die Abbruchbedingung korrekt anzuwenden, Dein Zeiger läuft über den eigentlichen Puffer hinaus.

Die klassische Informatik-Anwendung für Zeiger, (doppelt) verkettete Listen, erledigt man heute typischerweise mittels OOP, es gibt z.B. fertige String-Listen oder für kompliziertere Daten Collections. Dort greifst Du über abgesicherte Methoden auf die Daten zu, es kann nicht mehr zu Fehlern kommen.

Bei Delphi (und anderen modernen Programmiersprachen) versucht man mittlerweile, Zeiger zu vermeiden. Sie sind für eine Menge Fehler verantwortlich.

Zum Vergrößern anklicken....

Ja, seit ich die Zeiger eliminiert habe, treten jetzt auch keine Laufzeit-Exceptions mehr auf, wie das bis eben der Fall war

Stell Dir nur mal vor, Du greifst auf einen Datenpuffer mittels Zeiger zu. Nun vergißt Du aber, die Abbruchbedingung korrekt anzuwenden, Dein Zeiger läuft über den eigentlichen Puffer hinaus.

Zum Vergrößern anklicken....

Leider weiß ich über Datenpuffer nicht Bescheid, aber ich nehme an, dass die Adresse des Datenpuffers nicht statisch ist, richtig?

Da Du normalerweise nicht beeinflussen kannst, wo der angefordete Speicher herkommt, ist die Adresse immer eine andere. Aber das ist weniger das Problem. Stell Dir vor, Du forderst 1024 Byte an und bekommst einen Zeiger auf den Speicher. Jetzt kannst Du über den Pointer drauf zugreifen, aber eigentlich nur maximal 1024 Byte. Nichts verhindert aber, daß Du auf das 1025. Byte zugreifst. Es sei denn, ein anderer Prozeß hat den dahinterliegenden Speicher in Benutzung, dann bekommst Du die berühmte Zugriffsverletzung.

Ähnlich funktioniert das bei Arrays, die aber in der Regel nicht dynamisch zur Laufzeit erzeugt werden. Wenn Du in Delphi ein Array so deklarierst:
dann entspricht das einem angeforderten Speicher von 10x4 Byte. Der indizierte Zugriff ist eigentlich auch ein Pointer, nur ist das nicht so deutlich sichtbar. Nur wenn Du "range check" im Compiler aktiviert hast, bekommst Du eine Fehlermeldung beim Zugriff auf einen Index kleiner 1 oder größer 10. Die Prüfung zur Laufzeit ist zwar schön zur Fehlersuche, allerdings benötigt sie mehr Speicher und verlangsamt den Code.

Aha, danke für deine Hilfe. Das wird bestimmt nicht mein letztes Problem sein