¿Hay alguna ventaja en usar parámetros const con un tipo ordinal?

Question

Sé que marcar los parámetros de cadena como const puede hacer una enorme diferencia en el rendimiento, pero ¿qué ocurre con los tipos ordinales? ¿Gano algo haciéndolos const?

Siempre he usado const parámetros al manipular cadenas, pero nunca para Integer, Pointer, instancias de clases, etc.

Al utilizar const A menudo tengo que crear variables temporales adicionales, que sustituyen a la ahora protegidos contra escritura parámetros, así que me pregunto: ¿gano algo al marcar los parámetros ordinales como const?

Answer 1

Necesita comprender la razón, para evitar la "programación de culto a la carga". Marcar cadenas como const hace una diferencia en el rendimiento porque ya no necesita usar un incremento entrelazado y decremento del refcount en la cadena, una operación que en realidad se vuelve más cara, no menos, con el paso del tiempo porque más núcleos significa más trabajo eso tiene que hacerse para mantener sincronizadas las operaciones atómicas. Esto es seguro ya que el compilador aplica la restricción "esta variable no cambiará".

Para los ordinales, que suelen ser de 4 bytes o menos, no hay ganancia de rendimiento. Con const, la optimización solo funciona cuando usa tipos de valores de más de 4 bytes, como matrices o registros, o tipos contados como cadenas e interfaces.

Sin embargo, hay otra ventaja importante: la legibilidad del código. Si pasa algo como const y no hace ninguna diferencia en absoluto al compilador, aún puede hacer una diferencia en , ya que puede leer el código y ver que la intención es que no se modifique. Eso puede ser significativo si no has visto el código antes (alguien más lo escribió) o si vuelves a él después de un largo tiempo y no recuerdas exactamente lo que estabas pensando cuando lo escribiste originalmente.

Answer 2

declarar tipos ordinales const no hace ninguna diferencia porque se copian de todos modos (call-by-value), por lo que los cambios en la variable no afectan a la variable original.

procedure Foo (Val : Integer) 
begin 
Val := 2; 
end; 
... 
SomeVar := 3; 
Foo (SomeVar); 
Assert (SomeVar = 3); 

En mi humilde opinión declarar tipos ordinales const no tiene sentido y como dices requiere que introduzcas variables locales a menudo.

Answer 3

No puede accidentalmente tratarlos como var parámetros y tener su compilación de código. Entonces hace tus intenciones claras.

Answer 4

Depende de qué tan compleja es su rutina y cómo se usa. Si se usa en muchos lugares y requiere que el valor permanezca igual, declarelo como "const" para que sea despejado y seguro. Para el tipo de cadena, había un error (para Delphi 7 cuando toco) que causa daños en la memoria si se declara como "const".A continuación se muestra códigos de muestra

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

Hay una gran mejora en la velocidad usando Const con cuerdas:

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; 

por defecto: 443 const: 320 var: 325

por defecto: 444 const: 303 var : 310

predeterminado: 444 const: 302 var: 305

Lo mismo pasa con los números enteros:

por defecto: 142 const: 13 var: 14

Curiosamente, sin embargo, en 64 bits parece que hay casi ninguna diferencia con las cadenas (modo por defecto es solamente un poco más lenta que Const):

defecto: 352 const: 313 var: 314