¿1 Bit?

[pevi]

Es que ando ahorrando espacio para unos registros y no se si es posible guardar informacion usando solo un bit.

Es decir, quiero guardar informacion de por ejemplo Booleanos, True o false, 1 o 0. Informacion de solo un bit, pero delphi 7.0 guarda esta informacion en bytes.

¿Hay alguna manera de k solo ocupe un bit?

Saludos.

[dec]

Hola,


Es decir, quiero guardar informacion de por ejemplo Booleanos, True o false, 1 o 0. Informacion de solo un bit, pero delphi 7.0 guarda esta informacion en bytes.

El tipo "boolean" ocupa en Delphi 1 "byte" y no un "bit". Creo que no podrás hacer lo que quieres, si no estoy equivocado. No me sabré explicar, pero, lo que se guarda en memoria no es solamente el dato "en sí", sino algo más. ¿Qué algo más? Pues, por ejemplo, la información precisa para saber qué es ese dato en concreto, qué representa. No sabría ir más allá, pero, ya digo, un "booleano" no ocupa un solo "bit", sino 1 "byte".

[delphi.com.ar]

¿Hay alguna manera de k solo ocupe un bit?
Utilizando el resto del byte para almacenar el resto de la informacióm booleana, utilizando los operadores lógicos.

Saludos!

[dec]

Hola,


Utilizando el resto del byte para almacenar el resto de la informacióm booleana, utilizando los operadores lógicos.

¿Me lo puede repetir más despacio, por favor? Muchas gracias. ;)

[delphi.com.ar]

Digamos, si utilizas el primer bit de un byte para guardar un dato del tipo boolean (No es lo que hace el tipo boolean)... ¿Porqué no utilizar el resto para guardar 7 valores mas?
Puede hacerse a la antigua, utilizando los opreadores lógicos, por ejemplo marcando un bit con el operador or y preguntando por este con el and. O bien en lugar de utilizar este tipo de datos, podemos utilizar SETs... que Delphi los maneja de forma muy inteligente:

{ Extraída de http://www.clubdelphi.com/foros/showthread.php?t=23514 }
function IntToBase(Value: Integer; const Pattern: string): string;
var
B, R: Integer;
begin
Result := '';
B := Length(Pattern); { Base }
repeat
R := Value mod B; { Resto }
Result := Pattern[R+1] + Result;
Value := Value div B;
until Value = 0;
end;

{ Con conjuntos }
procedure TForm1.Button1Click(Sender: TObject);
type
TBits = set of(Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);
var
B: TBits;
begin
B := [Bit1, Bit2, Bit5, Bit8];
Caption := IntToBase(Byte(B), '01');
end;

{ con operadores lógicos }
procedure TForm1.Button2Click(Sender: TObject);
var
B: Byte;
begin
B := $1 or $2 or $10 or $80;
Caption := IntToBase(Byte(B), '01');
end;


Saludos!

[Casimiro Notevi]

Qué tiempos aquellos en los que había que ahorrar memoria por todos lados y teníamos que trabajar con bits :p

¡Cómo cambian las cosas!, ahora da igual si ocupa 8 u 80 megas, ahora es habitual conversaciones del estilo:

Ahora:
- ¿qué longitud le ponemos a este campo?
- ponle 50 bytes
- bueno, mejor 100, por si acaso
- pues ya puesto, dale 1000 y asi nos cubrimos la espalda
- vale, pues 1000.

Antes:
- ¿qué longitud le ponemos a este campo?
- 48 bytes
- uff, muchos son, 48 bytes * 10.000 registros = 480000 bytes
- es verdad, falta espacio, mejor 32
- vale, le doy 30 y que pongan abreviaturas

Es que todo tiene su parte buena y su parte mala.

[dec]

Hola,


function IntToBase(Value: Integer; const Pattern: string): string;
var
B, R: Integer;
begin
Result := '';
B := Length(Pattern); { Base }
repeat
R := Value mod B; { Resto }
Result := Pattern[R+1] + Result;
Value := Value div B;
until Value = 0;
end;

Yo con la función "IntToBase" ya tengo para estudiar lo que queda de año. Gracias Federico. Qué envidia, chico. Te felicito. ;)

[OSKR]

Saludos!, yo aqi desde mi mundo en C(pp) puedo hacer eso con "campos de bits", supongo q pascal ha de tener algo semejante pero aun no lo he visto



struct bits
{
unsigned tres : 3;
unsigned dos: 2;
unsigned dos2: 2;
unsigned paridad: 1;
};

//...............
bits Recep_puerto;
//..............

Recep_puerto.tres=8; (max 8 porq son solo 3 bits)

//o si quiero descomponer un char seria algo asi:
Recep_puerto=(char)otra_variable;

[DarkByte]

Por supuesto! C tiene esa maravillosa propiedad. Al igual que cuando creas una matriz has de indicar su espacio en memoria. Delphi lo omite salvando así buffers overflows y otras salvajadas cuando te excedes en el rango de memoria.

[roman]

Al igual que cuando creas una matriz has de indicar su espacio en memoria. Delphi lo omite salvando así buffers overflows y otras salvajadas cuando te excedes en el rango de memoria.

¿Qué quieres decir con esto?

Cuando declaras un arreglo en Delphi también le especificas el tamaño al decirle el número de elementos y el tipo de datos. Y si son arreglos dinámicos debes especificar el tamaño con SetLength.

// Saludos

[Mick]

Si usamos Delphi 7 no hace falta reinventar la rueda, basta utilizar
la clase TBits, que precisamente implementa un array de booleanos pero
utilizando un solo bit de informacion por booleano.

Saludos

[delphi.com.ar]

Si usamos Delphi 7 no hace falta reinventar la rueda, basta utilizar
la clase TBits, que precisamente implementa un array de booleanos pero
utilizando un solo bit de informacion por booleano.
Creo que no es el caso, cualquier clase en Delphi (por lo menos los de 32 bits), solo su puntero, ocupa al menos 4 bytes...

[roman]

El tipo "boolean" ocupa en Delphi 1 "byte" y no un "bit".

[...]

pero, lo que se guarda en memoria no es solamente el dato "en sí", sino algo más. ¿Qué algo más? Pues, por ejemplo, la información precisa para saber qué es ese dato en concreto, qué representa. No sabría ir más allá, pero, ya digo, un "booleano" no ocupa un solo "bit", sino 1 "byte".

Corríjanme si me equivoco pero que yo sepa, el tipo de dato no es algo que se guarde como parte del dato.

Independientemente de como quieran presentar el uso de bits, lo cierto es que aun cuando sólo manejen 3 bits, el dato que guarden ocupará como mínimo 1 byte. Incluso en C, con la estructura que menciona OSKR, se requerirá por lo menos 1 byte.

La memoria de una PC es, en todo caso, una secuencia de bytes, no de bits. Aun cuando podemos examinar los bits individuales, el procesador debe manejar bytes enteros. Por ello un booleano requiere el byte completo aun cuando sólo un bit tenga significado.

// Saludos

[dec]

Hola,


Corríjanme si me equivoco pero que yo sepa, el tipo de dato no es algo que se guarde como parte del dato.
Sin duda no supe expresarme roman. A lo mejor estoy equivocado, pero, no es que se guarde como parte del dato, pero sí está "al lado" del dato en la memoria, es decir, ocupando un espacio "unido" al dato en cuestión, de forma inexorable, precisamente, porque se necesita saber qué representa el dato.



La memoria de una PC es, en todo caso, una secuencia de bytes, no de bits. Aun cuando podemos examinar los bits individuales, el procesador debe manejar bytes enteros. Por ello un booleano requiere el byte completo aun cuando sólo un bit tenga significado.
Sí; efectivamente, no había pensado en eso a la hora de escribir en este Hilo, pero, según tengo entendido de lecturas varias así es como tú bien dices. La unidad que maneja el ordenador (creo que más concretamente el procesador/computador) es el "byte", o sea, "una palabra", o sea 8 bits.

Corrección: lo que se conoce como "palabra" no es concretamente un byte, o sea 8 bits, sino dos bytes, o sea, 16 bits. Y aún cabría añadir que las palabras actuales son las de 32 bits, y ya también las de 64 bits.

[roman]

pero sí está "al lado" del dato en la memoria, es decir, ocupando un espacio "unido" al dato en cuestión, de forma inexorable, precisamente, porque se necesita saber qué representa el dato.


Pues o no te estoy entendiendo o acabas de decir lo mismo pero de forma más rebuscada
:D

En memoria no se guarda ninguna información acerca del tipo de dato. Por ejemplo, en una locación de memoria podrías tener el byte


01000001


Esto puede ser o bien el número 65 o bien el caracter 'A'. ¿Cómo se distingue qué tipo de datos es? No es algo que suceda en tiempo de ejecución.

Basado en el tipo de datos declarado en el código fuente, el compilador manejará la información como mejor convenga para efectos de la compilación, pero en la memoria (o en el archivo ejecutable) no colocará nada aparte del 01000001, ni a la izqueirda ni a la derecha ni en ninguna otra parte.

Claro está que esto vale para tipos de datos simples. Pero incluso records, arrays estáticos e incluso sets no guardan ninguna información acerca del tipo de datos.

Por eso, precisamente, es que Federico puede hacer algo como Byte(B) siendo B un conjunto:


B := [Bit1, Bit2, Bit5, Bit8];


ya que el conjunto se almacena en el espacio de un byte como una suma de potencias de dos y, si se sabe lo que se hace, se le puede indicar al compilador que trate esa parte de la memoria como un byte. El "casting" lo resuelve el compilador, no es algo que suceda durante la ejecución.

// Saludos

[dec]

Hola,

No puedo sino decir que has de llevar razón roman, porque lo que yo tengo son vagos conceptos de lecturas diversas y acaso mal aprovechadas y lo que tú demuestras es sapiencia, mucho conocimiento de causa, o sea, que, desde luego, si tuviera que quedarme con mi "teoría" o con la tuya no lo dudaría un momento. ;) No todos los días, pero, algunos (claro está), hay posibilidades de aprender algo nuevo.

[kalimero]

Hola a todos.
Bueno me surge una duda:Y cuando se ejecuta el programa ¿Quien decide que la secuencia de bits (01000001) que tengo que dibujar en pantalla es el 65 ó el caracter 'A'?
Saludos

[roman]

Supongo que nadie. Eso ya está decidido desde la compilación.

Si tu pones

Write(v)

el compilador, supongo que examinará el tipo de datos de v declarado en el código fuente, si es integer generará el código necesario para imprimir un 65, y si es char, generará el código necesario para imprimir 'A' en la pantalla.

Disclaimer:
Nada de lo que estoy diciendo estoy 100% seguro. Por ello comencé con "Corríjanme si me equivoco"

// Saludos

[kalimero]

Si Román, aunque no se mucho del tema ,eso mismo pensaba yo.
Un tema bastante interesante y que da mucho juego

Saludos

[Mick]

Creo que no es el caso, cualquier clase en Delphi (por lo menos los de 32 bits), solo su puntero, ocupa al menos 4 bytes...

Realmente cualquier clase ocupa un poco mas de 4 bytes. Pero estamos hablando de uso de array de bits, y eso esta pensado para guardar muchos elementos, y ahi es donde nos ahorramos mucha memoria, ya que el coste de memoria para gestionar la clase es fijo.
Es decir si necesitamos 16384 booleanos por ejemplo, usando un objecto TBits gastamos 16384/8= 2048 bytes de memoria + unos pocos bytes fijos de la clase asi como de la cabecera del bloque de memoria reservado para guardar la info (pueden ser sobre 20 bytes a mayores).
En cambio 16384 booleanos reales ocupan 16384*4 = 65536 bytes.
Es decir es un ahorro enorme de casi 32 a 1.

Saludos

[dec]

Hola,

Voy a extractar de cierto libro titulado El gran libro de Delphi 2, de Jens Herber, Jörg Herbes y Jörg Rensmann, traducido por varios autores. No los nombro pero sin ellos, etc.


5.2 Tipos de datos estándar y su utilización

Todos los programas de ordenador, y todos [los] datos escritos escritos por usted y que utiliza este programa, constan de una secuencia de bits en la memoria. Un bit es una posición de memoria cuyo valor puede ser 0 ó 1. Una zona cualquiera del contenido de la memoria podría presentar el aspecto siguiente:

011001110010101110110101

En principio todo parece indicar que esta secuencia de bits carece por completo de estructura. Por lo tanto se tiene que crear una normativa para poder interpretarla inequívocamente. A tal fin se realiza, en primer lugar, una división en bytes, cada uno de los cuales comprende 8 bits. A continuación, se reúnen dos bytes para formar lo que se denomina palabra, que contiene, por tanto, 16 bits.

Falta aún por conocer el tipo del valor representado en la memoria por esta secuencia de bits para que se pueda interpretar el contenido de esa memoria. El tipo del valor contiene el número de bits pertenecientes al valor representado por la secuencia y la forma en que este valor se ha codificado en unos y ceros. Sólo conociendo el tipo del valor quedará claro si esta zona de la memoria representa un número entero, un número de coma flotante, caracteres, texto o cualquiera otras estructuras de datos.

Además del tamaño y la forma en que se codifica un valor, un tipo de datos contiene otras informaciones. Dado que todo tipo de datos tiene un tamaño determinado en la memoria, no puede representar cualquier número. Como consecuencia, cada tipo de datos tiene un rango de valores definido cuyas cotas, inferior y superior, no se deben sobrepasar. Así, mediante la declaración de tipo se especifica el rango de valores que puede tomar una variable o constante de este tipo.

Si un tipo de datos tuviese una longitud de una palabra, es decir 2 bytes ó 16 bits, podrá representar, como máximo, 2 [elevado a 16] = 65.536 valores distintos, ya que cada bit sólo puede tomar dos valores distintos (0 ó 1).

Además con el tipo de datos se definen también las operaciones permitidas para tal tipo. Así, para el tipo de datos Integer, que representa números enteros, están definidas, entre otras, las operaciones de suma, resta y producto. Esto facilita al compilador de Delphi un control de su manera de proceder con los tipos de datos: tan pronto como utilize una operación que no esté definida para el tipo de datos correspondiente, el compilador mostrará un mensaje de error y no ejecutará su aplicación.

El texto continúa, pero, con una descripción de los tipos simples y la típica tabla de tipos disponibles, con su descripción, rango de valores y longitud. Como de poco más que esto he tomado la información en que me he basado para escribir mi opinión en este Hilo, ahora, al releerlo y transcribirlo, pienso que estaba equivocado yo y que roman va por el buen camino: es Delphi el que se encarga del tipo de datos, es el compilador, no sé cómo lo hará, pero el tipo de datos no está unido, como pensaba, al dato en sí, según me deja entender el texto que acabo de transcribir.

[Mick]

Hola a todos.
Bueno me surge una duda:Y cuando se ejecuta el programa ¿Quien decide que la secuencia de bits (01000001) que tengo que dibujar en pantalla es el 65 ó el caracter 'A'?
Saludos

Esto tiene facil respuesta, lo decide el programador, cuando mandas imprimir algo debes indicar el formato, es decir como quieres que la computadora interprete y muestre esa lista de bits.


var
Variable:char;
begin
Variable:= 'A';
writeln(Format('%d',[Ord(Variable)])); // imprime 65
writeln(Format('%c',[Variable])); // imprime el caracter 'A';
end;

[kalimero]

Hola Mick.
Eso lo tengo claro, pero yo lo que quiero decir es que como se almacena dentro del ejecutable este formateo que indicas, es decir, cuando se estan ejecutando los ceros y unos ¿donde está escrito que sea una 'A' ó un 65?

Saludos a todos

[Mick]

Hola Mick.
Eso lo tengo claro, pero yo lo que quiero decir es que como se almacena dentro del ejecutable este formateo que indicas, es decir, cuando se estan ejecutando los ceros y unos ¿donde está escrito que sea una 'A' ó un 65?
Saludos a todos

No se almacena ningun tipo de formateo con la variable, en el ejecutable no hay nada mas que el numero 01000001.
Unicamente esta escrito que se imprima como A o como 65 directamente en la funcion que utilices para ordenar la impresion, o queda implicito por el tipo de variable, es decir:

Si tenemos declarada esta variable de tipo caracter:

var
Car:Char;

Y si usamos Format:

Format('%c',65);

El %c que se pasa como parametro a la funcion Format le indica que el segundo parametro debe ser tratado como un codigo ascii.

En el caso de usar funciones normales de pascal como:

write(Car);

Al ser delphi un lenguaje fuertemente tipado y estar definidos los tipos de variables previamente, el compilador sabe que Car debe tratarse como un caracter.
Luego en realidad el compilador va a sustituir write por WriteChar,
de modo que enn la realidad se estaria llamando a la funcion:

WriteChar(Car);

Es decir se llama a una funcion WriteChar que imprime solo caracteres y que trata siempre al valor que se le pase como un caracter.

Si Car fuera de tipo string, el compilador sustiye el Write por un

WriteString(Car);

Etc, para el resto de tipos de variables.

Si hacemos

Write(caracter, string);

En realidad el compilador lo sustituira por algo como:

WriteChar(caracter);
WriteString(string);

Saludos
Miguel