Delphi Vorbei Dynamisches array von Records zu funktionieren

Ich habe eine Dynamc array von Datensätzen und ich möchte an einem der Elemente im array an eine Funktion per Referenz

So zum Beispiel eines der array-Elemente - AArray[1].arecorditem eine Zeichenkette mit 6 Zeichen String[6]

die Funktion wäre -

function dosomething(var AStringVal:string):Integer;

So möchte ich ausführen,

Aresult:= dosomething(AArray[1].arecorditem);

jedoch, wenn ich versuche zu kompilieren bekomme ich die Fehlermeldung, Art der tatsächlichen und formalen var-Parameter müssen identisch sein.

Ist dies möglich oder sollte ich weisen Sie das array-Element in einen string und dann den string an die Funktion.

Dank

Colin

InformationsquelleAutor colin | 2011-12-06

5

Ihre Frage-Titel und die tatsächliche Frage sind nicht das gleiche, so gebe ich Ihnen einen überblick über beide Themen.

Müssen Sie definieren eine Array-Typ
```
TMyRecord = record
  Field1: String
  Field2: String
end;

TMyRecordArray = Array of TMyRecord

function DoSomething(const ARecordArray: TMyRecordArray): Integer;
```
Dies ist, wenn Sie wollen, um eine gesamten dynamischen array der Elemente auf die Funktion. Wenn Sie wollen einfach nur pass ein Element, Sie würden definieren Sie die Funktion wie folgt:
```
function DoSomething(const ARecord: TMyRecord): Integer;
```
Nun, wenn Sie wollen, passieren die Wert von Feld1 an die Funktion, Sie müssten die Funktion definiert als:
```
function DoSomething(const AField: String): Integer;
```
Sie nicht definieren Sie die parameter wie varoder Sie werden am Ende mit der Fehlermeldung, die Sie bekommen!

Zusätzliche:

Wie andere gesagt haben, wenn Sie mit einer Zeichenfolge fester Länge für das Feld, müssen Sie definieren es als eine Art eben, wie ich oben gezeigt für TMyRecordArray.
```
TString6 = String[6];
```
Verwenden, Geben Sie für das Feld, und Ihre Funktion Parameter.

InformationsquelleAutor LaKraven
4

Müssen Sie erstellen Sie einen Typ aus:
```
    type
      TName = string[80];
```
So rufen Sie Ihre Funktion auf diese Weise:
```
    function doSomething(var name: TName): Integer;
    begin
        ...
        ...
        ...
    end;  
```
Beispiel Arbeiten
```
program HelloWorld;

type
  TName = string[80];

type
  TCustomer = record
    name : Name;
    age : byte;
  end;

procedure qwerty(var name: TName);
begin
  name := 'doSomething';
end;

var
  customers : array[1..3] of TCustomer;
  b : Byte;
begin

  with customers[1] do
  begin
    name := 'qwerty';
    age := 17;
  end;

  with customers[2] do
  begin
    name := 'poiuy';
    age := 18;
  end;

  writeln(customers[1].name);

  qwerty(customers[1].name);
  writeln(customers[1].name);

  Readln(b);
end.
```
- Versuchen, die ungeschriebenen Konventionen Formatierung und syntax. Typen haben die T auf den Anfang des Wortes, wie ich in meinem nick 😉 bist du Jetzt mischen zwei Dinge zusammen, prüfen Sie die syntax Name: Name.
- Sind Sie eine Klasse oder eine Instanz? 😉
- Ich bin nur ein Typ 🙂 Manchmal wie eine Klasse, weil ich das Gefühl, ich brauche mehr Instanzen von mir die gleichen Dinge tun, die auf vielen Plätzen und manchmal wie eine deklarierte boolean-Typ, es kommt also drauf an 🙂
- Ich bin sicher, Sie hätte einen Witz über ein singleton-irgendwie......
- Ich fühle mich wie ein Faden, denn ich brauche immer mehr als einen der mir die Durchführung der gleichen Aufgabe zur gleichen Zeit zu erreichen, die ein schnelleres Ergebnis!
InformationsquelleAutor Eder
1

String[6] ist ein ShortString mit einer maximalen Länge von 255 Zeichen. Sie müssen ändern Sie entweder die definition von doSomething so etwas wie:
```
function dosomething(var AStringVal:string[6]):Integer;
```
oder
```
  function dosomething(var AStringVal:ShortString):Integer;
```
oder ändern Sie die definition des Datensatz, so dass arecorditem vom Typ String ist (im Gegensatz zu String[6]).
- string[6] ist kein Gültiger Typ in eine Funktion/Prozedur Deklaration. Deklarieren Sie Sie außerhalb, Geben Str6 = string[6];
InformationsquelleAutor Steve
0

Wenn Sie nicht ändern Sie den Wert des Parameters in der Funktion ändern können Sie die variable Typ in der Deklaration der Funktion zu const statt var, wird der compiler die Konvertierung für Sie tun:

Ändern von:
```
procedure doSomething(var AStringVal: String);
```
Zu diesem:
```
procedure doSomething(const AStringVal: String);
```
Nun können Sie dies tun, ohne zu Klagen:
```
var
  myShortString: String[6];
begin
  myShortString := '123456';
  doSomething(myShortString);
end;
```
Beim übergeben von Variablen per Referenz, Sie müssen vom selben Typ sein. Wenn Sie von anderen Mitteln, die der compiler wird versuchen, zu konvertieren für Sie.

InformationsquelleAutor Marcus Adams

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Beispiel Arbeiten