STD FileSystem C ++

Un sistema de archivos mantiene y clasifica los archivos en un medio, a menudo uno o más discos de almacenamiento, de una manera que los haga accesibles para la recuperación. La mayoría de los sistemas de archivos modernos mantienen los archivos organizados en forma de árbol (o jerárquica). Uno o más nodos raíz se encuentran en la parte superior del árbol. El sistema de archivos es una biblioteca en el estándar C ++ 17 que nos permite trabajar con la ruta de archivo, los directorios, el estado y los errores de los archivos en un sistema de archivos jerárquico. El impulso.La biblioteca del sistema de archivos sirve como base para la creación de esta biblioteca estándar. Con esta biblioteca, exploraremos las diferentes funciones del sistema de archivos y su rendimiento en C ++ 17 y accederemos a sus propiedades y búsqueda. El espacio de nombres STD :: FileSystem del encabezado del sistema de archivos ofrece la biblioteca del sistema de archivos. Usaremos el alias de espacio de nombres dados en los siguientes ejemplos en todos los casos para mantener el código más simple.

Ejemplo 1: Uso de std :: filesystem :: existe

El sistema de archivos std :: proporciona la función que se utiliza para determinar si un archivo o directorio con la ruta o estado especificado ya existe. Para esto, implementamos un programa en el que importamos la biblioteca "sistema de archivos" y creamos una "demostración" de la función nula. Para la función de demostración, le damos la ruta y la función de estado del sistema de archivos de clase. Luego, empleamos la condición if-else para devolver la declaración de la existencia del archivo.

Dentro de la cláusula IF, invocamos la función "FS :: existe" y pasamos la variable "S" para el estado del archivo y "PTH" para la ruta del archivo. Si existe el estado del archivo y existe la ruta del archivo, imprime "encontrado". Y si el archivo no existe, se imprime la declaración "no encontrada". La función principal se implementa con la ruta de archivo y la creación de directorio.

Primero, especificamos la ruta del archivo. Luego, creamos el directorio y el enlace simbólico para el directorio para vincular los dos archivos. Todas las funciones que utilizamos son compatibles con la biblioteca del sistema de archivos. Para iterar sobre las entradas del directorio, utilizamos la función Directory_iterator.

#incluir
#incluir
#incluir
#incluir
espacio de nombres fs = std :: filesystem;
Void Demo (const fs :: rath & pth, fs :: file_status s = fs :: file_status )

std :: cout << pth;
if (fs :: status_ conocido (s) ? fs :: existe (s): fs :: existe (pth))
std :: cout << " Found\n";
demás
std :: cout << "Not Found\n";

int main ()

const fs :: Path FileBox "FileBox";
FS :: Create_Directory (FileBox);
std :: ofStream filebox/"file";
fs :: create_symlink ("no existe", filebox/"symlink");
demostración (FileBox);
For (const auto y entrada: FS :: Directory_Iterator (FileBox)))
demostración (entrada, entrada.estado());
fs :: remove_all (FileBox);

Para una compilación de funciones y códigos de C ++ 17, usamos los siguientes comandos. Por lo tanto, podemos ver la existencia de la ruta del archivo y el estado del archivo en la pantalla de salida:

Ejemplo 2: Uso de std :: filesystem :: file_size

El std :: filessystem :: file_size es una función proporcionada por la biblioteca std :: filessystem of C++. Consideremos el ejemplo donde se pasa la ruta del archivo y se crea el objeto asociado, junto con el tamaño del archivo que se recuperará. Como todas las funciones del sistema de archivos son compatibles con la biblioteca del sistema de archivos, agregamos la biblioteca "" a nuestro programa. Luego, con el espacio de nombres, etiquetamos el "sistema de archivos std :: como" fs ".

Luego, utilizamos la función de ruta FS :: y especificamos la ruta del archivo "principal.C". Luego, llamamos al std :: ofStream y pasamos el objeto de ruta de archivo dentro de él. Además, usamos la función put () que toma el personaje "A" para el uso normal. Después de eso, obtenemos el tamaño del archivo utilizando el sistema de archivos :: file_size function. Con el sistema de archivos :: eliminar la función, eliminamos la ruta del archivo. Al final, tenemos un bloque de intento para atrapar y lanzar el error si ocurre.

#incluir
#incluir
#incluir
espacio de nombres fs = std :: filesystem;
int main ()

FS :: Path filePath = fs :: current_path () / "principal.C";
std :: ofstream (filepath).Poner un');
std :: cout << "File size = " << fs::file_size(filepath) << '\n';
fs :: eliminar (filepath);
intentar
fs :: file_size ("/dev");
catch (fs :: filesystem_error & e)
std :: cout << e.what() << '\n';

Obtuvimos el tamaño del archivo implementando el programa con el sistema de archivos :: file_size function. Recibimos el error del sistema de archivos de no obtener el tamaño del archivo.

Ejemplo 3: Uso de la función std :: filesystem :: filesystem_error

Cuando el lanzamiento de las sobrecargas de las funciones de la biblioteca del sistema de archivos fallan, se lanza un objeto de error especificado por la clase std :: filessystem :: filessystem Error. Usamos el módulo de error del sistema que maneja el error del programa. Identificamos las rutas de los archivos inexistentes en el código posterior. El bloque Catch toma el std :: filesystem :: filesystem_error dentro de él para lanzar la excepción del sistema de archivos.

Aquí, utilizamos las diferentes llamadas de función para imprimir las excepciones para los archivos no encontrados. Utilizamos la función std :: what () para detectar la excepción que devuelve una secuencia de caracteres de extremo nulo. Luego, usamos la función ruta () con el objeto file_error "e". Por último, imprimimos el valor, el mensaje y la categoría generados a partir de la función de error del sistema de archivos. También generamos una declaración de código de error desde la función std :: error_code.

#incluir
#incluir
#incluir
int main ()

const std :: filessystem :: ruta desde "/nofile1/a", a "/nofile2/b";
intentar
std :: filessystem :: copy_file (de, a);

capt (std :: filessystem :: filesystem_error const & e)
std :: cout
<< "what(): " << e.what() << '\n'
<< "path1(): " << e.path1() << '\n'
<< "path2(): " << e.path2() << '\n'
<< "code().value(): " << e.code().value() << '\n'
<< "code().message(): " << e.code().message() << '\n'
<< "code().category(): " << e.code().category().name() << '\n';

std :: error_code err;
std :: filessystem :: copy_file (de, a, err);
std :: cout << "\nerror_code has non-throwing sets: " << err.message() << '\n';

Los errores son generados por la función file_error, ya que no se encuentra dicho archivo o directorio.

Ejemplo 4: Uso de std :: filesystem :: función absoluta

Tenemos otra función que whis es el "std :: filessystem :: absoluto" que proporciona la ruta absoluta del archivo. Una ruta es absoluta que siempre incluye el componente base y la lista completa de directorio que se necesitan para encontrar el archivo. Aquí, dentro de la función principal, usamos la función de ruta std :: filessystem :: y creamos su objeto como "FP". Luego, damos la ruta del archivo como "principal.C". Mostramos la ruta actual del archivo y la ruta absoluta del archivo especificado con el comando cout. La ruta absoluta se muestra pasando el objeto de ruta de archivo "FP" en la función "STD :: Files System :: Absolute".

#incluir
#incluir
espacio de nombres fs = std :: filesystem;
int main ()

std :: filessystem :: path fp = "principal.C";
std :: cout << "Current path " << fs::current_path() << '\n';
std :: cout << "Absolute path of" << fp << " is "
<< std::filesystem::absolute(fp) << '\n';

Podemos ver la ruta actual del archivo en nuestro sistema y la ruta absoluta del archivo que se obtiene de la función absoluta del sistema de archivos.

Conclusión

La biblioteca STD :: Files System, que tiene una variedad de funcionalidades, se introduce en C ++ 17. Pero solo cubrimos algunas funciones del sistema de archivos. Una biblioteca estándar contiene clases y funciones altamente beneficiosas y cuidadosamente construidas para tratar, y el manejo específico del sistema operativo se abstrae. Implementamos la función del sistema de archivos file_exist para conocer la existencia del archivo en nuestro primer ejemplo. Luego, utilizamos la función de tamaño de archivo para obtener el tamaño del archivo. Además, empleamos la función de error del sistema de archivos para mostrar cómo se generan las excepciones en un archivo. Además, utilizamos la función absoluta del sistema de archivos para obtener la ruta absoluta del archivo.