constantes de classes demasiado estáticas :P

[[Al González]]

Hola Poyo. Como siempre un gusto.

Al menos hasta Delphi 7, el compilador no permite la declaración de constantes de clase.

Comparto la opinión de Marcelo.

Entiendo que las constantes de clase sirven para encapsular, dentro de una clase, valores fijos que pueden ser resueltos en tiempo de compilación (una manera de definir el concepto constante) y que habrán de ser utilizados principalmente por los métodos de esa clase.

Claro, para alguna rutina exterior también podrían ser útiles, pero veo que esperabas que tuvieran el mismo efecto dinámico de los métodos virtuales. No estoy seguro de que eso deba ser así, pues el comportamiento normal de un método es estático, ¿entonces por qué el comportamiento normal de una constante de clase debería ser virtual?

Creo que la solución que buscas debería hacerse con métodos clase virtuales.

Aunque claro, sería estupendo que el compilador aceptara esta forma alternativa de declarar métodos:

Código Delphi [-]
TPlaneta = class(TObject)
public
  Class Function Gravedad : Double = 0; Virtual;
end;

TTierra = class(TPlaneta)
public
  Class Function Gravedad : Double = 9.81; Override;
end;

(sin mayor implementación de los mismos).

De momento, escribir la implementación con Begin y End tampoco significa un gran esfuerzo.

Saludos.

Al González.

[[Delphius]]

Empezado por Al González

Comparto la opinión de Marcelo.

Muchas gracias Al.

Esta vez dije algo y no me llevo el tirón de orejas o una patadita bien merecido... ¡eso significa que estoy aprendiendo!

Empezado por Al González

Creo que la solución que buscas debería hacerse con métodos clase virtuales.

Yo no veo otra alternativa, según lo que tengo entendido y estudiado al momento.

Empezado por Al González

Aunque claro, sería estupendo que el compilador aceptara esta forma alternativa de declarar métodos:

Código Delphi [-]
TPlaneta = class(TObject) 
  public Class Function Gravedad : Double = 0; Virtual; 
end;  
TTierra = class(TPlaneta) 
  public Class Function Gravedad : Double = 9.81; Override; 
end;

(sin mayor implementación de los mismos).

De momento, escribir la implementación con Begin y End tampoco significa un gran esfuerzo.

Saludos.

Al González.

Yo me haría un lío. No niego que se ahorra lineas y que puede llegar a ser interesante... pero yo que estoy acostumbrado a "lo de siempre"... encontrarme con algo así me desorientaría.

Saludos,

[poyo]

sería fantástico declarar las funciones así!
lástima...

el tema es que, en principio, tengo que hacer muchísisimas clases (más de 40, en un principio) donde cada clase tiene al menos 4 métodos virtuales que tengo que escribir para devolver un simple string... :'(
La idea era ahorrarme la declaración y la implementación que involucran las funciones de Clase.
Antes de ponerme de ese modo voy a probar un poco con las variables de clase, aunque estas necestan inicialización (ya que no se les puede asignar el valor en la declaración)
Gracias por las respuestas!

[roman]

Empezado por Delphius

Desconozco como es el concepto de constante de clase, más me llama la atención de que se pretenda modificar el valor. Digo... si es que el concepto de constante se mantiene, es para mi de esperar que el valor no pueda ser sobreescrito en una clase descendiente.

Yo siempre he entendido una constante como un valor que no cambia durante la ejecución. En este sentido, lo que dice poyo se ajusta a la definición, más allá de si las clase heredadas revalúan la constante. Esto es, el cambio de valor al pasar de una clase a una descendiente, sale del ámbito de ejecución, se realiza al codificar, más no al ejecutar.

La verdad es que yo vería muy natural que las constantes de clase se comportasen como esperaba poyo. El mismo ejemplo que da con ClassName es, en mi opinión, bastante esclarecedor.

En alguna ocasión me enfrenté a algo similar, queriendo hacer una jerarquía de clases para encapsular entidades reales como TCliente, TFactura, TProducto, etc., todas ellas descendientes de una clase base TObjetoPersistente.

Para saber en qué tabla de la base se debían guardar los datos, cada clase debía inicializar una propiedad TableName en el constructor. Pero, realmente, dicha propiedad es una propiedad de la clase y no de una instancia en particular; así que se antojaba tener dichas constantes de clase.

Como comenta Al, se puede hacer uso de funciones de clase virtuales, pero no deja de mosquear el hecho de tener una función que siempre regresa el mismo valor, ¿para qué?

En fin, que no aporto nada, pero quería comentar que no se me hace extraña la necesidad del comportamiento que esperaba poyo.

// Saludos

[[Al González]]

Empezado por roman

...En fin, que no aporto nada, pero quería comentar que no se me hace extraña la necesidad del comportamiento que esperaba poyo.

Vaya, al menos a mí me hace reflexionar lo que comentas. Viéndolo como explicas, quizá no estaría mal que las constantes de clase tuvieran esa capacidad.

[poyo]

Bueno, les cuento que al final lo resolví poniendo variables de clase.
A la clase base le puse un método virtual llamado "initclassvars" y allí las inicializo todas juntas.
Ese método lo ejecuto or única vez en la registración de mis classes...
De esta manera achiqué CONSIDERABLEMENTE la cantidad de líneas a escribir de unas 1000 a "apenas" alrededor 350. Comparando con lo que hubiese sido lo más lógico: funciones de clase... pero me negaba a escribir taaantas veces lo mismo!
Era eso un Bot que escriba por mí. jejejeje
Nuevamente. Gracias por ayudarme a despejar mis dudas.

--------------------------------------------------------
EDITO: Lo que puse antes fue porque canté victorio de apresurado sin haber hecho las suficientes pruebas!!!!
Eso me pasa por neófito!

Resulta que una clase que hereda de otra clase un "Class Var", hereda exactamente la misma variable... con la misma posición y todo... o sea, la MISMA variable y no otra de similares características.
Es como si fuese una global pero que se accede con la clase como referencia:

TClassEjemplo.Variable := 'valor';

o sea que si tenemos:

Código Delphi [-]
TClassEjemplo = class(TObject)
  public
    Class var cadena: string;
end;

TClassHija = class(TClassEjemplo)
end;

y yo ejecuto:

Código Delphi [-]
TClassHija.Cadena := 'valor nuevo';

Voy a estar cambiando implícitamente el valor de TClassEjemplo.cadena;

Para que cada en una nueva clase REALMENTE sea otra "Class Var", es decir con otro puntero en memoria, esta tiene que ser vuelta a declarar (no existe override, simplemente se declara del mismo modo y listo):

Código Delphi [-]
TClassHija = class(TClassEjemplo)
  public
    Class var cadena: string;
end;

Perdón por el apuro.
Ahora estoy pensando si agrego líneas de declaración de variables o simplemente pongo una función de clase que devuelva un record con todo junto y se acabó

[[Al González]]

¡Hola Poyo!

Aunque quizá hay mejores soluciones (habría que ver el fondo de esta necesidad ), se me ocurre, por ejemplo, el uso de propiedades con índice y tener un arreglo global con todos los valores posibles de la constante de clase.

Desarrollé un ejemplo para ilustrarlo:

Código Delphi [-]
implementation

{$R *.dfm}

Uses
  TypInfo;

Const // Cambiar a "Var" para emular variable de clase en vez de constante
  Cadenas :Array [0..2] Of String = ('X de TA', 'X de TB', 'X de TC');

Type
  {$TypeInfo On}  // Para generarle RTTI a la clase TA y sus descendientes
  TA = Class
    Private
      // Método de lectura de la propiedad
      Function GetX (Indice :Integer) :String;
    Published
      { Declaración base de la propiedad que emulará una constante de
        clase virtual.  Añadir especificador "Write SetX" para emular una
        variable de clase virtual en lugar de una constante. }
      Property X :String Index 0 Read GetX;
  End;
  {$TypeInfo Off}

  TB = Class (TA)
    Published
      Property X Index 1;
  End;

  TC = Class (TA)
    Published
      Property X Index 2;
  End;

Function TA.GetX (Indice :Integer) :String;
Begin
  { Para que la solución sea polimórfica, es necesario consultar en la RTTI
    el índice que tiene la propiedad X para el objeto actual, en lugar de
    usar el índice que llega como parámetro (ver la diferencia comentando
    esta sentencia) }
  Indice := GetPropInfo (Self, 'X').Index;

  { Devolvemos la cadena que corresponde del arreglo global }
  Result := Cadenas [Indice];
End;

procedure TForm1.Button1Click(Sender: TObject);
Var
  A, B, C :TA;
begin
  { TEMA: Emular constante de clase "virtual" mediante una propiedad
    publicada con índice y soportando polimorfismo. }

  { Aunque las tres variables están declaradas como de clase TA, les
    asignamos instancias nuevas de clase distinta }
  A := TA.Create;
  B := TB.Create;
  C := TC.Create;

  { Aunque las tres variables estén declaradas con la misma clase, y a
    todas las compilemos como objetos TA, en tiempo de ejecución el
    programa leerá el valor correcto de la propiedad X para cada objeto,
    según la clase real a la cual pertenecen (polimorfismo) }
  ShowMessage (A.X);
  ShowMessage (B.X);
  ShowMessage (C.X);

  // Liberamos los objetos (usar Try..Finally en un caso real)
  A.Free;
  B.Free;
  C.Free;
end;

Anexo el código en un archivo .zip.

Saludos.

Al González.

[[Delphius]]

Hola poyo,
Me gustaría que nos comentases a que se debe todo. Si en vez de trabajar con ejemplos abstractos nos comentases con mayores detalles sobre tu caso real, tal vez podríamos proponerte alguna otra alternativa o enfoque que puedas considerar.

Si, muy cierto es que si ya tienes bastante código no es bueno cambiarlo, pero quizá si nos compartes más del caso podríamos entre todos ver de que otra manera darle la vuelta y sin que tengas que afectar todo el diseño.

Saludos,