Como acabamos de decir, necesitamos algún método para averiguar las unidades lógicas disponibles en el sistema. Para ello, debemos echar mano del API Win32, que nos ofrece una función muy interesante: GetLogicalDrives. Sin embargo, para poder utilizar esta función tenemos que saber cómo trabajar a nivel de bits, ya que nos retorna un valor de 4 bytes, en el que cada bit individual representará la existencia o ausencia de una unidad. La posición del bit indicará la unidad (el primer bit por la derecha para la unidad A:, el siguiente para la unidad B:, y así sucesivamente), mientras que el valor (0 ó 1) indicará si la unidad está disponible o no.
Para ir recorriendo estos 32 bits, debemos hacer un bucle que recorra las letras desde la “A” a la “Z” (las posibles unidades), e ir verificando en cada vuelta el valor del bit: en la primera vuelta, el primer bit por la derecha, en la segunda vuelta, el segundo bit, en la tercena, el siguiente, etc. Para ello, haremos uso de una técnica para el acceso a bits individuales a través de lo que llamamos una “máscara”. Esta técnica se utiliza para averiguar si un bit de una posición concreta tiene el valor 1 ó 0.
Vamos a explicarlo con un ejemplo: supongamos que tenemos el siguiente valor de 8 bits (1 byte): 101100101. Necesitamos averiguar el valor del primer y cuarto bit (la posición de los bits siempre se empieza a contar por la derecha). Para ello, haremos una operación “and” de ese bit con el valor 1. Si el resultado de esa operación es 1, significará que el bit que estamos buscando está activo (tiene el valor 1), y si el resultado es 0, significará que el bit está también a 0.
101100101
and 000000001
000000001
Por cierto, ya sabéis que el resultado a nivel de bit de una operación “and” es 1 (true) cuando los dos operandos son 1. Así que, para averiguar si el primer bit está activo, debemos hacer la operación del listado de la derecha.
Como veis, se va operando cada uno de los bits, de forma vertical, dando como resultado otro número en notación binaria. El resultado final (1 si lo convertimos a decimal) nos indica que el primer bit está activo.
101100101
and 000001000
000000000
Si ahora queremos averiguar el valor del cuarto bit, podéis ver la operación tal y como aparece en el listado de la derecha. En este caso, como veis, el resultado final, en decimal, es 0, lo que nos indica que el cuarto bit no está activo.
Al segundo operando, que contiene un bit en la posición que más nos interesa, se le suele llamar “máscara de bits”.
Bien, ya conocemos la base teórica que necesitamos para utilizar la función GetLogicalDrives. La implementación final pasa por obtener los 32 bits retornados por la función, e ir recorriendo, a través de un bucle, cada uno de ellos para averiguar su valor. Para ello, necesitaremos una máscara que con la que operar en cada vuelta del bucle. La máscara debe tener a 0 todos sus bits, excepto el bit de la posición de la vuelta que estemos dando, es decir:
- 1ª vuelta: todos a 0 excepto el primer bit: 00000000000000000000000000000001
- 2ª vuelta: todos a 0 excepto el segundo bit: 00000000000000000000000000000010
- 3ª vuelta: todos a 0 excepto el tercer bit: 00000000000000000000000000000100
- 4ª vuelta: todos a 0 excepto el cuarto bit: 00000000000000000000000000001000
- enésima vuelta: todos a 0 excepto el bit n.
Para conseguir esto, debemos hacer uso del operador “shl”, que desplaza todos y cada uno de los bits de un número, una posición a la izquierda, rellenando los espacios libres que queden a la derecha con ceros. Así, si desplazamos el valor 11011 a la izquierda, el resultado será 10110, perdiendo el valor del último bit (el cuarto), y añadiendo un cero al primer bit.
Combinando estas dos técnicas, podemos averiguar las unidades existentes, tal y como podéis ver en el siguiente listado
procedure BuscaUnidades;
var
unidades: DWORD;
mascara: DWORD;
u: char;
msg: string;
begin
unidades := GetLogicalDrives;
mascara := 1;
comenzamos con el primer bit activo
msg := 'Unidades válidas: ';
for u:='A' to 'Z' do
begin
comprobar si está activo el bit
if (unidades and mascara) <> then
msg := msg + u + ', ';
mascara := mascara shl 1;
desplazar hacia la izquierda todos los bits
end;
quitar la coma final
msg := Copy(msg, 1, Length(msg) - 2);
mostrar el resultado
ShowMessage(msg);
end;
