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

[[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