Ci sono dei vantaggi nell'usare i parametri const con un tipo ordinale?

Question

So che la marcatura dei parametri delle stringhe come const può fare un'enorme differenza di prestazioni, ma per quanto riguarda i tipi ordinali? Guadagno qualcosa rendendoli const?

ho sempre usato const parametri durante la manipolazione stringhe, ma mai per Integer, Pointer, istanze di classi, ecc

Quando si utilizza const spesso devo creare variabili temporanee aggiuntive, che sostituiscono l'ormai protetti dalla scrittura parametri, quindi mi chiedo: ottengo qualcosa dal contrassegnare i parametri ordinali come const?

Answer 1

È necessario comprendere il motivo, per evitare la "programmazione settoriale del carico". Contrassegnare le stringhe come const fa una differenza di prestazioni perché non è più necessario utilizzare un incremento interlocked e decrementare il refcount sulla stringa, un'operazione che diventa effettivamente più costosa, non meno, con il passare del tempo perché più core significa più lavoro che deve essere fatto per mantenere sincronizzate le operazioni atomiche. Questo è sicuro da fare poiché il compilatore impone il vincolo "questa variabile non verrà modificata".

Per gli ordinali, che di solito sono 4 byte o meno, non si ottiene alcun guadagno in termini di prestazioni. L'utilizzo di const come ottimizzazione funziona solo quando si utilizzano tipi di valore superiori a 4 byte, ad esempio matrici o record o tipi conteggiati di riferimento come stringhe e interfacce.

Tuttavia, c'è un altro importante vantaggio: la leggibilità del codice. Se passi qualcosa come const e non fa alcuna differenza per il compilatore, può ancora fare la differenza per tu, dal momento che puoi leggere il codice e vedere che l'intenzione era di farlo non essere modificato. Questo può essere significativo se non hai visto il codice prima (qualcuno l'ha scritto) o se torni indietro dopo molto tempo e non ricordi esattamente cosa stavi pensando quando lo hai scritto originariamente.

Answer 2

La dichiarazione dei tipi ordinali const non fa alcuna differenza in quanto vengono comunque copiati (call-by-value), pertanto eventuali modifiche apportate alla variabile non influiscono sulla variabile originale.

IMHO che dichiara i tipi ordinali const non ha senso e, come dici tu, richiede di introdurre spesso variabili locali.

Answer 3

Non è possibile trattarli accidentalmente come i parametri var e compilare il codice. Quindi rende chiare le tue intenzioni.

Answer 4

Dipende da quanto è complessa la routine e da come viene utilizzata. Se viene utilizzato in molti luoghi e richiesto che il valore rimanga lo stesso, dichiararlo come "const" per renderlo libero e sicuro. Per il tipo di stringa, c'era un bug (per Delphi 7 che stump su di esso) che causa il danneggiamento della memoria se si dichiara come "const".Qui di seguito è codici di esempio

type 
    TFoo = class 
    private 
    FStr: string; 
    public 
    procedure DoFoo(const AStr: string); 
    begin 
     FStr := AStr; //the trouble code 1 
     ...... 
    end; 
    procedure DoFoo2; 
    begin 
     ..... 
     DoFoo(FStr); //the trouble code 2 
    end; 
    end; 

Answer 5

C'è un enorme miglioramento della velocità utilizzando Const con le stringhe:

function test(k: string): string; 
begin 
    Result := k; 
end; 

function test2(Const k: string): string; 
begin 
    Result := k; 
end; 

function test3(Var k: string): string; 
begin 
    Result := k; 
end; 

procedure TForm1.Button1Click(Sender: TObject); 
Var a: Integer; 
    s,b: string; 
    x: Int64; 
begin 
    s := 'jkdfjklf lkjj3i2ej39ijkl jkl2eje23 io3je32 e832 eu283 89389e3jio3 j938j 839 d983j9'; 

    PerfTimerInit; 
    for a := 1 to 10000000 do 
    b := test(s); 
    x := PerfTimerStopMS; 
    Memo1.Lines.Add('default: '+x.ToString); 

    PerfTimerInit; 
    for a := 1 to 10000000 do 
    b := test2(s); 
    x := PerfTimerStopMS; 
    Memo1.Lines.Add('const: '+x.ToString); 

    PerfTimerInit; 
    for a := 1 to 10000000 do 
    b := test3(s); 
    x := PerfTimerStopMS; 
    Memo1.Lines.Add('var: '+x.ToString); 
end; 

default: 443 const: 320 var: 325

default: 444 const: 303 var : 310

valore predefinito: 444 const: 302 var: 305

Stessa cosa con numeri interi:

default: 142 const: 13 var: 14

interessante notare, però, a 64-bit non sembra esserci quasi nessuna differenza con le stringhe (modalità predefinita è solo un po 'più lento const):

predefinito: 352 const: 313 var: 314