C/Visual C - Simulación de Sistema Operativo

Filtrado por el usuario: zzzz
<<>>
Filtrado por el usuario 'zzzz' (Eliminar fitro)
 
Vista:

Simulación de Sistema Operativo

Publicado por Novato (2 intervenciones) el 29/06/2002 03:17:49
Necesito ayuda.
Necesito desarrollar como un administrador de direcctorios y archivos el programa tiene que utilizar un archivo plano donde se guarde el arbol de directorios y archivos ademas en el mismo archivo debo copiar archivos desde windows a una sección de este archivo.
Para que me entiendan por ejemplo tengo un archivo de 1 mg los primeros 100k son para el arbol y los restantes para copiar archivos osea que cuando se guarda el nombre de un archivo este tiene que almacenar el byte de comienzo y final para poder manipular este archivo dado que las funciones que nos piden son:

archplano nombre, tamaño = en megabytes
cdir = crear directorios
rdir = borrar direcctorios debe avizar si tiene datos o no para eliminarlo
cdir = para accesar un direcctorio
cd... = para devolverse
cpyarc archivo de windows, archivo local = copia un archivo desde windows a nuestro archivo plano
exparc archivo local, archivo windows = exporta el archivo local a un archivo de windows para verificar que se copio bien la información
rarch = borrar archivos

Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Programa de administración de directorios y archivos

Publicado por Alejandro (913 intervenciones) el 06/03/2025 16:33:28
A continuación, te proporcionaré un esquema básico de cómo desarrollar un programa en C que actúe como un administrador de directorios y archivos, utilizando un archivo plano para almacenar la estructura del árbol de directorios y los archivos. Este programa incluirá las funciones que mencionaste.

Estructura del programa



1. Estructura de datos:
- Usaremos una estructura para representar un archivo y un directorio.
- El archivo plano contendrá la archivos.

2. Funciones:
- `archplano`: Inicializa el archivo plano.
- `cdir`: Crea un directorio.
- `rdir`: Borra un directorio.
- `cd`: Cambia el directorio actual.
- `cd..`: Regresa al directorio padre.
- `cpyarc`: Copia un archivo desde Windows al archivo plano.
- `exparc`: Exporta un archivo del archivo plano a Windows.
- `rarch`: Borra un archivo.

Ejemplo de código



Aquí tienes un ejemplo simplificado del programa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_DIRS 100
#define MAX_FILES 100
#define MAX_NAME 50
#define FILE_SIZE 1048576 // 1 MB
 
typedef struct {
    char name[MAX_NAME];
    long start_byte;
    long end_byte;
} File;
 
typedef struct {
    char name[MAX_NAME];
    int file_count;
    File files[MAX_FILES];
} Directory;
 
Directory directories[MAX_DIRS];
int dir_count = 0;
FILE *file_system;
 
void archplano(const char *filename) {
    file_system = fopen(filename, "wb+");
    if (!file_system) {
        perror("Error al crear el archivo plano");
        exit(1);
    }
    // Reservar espacio para el árbol de directorios
    fseek(file_system, 0, SEEK_SET);
    char buffer[FILE_SIZE] = {0};
    fwrite(buffer, sizeof(char), FILE_SIZE, file_system);
    fflush(file_system);
}
 
void cdir(const char *name) {
    if (dir_count < MAX_DIRS) {
        strcpy(directories[dir_count].name, name);
        directories[dir_count].file_count = 0;
        dir_count++;
        printf("Directorio '%s' creado.\n", name);
    } else {
        printf("Límite de directorios alcanzado.\n");
    }
}
 
void rdir(const char *name) {
    for (int i = 0; i < dir_count; i++) {
        if (strcmp(directories[i].name, name) == 0) {
            if (directories[i].file_count == 0) {
                // Mover el último directorio al lugar del eliminado
                directories[i] = directories[dir_count - 1];
                dir_count--;
                printf("Directorio '%s' eliminado.\n", name);
            } else {
                printf("No se puede eliminar el directorio '%s' porque contiene archivos.\n", name);
            }
            return;
        }
    }
    printf("Directorio '%s' no encontrado.\n", name);
}
 
void cpyarc(const char *windows_file, const char *local_file) {
    // Implementar la lógica para copiar un archivo desde Windows al archivo plano
    // Aquí se debe abrir el archivo de Windows, leer su contenido y escribirlo en el archivo plano
}
 
void exparc(const char *local_file, const char *windows_file) {
    // Implementar la lógica para exportar un archivo del archivo plano a Windows
}
 
void rarch(const char *name) {
    // Implementar la lógica para borrar un archivo
}
 
int main() {
    archplano("filesystem.dat");
    cdir("Documents");
    cdir("Pictures");
    rdir("Documents");
    rdir("Pictures");
    return 0;
}

Notas sobre el código



1. Estructura de datos: Se definen estructuras para representar archivos y directorios.
2. Funciones básicas: Se implementan funciones para crear y eliminar directorios. Las funciones para copiar y exportar archivos deben ser implementadas según tus necesidades específicas.
3. Archivo plano: Se crea un archivo plano que reserva espacio para el árbol de directorios y archivos.

Implementación de funciones faltantes



- `cpyarc` y `exparc`: Estas funciones deben abrir archivos en el sistema de archivos de Windows y copiar su contenido al archivo plano, o viceversa. Puedes usar funciones como `fopen`, `fread`, y `fwrite` para manejar la lectura y escritura de archivos.
- `rarch`: Esta función debe buscar un archivo en el directorio actual y eliminarlo, actualizando el archivo plano en consecuencia.

Conclusión



Este es un esquema básico para comenzar a desarrollar tu programa de administración de directorios y archivos. Puedes expandirlo y adaptarlo según tus necesidades específicas. ¡Buena suerte con tu proyecto!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar