Quitar dos espacios en cadena dejar uno

[Casimiro Noteví]

Empezado por escafandra

Delphi no puede estar protegido contra esto pues muchas estructuras de windows definen un elemento de un array de dimensión desconocida y dada por el tamaño de la estructura, conocido más tarde.
Saludos.

Pero mientras no se sepa qué dimensión tiene, debería ser null y no dejar acceder.

[[escafandra]]

Empezado por Casimiro Notevi

Pero mientras no se sepa qué dimensión tiene, debería ser null y no dejar acceder.

Te pongo un ejemplo típico:

La estructura WLAN_AVAILABLE_NETWORK_LIST es usada para obtener una lista de redes wifi disponiobles, la API WlanGetAvailableNetworkList recibe por referencia un puntero a un elemento WLAN_AVAILABLE_NETWORK_LIST y devuelve la lista deseada en un bloque de memoria a la que apunta el puntero pasado.
Esta es la definición:

Código Delphi [-]
TWLAN_AVAILABLE_NETWORK_LIST = record
    dwNumberOfItems: DWORD;
    dwIndex: DWORD;
    Network: array[0..0] of TWLAN_AVAILABLE_NETWORK;
end;

Observa que el array Network definido en la estructura solo contiene un elemento, sin embargo puede tener muchos mas. Cuando WlanGetAvailableNetworkList nos devuelva el puntero a la lista de redes (WLAN_AVAILABLE_NETWORK_LIST), Windows informa del número de elementos que tiene en dwNumberOfItems. Nosotros navegaremos por el array Network donde están las redes, el límite lo controlaremos nosotros pero no delphi.

Casos como el que expongo son habituales cuando se trabaja a nivel de API. Un compilador que limite los índices no sería operativo a bajo nivel y delphi lo es.


Saludos.

[Casimiro Noteví]

Sí. te entiendo, no había pensado en esos casos.
Aunque puestos a buscar soluciones seguras podrían usar otro forma, por ejemplo un array dinámico o alguna otra solución.

[ecfisa]

Hola.

Con el fin de entender esto, me puse a investigar un poco. Y de lo conocido, mas lo que pude ampliar leyendo, una variable de tipo AnsiString contiene un apuntador que almacena un valor nulo si está vacía o de modo contrario apunta a la dirección del comienzo de una cadena finalizada en nulo al estilo de las cadenas C.

Pero no termina allí, el formato en que se almacena este tipo es:

[contador de referencias] [longitud de cadena] [cadena + nulo]

El contador de referencias mantiene la cantidad de variables que apuntan a esa cadena en un momento determinado. La longitud de la cadena es almacenada de forma similar a como lo hacía Pascal y por último sigue la cadena en si misma, finalizada en nulo como en C. Lo que hace que este tipo sea una especie de tipo híbrido entre Pascal y C.

El contador de referencias se incrementa cada vez que una cadena es asignada a una variable y se decrementa cuando deja de hacerlo. De este modo cuando el contador llega a cero la memoria previamente reservada es liberada de forma automática; del mismo modo es liberada cuando sale de su ámbito (al estilo de C++). Las variables de este tipo también se inicializan como cadenas vacías de forma automática.

Por último cuando se concatena carácter a carácter, es posible que se libere y reasigne memoria en cada asignación. De lo que resulta, por ejemplo, que es mas eficiente hacer:

Código Delphi [-]
  SetLength(s, 15);
  FillChar(s[1], 15, Ord(' '));

que:

Código Delphi [-]
  for i := 1 to 15 do str := str + ' ';

Haciendo unas pruebas pude pude lograr que se produzca error que buscaba:

Código Delphi [-]
procedure foo(const str: string);
var
  s: string;
  i: Integer;
begin
  for i := 1 to 100 do s := s + str[i];
end;

// Llamada que funciona
procedure TForm1.btnWithoutErrorClick(Sender: TObject);
var
  str: string;
begin
  str := #0;  // o inicializada con cualquier caracter
  foo(str);
end;

// Llamada que produce error
procedure TForm1.btnWithErrorClick(Sender: TObject);
var
  str: string;
begin
  str := EmptyStr; // u omitiendo la línea
  foo(str);
end;

y como se puede ver, sucede cuando el argumento no fue previamente inicializado.

Por último, la función del mensaje #9, resistió todas mis pruebas sin generar ningún error.

En definitiva, no encontré la alusión concreta que buscaba, pero sé un poco mas al respecto .

Saludos

[roman]

Estoy confundido con sus confusiones

¿Cómo está eso de que "Creía que con delphi se estaba "protegido" ante esas problemáticas."?

Por un lado, como ya comentó escafandra, delphi permite el acceso fuera del rango especificado por un arreglo para datos a los que se quiere acceder de esa forma pero que no se conocen sino hasta la ejecución. Pero, por otro lado, ¿les suena conocido eso de {$R+}? Esa directiva al compilador impide tal acceso, así que sí: delphi nos protege hasta de eso y poder acceder fuera de rango hay que avisarle {$R-} que no queremos que nos proteja .

Por otro lado, leer más allá de los índices posiblemente no de errores pero debe hacerse siempre y cuando sepamos qué vamos a leer. En el caso presente, debíamos saber que en Length+1 no había un espacio y eso no podíamos asegurarlo si no lo asignábamos nosotros mismos.

Finalmente, ya había mencionado porqué cambia el comportamiento cuando se asigna un valor a Memo1.Text caracter a caracter o de un sólo golpe. La asignación a la propiedad Text implica el envio del mensaje WM_TEXT al control, que eventualmente manejará la API de Windows. Si bien el string de delphi no tiene problemas para manejar #0's, la API de Windows cortará cualquier cadena que se envie en el primero #0 que vea. Pero cuando lo hacemos caracter por caracter, si llegaos a un #0, ése no aparecerá en el memo, pero como seguimos avanzando, sí aparecerá cualquier otro caracter que no sea #0.

// Saludos

[Casimiro Noteví]

Empezado por roman

Estoy confundido con sus confusiones

Puede que esté confundido por el cambio de lenguaje

[[AgustinOrtu]]

Roman, Daniel y Casimiro confundidos? Mejor mantener las narices lejos

[Casimiro Noteví]

Los años no perdonan