Código de C/Visual C - Leer los archivos de un directorio

Imágen de perfil

Leer los archivos de un directoriográfica de visualizaciones


C/Visual C

estrellaestrellaestrellaestrellaestrella(2)
Publicado el 26 de Noviembre del 2005 por Xavi
15.865 visualizaciones desde el 26 de Noviembre del 2005. Una media de 28 por semana
Ejemplo que muestra con clases, como guardar los nombres de archivo de un directorio dado.
Programado con GNU/g++-4.0

Versión 1
estrellaestrellaestrellaestrellaestrella(2)

Publicado el 26 de Noviembre del 2005gráfica de visualizaciones de la versión: Versión 1
15.866 visualizaciones desde el 26 de Noviembre del 2005. Una media de 28 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <iostream>
#include <fstream>
#include <dirent.h>
using namespace std;
 
/* clase que contiene la información de un archivo y la posición del siguiente si hay */
class Archivo
{
	public:
		Archivo(char * nombre)
		{
			nombreArchivo=nombre;
			apArchivoSiguiente=NULL;
		}
		~Archivo();
		char * mostrarNombreArchivo()
		{
			return nombreArchivo;
		}
		void apAsignarSiguiente(Archivo * siguiente)
		{
			apArchivoSiguiente=siguiente;
		}
		Archivo * apDevolverSiguiente(Archivo * siguiente)
		{
			return apArchivoSiguiente;
		}
	private:
		char * nombreArchivo;
		//hace referencia al siguiente archivo. El ultimo, siempre tiene valor NULL
		Archivo * apArchivoSiguiente;
};
/*
Cada clase Archivo, contiene el nombre del archivo y un apuntador a la siguiente clase Archivo.
La ultima clase Archivo, apunta a NULL.

    Archivo                   Archivo
**********************  |--**********************  |--NULL
* nombrearchivo      *  |  * nombrearchivo      *  |
**********************  |  **********************  |
* apArchivoSiguiente *---  * apArchivoSiguiente *---
**********************     **********************
*/
 
/* clase que a partir de un directorio, genera tantas clase Archivo como archivos contenga el directorio */
class Directorio
{
	public:
		Directorio(char * nombreDir)
		{
			nombreDirectorio=nombreDir;
			apArchivoInicial=NULL;
		}
		~Directorio();
		int leerDirectorio();
		void mostrarArchivos();
	private:
		//contiene el nombre del directorio a leer
		char * nombreDirectorio;
		//contiene un apuntador a la clase archivo con el primer archivo que se lee
		Archivo * apArchivoInicial;
		//contiene un apuntador a la clase archivo con el al ultimo archivo guardado
		Archivo * apArchivo;
};
 
int Directorio::leerDirectorio()
{
	DIR * dir;
	struct dirent * fichero;
	/*
	 * fichero->d_name 				Nombre del fichero
	 * fichero->d_type 				determina el tipo de fichero
	 */
 
	//abrimos una instancia al directorio
	dir=opendir(nombreDirectorio);
 
	Archivo * apTemporal;
	//si devuelve null, es que ha habido algun error
	if (dir!=NULL)
	{
		//bucle para leer todos los archivos del directorio
		while (fichero=readdir(dir))
		{
			//si NO es un directorio...
			if(fichero->d_type!=DT_DIR)
			{
				if(apArchivoInicial==NULL)
				{
					//no hay todavia ningun fichero añadido
					apArchivoInicial=new Archivo(fichero->d_name);
					apArchivo=apArchivoInicial;
				}else{
					//ya hay algun fichero introducido
					//apTemporal es igual apArchivo
					apTemporal=apArchivo;
					//se genera una nueva instancia de la case con el nuevo nombre
					apArchivo=new Archivo(fichero->d_name);
					//al apuntador anterior se le asigna el valor del nuevo archivo
					apTemporal->apAsignarSiguiente(apArchivo);
				}
			}
		}
		closedir(dir);
		return 1;
	}else{
		closedir(dir);
		cout << "no se ha podido abrir el directorio: " << nombreDirectorio << endl;
		return 0;
	}
};
 
void Directorio::mostrarArchivos()
{
	//si tiene por lo menos un archivo
	if(apArchivoInicial!=NULL)
	{
		Archivo * apArchivoListado;
 
		//apArchivoListado coje el valor inicial. apArchivoInicial apunta al primer archivo introducido
		apArchivoListado=apArchivoInicial;
		//vamos leyendo los diferentes archivos, hasta que lleguemos al ultimo. En el ultimo, apArchivoSiguiente apunta a NULL
		while(apArchivoListado->apDevolverSiguiente(apArchivoListado)!=NULL)
		{
			//mostramos el nombre del archivo
			cout << apArchivoListado->mostrarNombreArchivo() << endl;
			//apArchivoListado coje el valor del siguiente archivo introducido
			apArchivoListado=apArchivoListado->apDevolverSiguiente(apArchivoListado);
		}
		//al salir del while porque apArchivoSiguiente vale NULL, todavia no hemos mostrado el valor del archivo en si
		cout << apArchivoListado->mostrarNombreArchivo() << endl;
	}
};
 
 
int main(int argc,char * argv[])
{
	bool i;
	Directorio * apDirectorio;
	//si recibimos un parametro, intentaremos leer el directorio, sino leemos el directorio actual
	if(argc>=2)
		apDirectorio=new Directorio(argv[1]);
	else
		apDirectorio=new Directorio("./");
 
	//leemos el directorio
	i=apDirectorio->leerDirectorio();
	//mostramos los archivos leidos si no ha habido ningun problema
	if(i)
		apDirectorio->mostrarArchivos();
	return 0;
}



Comentarios sobre la versión: Versión 1 (2)

Johan
19 de Diciembre del 2005
estrellaestrellaestrellaestrellaestrella
Muy bueno, hacia mucho tiempo que buscaba un ejemplo así. Gracias :)
Responder
Mofo
26 de Enero del 2006
estrellaestrellaestrellaestrellaestrella
Muy buen codigo
Responder

Comentar la versión: Versión 1

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios

http://lwp-l.com/s1277