(const Value: string) vs (Value: string)

[eliash]

Por qué

procedure SetText(const Value: string)

que es lo que escribe delphi por defecto (code completion la llaman) al poner una property...
y no sencillamente

procedure SetText(Value: string);

Equivale este último a ...?

procedure SetText(var Value: string);

quizás parezca una tontería, pero me tiene realmente despistado

??

[roman]

De la ayuda de Delphi:

Using const allows the compiler to optimize code for structured- and string-type parameters. It also provides a safeguard against unintentionally passing a parameter by reference to another routine.

En otras palabras, optimización y seguridad de que tus rutinas no alterarán accidentalmente los parámetros.

// Saludos

[[maeyanes]]

Aquí te pongo lo que dice la ayuda de Delphi sobre parámetros constantes:

Empezado por Delphi Help

A constant (const) parameter is like a local constant or read-only variable. Constant parameters are similar to value parameters, except that you can't assign a value to a constant parameter within the body of a procedure or function, nor can you pass one as a var parameter to another routine. (But when you pass an object reference as a constant parameter, you can still modify the object's properties.)

Using const allows the compiler to optimize code for structured- and string-type parameters. It also provides a safeguard against unintentionally passing a parameter by reference to another routine.

Here, for example, is the header for the CompareStr function in the SysUtils unit:

Código Delphi [-]
function CompareStr(const S1, S2: string): Integer;

Because S1 and S2 are not modified in the body of CompareStr, they can be declared as constant parameters.

Espero que te sirva para aclarar tu duda.


Saludos...



Update: Como siempre, Román se me adelantó...

[vtdeleon]

Saludos

Empezado por Essential Pascal - Marco Cantù

Parámetros constantes

Como alternative a los parámetros de referencia, puede usar un parámetro const. Ya que no puede asignar un nuevo valor a un parámetro constante dentro de una rutina, el compilador puede optimizar la transmisión de parámetros. El compilador puede elegir un enfoque similar para parámetros de referencia (o una referencia const, términos de C++), pero el comportamiento seguirá siendo similar a los parámetros de valor, porque el valor original no se verá afectado por la rutina.

De hecho, si intenta compilar el siguiente código (trivial), Delphi producirá un error :

Código Delphi [-]
function DoubleTheValue (const Value: Integer): Integer;
begin
  Value := Value * 2;      // error de compilación
  Result := Value;
end;

Parámetros de referencia
...
Transmitir un parámetro por referencia significa que su valor no se copia en la pila del parámetro formal de la rutina (evitar una copia a menudo significa que el programa se ejecuta más rápido). En su lugar, el programa hace uso del valor original, también en el código de la rutina. Esto permite al procedimiento o función cambiar el valor del parámetro. La transmisión de parámetros por referencia se expresa con la palabra clave var.
He aquí un ejemplo de transmisión de un parámetro por referencia mediante el uso de la palabra clave var:

Código Delphi [-]
procedure DoubleTheValue (var Value: Integer);
begin
  Value := Value * 2;
end;

{En este caso, el parámetro se usa tanto para transmitir un valor al 
procedimiento como para devolver un nuevo valor al código de llamada. Cuando se escribe ...
}
var
  X: Integer;
begin
  X := 10;
  DoubleTheValue (X);
end;

Yo creo que esto está claro

[vtdeleon]

Llegue tarde


Saludos

[[Lepe]]

A ver si puedo explicarlo sencillamente o no

Código Delphi [-]
procedure SetText(const Value: string)
procedure SetText(Value: string)

En principio, esos dos compadres son iguales, pero no es lo mismo.

En el primero, cuando dentro de SetText intentas hacer una asignación a Value, es decir, del tipo

Código Delphi [-]
procedure SetText(const Value:String);
begin
   Value := 'pepe que no';
end;

Aqui delphi en compilación no te deja modificar la variable, porque ha sido pasada con el Const.

En este otro caso:

Código Delphi [-]
procedure SetText(Value:String);
begin
   Value := 'pepe que si que si';
end;

Value, dentro de la funcion, te permite modificarla, pero creo que con esto queda más claro:

Código Delphi [-]
var valor:string;
begin
  valor := 'pepe';
  SetText(valor);
  showmessage(valor);
end;

valor tendrá 'pepe', dentro de la funcion SetText, se le da el valor 'pepe que si que si', pero solo dentro de la funcion SetText, cuando salga, es decir en el showMessage saldrá 'pepe'

Obviamente, si ponemos SetText(var Value:String);
se modifica el valor, y en el showMessage, saldrá 'pepe que si que si'

Por tanto, poner el "Const" es un seguro de vida, si quieres modificar la variable localmente o no.

Otra cosa distinta es cuando se pasan objetos:

Código Delphi [-]
procedure SetText(const Value: Tcomponent)
procedure SetText(Value: Tcomponent)

En este caso se pasa un puntero (de 4 bytes) al objeto, por tanto, todos los objetos se pasan por referencia, da igual si pones const, si no lo pones, o si lo pasas con var. De las 3 formas podrás modificar las propiedades del objeto, el width, height, etc.

saludos

[[Lepe]]

Empezado por vtdeleon

Llegue tarde

Pues yo mejor me voy a la cama.... mañana será otro día... que ya van dos hilos a los que llego tarde hoy....

saludos

[roman]

Empezado por Lepe

En este caso se pasa un puntero (de 4 bytes) al objeto, por tanto, todos los objetos se pasan por referencia, da igual si pones const, si no lo pones, o si lo pasas con var. De las 3 formas podrás modificar las propiedades del objeto, el width, height, etc.

Aquí hay una inexactitud. Claro que de cualquier forma puedes modificar las propiedades de los objetos, pero no es lo mismo usar o no usar const o usar o no usar var.

Para empezar está el asunto de la optimización que menciona la ayuda de Delphi en cuanto al uso del const. Por otra parte lo que se pasa como const o var no es el objeto sino la referencia al objeto, y ésta sí que puede cambiarse (o evitar que se haga).

Aquí un ejemplo extraído de código de Phil Brown:

Código Delphi [-]
type
  TPDClass = class of TPDObject;

  TPDObject = class
  protected
    function GetObject(ClassType: TPDClass; var PDObject: TPDObject): TPDObject;
  end;

  TOrder = class(TPDObject)
  private
    FCustomer: TCustomer;

  public
    property Customer: TCustomer read GetCustomer;
  end;

implementation

function TPDObject.GetObject(ClassType: TPDClass; var PDObject: TPDObject): TPDObject;
begin
  if PDObject = nil then
    PDObject := ClassType.Create;

  Result := PDObject;
end;

function TOrder.GetCustomer: TCustomer;
begin
  Result := TCustomer(GetObject(TCustomer, FCustomer));
end;

Aquí la idea es lo que llaman "lazy construction". Objetos como TOrder pueden tener objetos relacionados como TCustomer. Cuando esto se lee de la base de datos, normalmente conviene cargar el objeto relacionado sólo cuando se le llame.

Phil Brown utiliza un método genérico en la clase base para cargar los objetos relacionados de manera que los descendientes simplemente tengan que hacer un moldeo al tipo de datos adecuado.

En este método base, GetObject, el campo que respalda la propiedad (FCustomer en el caso de TOrder), aún no ha sido creado la primera vez que se le llama. Y lo que GetObject está cambiando es la referencia al objeto (de hecho está creando una nueva). Para ello fue imprescindible el uso de var en la declaración de GetObject.

// Saludos

[[Lepe]]

Exacto.

No quise profundizar en ese sentido, por eso dije explicitamente que podía modificar sus propiedades .

Sin duda, el hilo ha quedado mucho más completo ahora.

saludos

[jachguate]

A las buenas explicaciones ya dadas quisiera añadir algunos "detalles":

Cuando un parámetro se define con los modificadores "const" o "var", este es pasado "por referencia", es decir, es un puntero a la variable original lo que la función recibe, ocupando solamente 4 bytes de memoria en la pila.

En cambio, si una variable de 1000 bytes es pasada sin modificadores (por valor), estos 1000 bytes son copiados en la pila y liberados cuando se sale de la rutina. Esto puede provocar errores de desbordamiento de la pila, por ejemplo, en llamadas recursivas. (Un caso típico es el paso de strings al estilo pascal (string[xx])),

Por último, con respecto de:

Empezado por Lepe

En este caso se pasa un puntero (de 4 bytes) al objeto, por tanto, todos los objetos se pasan por referencia, da igual si pones const, si no lo pones, o si lo pasas con var. De las 3 formas podrás modificar las propiedades del objeto, el width, height, etc.

Efectivamente, de cualquiera de las 3 formas se pueden modificar las propiedades del objeto, pero la diferencia sigue existiendo y es significativa, trataré de explicarme con un ejemplo:

Código Delphi [-]
Procedure DoSomething1(const objeto : TObject);
begin
  objeto.Propiedad := NuevoValor;
  //objeto := Button2;  //error de compilación
  objeto.Parent := Panel1; 
  //dentro de la rutina solamente puede usarse el "objeto" enviado como
  //parámetro, (sigue siendo una medida de seguridad.
end;

Procedure DoSomething2(objeto : TObject);

begin
  objeto.Propiedad := NuevoValor;
  objeto := Button2;  //sentencia válida
  objeto.Parent := Panel1; 
end;

Procedure DoSomething3(var objeto : TObject);
begin
  objeto.Propiedad := NuevoValor;
  objeto := Button2;  //sentencia válida
  objeto.Parent := Panel1; 
end;

//Ejemplos de llamada;

Procedure TForm1.Button1Click(Sender : TObject);
Var
  Objeto : TObject;
begin
  Objeto := Button1;
  DoSomething1(Objeto);  
  ShowMessage(Objeto.Name); //Button1
  DoSomething2(Objeto);
  ShowMessage(Objeto.Name); //Button1
  DoSomething3(Objeto);
  ShowMessage(Objeto.Name); //Button2
end;

¿se entendió la diferencia?

[eliash]

Gracias a todos por la aclaración; sobre todo a Lepe, que lo ha dejado muy bien explicado