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