Newsgroup: it.comp.lang.delphi
Titolo: Prima volta con i puntatori ad array in funzioni...qualcuno mi dà delucidazioni?

Salve!
E' la prima volta che mi ritrovo ad dover lavorare con delle funzioni 
alle quali passare un puntatore ad una serie di bytes (un'array di bytes).
La funzione deve manipolare questi bytes e ritornare a sua volta una 
serie di bytes...
Dimeti se procedo bene...continua adarmi errori ma me lo 
aspettavo...finchè non finisco di "codare" la funzione...
Definizioni:
var:
Charset: array[0..4] of Byte =($30,$31,$32,$33,$34);
Ritorno: array [0..4] of byte=($0,$0,$0,$0,$0);
La funzione che vorrei fare è incrementare di 1 il primo valore di 
charset e restituire l'intero array in "Ritorno" (per adesso voglio solo 
lavorare sul primo valore...tanto per fare una prova!!!!!)
un qualcosa tipo:
Ritorno:=Funzione(Charset);
Quindi definisco queste cose:
type
TStringbytes = array of byte;
e la funzione:
function funzione(input: TStringbytes): TStringbytes;
function TForm1.funzione(input:TStringArray): retu;
begin
input[1]:=input[1]+1;
retu:=input;
end;
Ma quando la chiamo:
Ritorno:=funzione(Charset);
il compilatore dice che sono incompatibili i tipo array e tstringbytes
Qualcono mi spiega cosa sbaglio?
Grazie infinite!

Ma prima di compilare etc hai letto bene il tuo codice?
A.


Hai le idee un po' confuse.
Andiamo per ordine....
1) Per il Delphi un elemento e' uguale ad un altro solo se ha lo stesso 
tipo di base.
Per cui se dichiari:
Type
   TMioArray = Array[0..4] Of Byte;
Var
   Primo : TMioArray;
   Secondo : TMioArray;
Primo e Secondo sono dello stesso tipo ma se invece scrivi
Var
   Primo : Array[0..4] Of Byte;
   Secondo : Array[0..4] Of Byte;
Primo e secondo sono diversi.
2) Il ritorno di una funzione e' un tipo e non una variabile.
Per cui se hai dichiarato
Type
   TMioArray= Array[0..4] Of Byte;
allora la definizione Function MiaFunzione : TMioArray e' valida, ma se 
dichiari
Var
   Primo : Array[0..4] Of Byte;
la definizione Function MiaFunzione : Primo non puo' essere accettata
3) Se un array e' dichiarato array[0..n] of byte il primo elemento e' 0 
e non 1 (lo hai dichiarato tu)
4) L'uso di una funzione o di una procedura varia a seconda di quello 
che devi fare e di come hai dichiarato le variabili/tipi del progetto.
Se dichiari una cosa cosi':
Type
   TMioArray = Array[0..4] Of Byte;
Var
   Vettore : TMioArray;
   Ritorno : TMioArray;
ed in ritorno hai i tuoi valori di uscita, allora ti conviene usare una 
procedura (l'uscita gia' l'hai)
Procedure Incrementa_e_Copia;
Var
   I : Byte;
Begin
   // Copio il vettore di uscita
   // si puo' anche scrivere Move(vettore, Ritorno, SizeOf(Vettore))
   For I := 0 To 4 Do Ritorno[I] := Vettore[I];
   // Modifico il primo byte
   // si puo' anche scrivere Inc(Ritorno[0])
   Ritorno[0] := Ritorno[0] + 1;
End;
Se invece lo vuoi trasformare in funzione (con la stessa dichiarazione)
Function Incrementa_e_Copia : TMioArray;
Var
   Rit : TMioArray;
   I   : Integer;
Begin
   // Copio il vettore di uscita
   // si puo' anche scrivere Move(vettore, Rit, SizeOf(Vettore))
   For I := 0 To 4 Do Rit[I] := Vettore[I];
   // Modifico il primo byte
   // si puo' anche scrivere Inc(Rit[0])
   Rit[0] := Rit[0] + 1;
   // Setto l'uscita
   Result := Rit;
End;
e dall'estero la vedrai come
Ritorno := Incrementa_e_Copia;
ovviamente ritorno e' una variabile che hai dichiarato
Ancora un'ultima cosa... la dichiarazione
var:
  Charset: array[0..4] of Byte =($30,$31,$32,$33,$34);
  Ritorno: array [0..4] of byte=($0,$0,$0,$0,$0);
e' errata per due motivi
1) dopo var non ci vanno i due punti
2) Si chiamano costanti e quindi si scrivera' Const invece di Var

Dimenticavo gli open array ovvero quegli array senza una dimenzione 
prefissata tipo questo
Type
   TMioArray = Array of Byte;
In questo caso il primo elemento ha come indice 0, devi sempre 
dichiararne la lunghezza e puoi saperne le dimensioni con Low ed High 
(Low ritorna l'indice piu' basso ed High ritorna l'indice piu' alto)
Facciamo un esempio con i tuoi dati:
Type
   TMioArray = Array Of Byte;
Const
   Ingresso : Array[0..4] Of Byte = ($30,$31,$32,$33,$34);
   Ritorno  : TMioArray;
Function Incrementa(Indice : Byte) : TMioArray;
Var
   Rit : TMioArray;
   I   : Integer;
Begin
   // Creo l'uscita di dimensione esatta
   SetLength(Rit, 5);
   // Copio il vettore di uscita
   For I := 0 To 4 Do Rit[I] := Vettore[I];
   // Incremento il termine che mi interessa
   Rit[Indice] := Rit[Indice] + 1;
   // Setto l'uscita
   Result := Rit;
End;
Se non conosco la dimensione del vettore VETTORE posso scrivere
Function Incrementa(Indice : Byte) : TMioArray;
Var
   Rit : TMioArray;
   I   : Integer;
Begin
   // Creo l'uscita di dimensione esatta
   SetLength(Rit, High(Vettore)-Low(Vettore)+1);
   // Copio il vettore di uscita
   For I := Low(Vettore) To High(Vettore) Do Rit[I] := Vettore[I];
   // Incremento il termine che mi interessa
   Rit[Indice] := Rit[Indice] + 1;
   // Setto l'uscita
   Result := Rit;
End;
Ciao