delphi - software - ¿Hay alguna ventaja en el uso de los parámetros de const con un tipo ordinal?

delphi technologies

Question

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

Siempre he usado parámetros const cuando manejo cadenas, pero nunca para Integer , Pointer , instancias de clase, etc.

Cuando uso const , a menudo tengo que crear variables temporales adicionales, que reemplazan los parámetros ahora protegidos contra escritura, así que me pregunto: ¿gano algo desde el marcado de parámetros ordinales como const ?

Answer 1

Debes comprender el motivo, para evitar la "programación de culto de carga". Marcar cadenas como const hace una diferencia en el rendimiento porque ya no es necesario utilizar 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 que tiene para hacer 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 generalmente son de 4 bytes o menos, no hay ganancia de rendimiento. El uso de const como optimización solo funciona cuando se utilizan tipos de valores que son mayores que 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 tiene ninguna importancia para el compilador, puede marcar una diferencia para usted , 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 diferencia porque se copian de todos modos (llamada por valor), por lo que cualquier cambio en la variable no afecta 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

Depende de qué tan compleja es tu 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 hay 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 4

Hay una gran mejora de velocidad al utilizar Const con cadenas:

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;

predeterminado: 443 const: 320 var: 325

valor predeterminado: 444 const: 303 var: 310

predeterminado: 444 const: 302 var: 305

Lo mismo con enteros:

predeterminado: 142 const: 13 var: 14

Curiosamente, en 64 bits parece que casi no hay diferencia con las cadenas (el modo predeterminado es solo un poco más lento que Const):

valor predeterminado: 352 const: 313 var: 314

Answer 5

No puede tratarlos accidentalmente como parámetros var y hacer compilar su código. Entonces hace tus intenciones claras.