STD Filesystem C ++

Um sistema de arquivos mantém e classifica os arquivos em um meio, geralmente um ou mais discos de armazenamento, de uma maneira que os torna acessíveis para recuperação. A maioria dos sistemas de arquivos modernos mantém os arquivos organizados em uma forma de árvore (ou hierárquica). Um ou mais nós raiz estão localizados no topo da árvore. O sistema de arquivos é uma biblioteca no padrão C ++ 17, que nos permite trabalhar com o caminho, diretórios, status e erros dos arquivos em um sistema de arquivos hierárquicos. O impulso.A Biblioteca de sistemas de arquivos serve como base para a criação desta biblioteca padrão. Com esta biblioteca, exploraremos as diferentes funções do sistema de arquivos e seu desempenho no C ++ 17 e acessarão suas propriedades e pesquisas. O espaço nomes do STD :: FileSystem do cabeçalho do sistema de arquivos oferece a biblioteca do sistema de arquivos. Usaremos o alias de espaço para nome dado nos exemplos a seguir em todos os casos para manter o código mais simples.

Exemplo 1: Usando STD :: FileSystem :: Existe

O STD :: FileSystem fornece a função usada para determinar se um arquivo ou diretório com o caminho ou status especificado já existe. Para isso, implementamos um programa em que importamos a biblioteca "sistema de arquivos" e criamos uma função void "Demo". Para a função de demonstração, damos o caminho e a função de status do sistema de arquivos de classe. Em seguida, empregamos a condição de if-else para retornar a declaração da existência do arquivo.

Dentro da cláusula if, invocamos a função "fs :: existe" e passamos a variável "s" para o status do arquivo e "pTh" para o caminho do arquivo. Se o status do arquivo existir e o caminho do arquivo, ele imprime “encontrado”. E se o arquivo não existir, a declaração "não encontrada" será impressa. A função principal é implementada com o caminho do arquivo e a criação de diretórios.

Primeiro, especificamos o caminho do arquivo. Em seguida, criamos o diretório e o link simbólico para o diretório vincular os dois arquivos. Todas as funções que usamos são suportadas pela biblioteca de sistemas de arquivos. Para iterar sobre as entradas do diretório, usamos a função Directory_Iterator.

#incluir
#incluir
#incluir
#incluir
namespace fs = std :: filesystem;
Void Demo (const fs :: Path & Pth, FS :: file_status s = fs :: file_status )

std :: cout << pth;
if (fs :: status_known (s) ? FS :: Existe (s): fs :: existe (pTh))
std :: cout << " Found\n";
outro
std :: cout << "Not Found\n";

int main ()

const FS :: Path Filebox "FileBox";
fs :: create_directory (filebox);
std :: ofstream Filebox/"File";
fs :: create_symlink ("não existe", filebox/"symlink");
Demo (FileBox);
Para (const Auto & Entry: FS :: Directory_Iterator (Filebox))
Demo (entrada, entrada.status());
fs :: remover_all (Filebox);

Para uma compilação de funções e códigos C ++ 17, usamos os seguintes comandos. Portanto, podemos ver a existência do caminho do caminho e do arquivo na tela de saída:

Exemplo 2: Usando STD :: FileSystem :: file_size

O Std :: FileSystem :: File_size é uma função fornecida pela Biblioteca de STD :: FileSystem de C++. Vamos considerar o exemplo em que o caminho do arquivo é passado e o objeto associado é criado, juntamente com o tamanho do arquivo a ser recuperado. Como todas as funções do sistema de arquivos são suportadas pela biblioteca de sistemas de arquivos, adicionamos a biblioteca "" ao nosso programa. Então, com o espaço para nome, rotulamos o "std :: FileSystem" como "fs".

Em seguida, utilizamos a função FS :: Path e especificamos o caminho do arquivo “Principal.C ”. Então, chamamos o std :: ofstream e passamos o objeto do caminho do arquivo dentro dele. Além disso, usamos a função put () que leva o personagem "A" para uso normal. Depois disso, buscamos o tamanho do arquivo usando a função FileSystem :: file_size. Com o FileSystem :: Remover Função, removemos o caminho do arquivo. No final, temos um bloco de tentativa de pegar e jogar o erro se ocorrer.

#incluir
#incluir
#incluir
namespace fs = std :: filesystem;
int main ()

fs :: caminho filepath = fs :: current_path () / "main.C ";
std :: ofstream (filepath).colocar um');
std :: cout << "File size = " << fs::file_size(filepath) << '\n';
fs :: remover (filepath);
tentar
fs :: file_size ("/dev");
catch (fs :: filesystem_error & e)
std :: cout << e.what() << '\n';

Buscamos o tamanho do arquivo implementando o programa com a função FileSystem :: file_size. Recebemos o erro do sistema de arquivos de não obter o tamanho do arquivo.

Exemplo 3: Usando STD :: FileSystem :: FileSystem_error Função

Quando as sobrecargas de arremesso das funções da biblioteca do sistema de arquivos falham, um objeto de erro especificado pela classe Std :: FileSystem :: FileSystem Erro é lançado. Usamos o módulo de erro do sistema que lida com o erro do programa. Identificamos os caminhos dos arquivos inexistentes no código subsequente. O bloco de captura leva o std :: filesystem :: filesystem_error dentro dele para jogar a exceção do sistema de arquivos.

Aqui, usamos as diferentes chamadas de função para imprimir as exceções para arquivos não encontrados. Utilizamos a função STD :: What () para detectar a exceção que retorna uma sequência de caracteres de ponta nula. Em seguida, usamos a função PATH () com o objeto File_error "e". Por fim, imprimimos o valor, mensagem e categoria gerados a partir da função de erro do sistema de arquivos. Também geramos uma instrução Código de erro da função STD :: ERROR_CODE.

#incluir
#incluir
#incluir
int main ()

const std :: filesystem :: path de "/nofile1/a", para "/nofile2/b";
tentar
std :: filesystem :: copy_file (de, para);

Catch (std :: filesystem :: 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 :: filesystem :: copy_file (de, para, err);
std :: cout << "\nerror_code has non-throwing sets: " << err.message() << '\n';

Os erros são gerados pela função file_error como nenhum arquivo ou diretório é encontrado.

Exemplo 4: Usando STD :: FileSystem :: Função Absoluta

Temos outra função whit é o “std :: filesystem :: absoluto”, que dá o caminho absoluto do arquivo. Um caminho é absoluto que sempre inclui o componente base e toda a lista de diretórios necessários para encontrar o arquivo. Aqui, dentro da função principal, usamos a função STD :: FileSystem :: Path e criamos seu objeto como "fp". Então, damos o caminho do arquivo como “principal.C ”. Exibimos o caminho atual do arquivo e o caminho absoluto do arquivo especificado com o comando cout. O caminho absoluto é exibido passando o objeto de caminho do arquivo "FP" na função "std :: filesystem :: absoluto".

#incluir
#incluir
namespace fs = std :: filesystem;
int main ()

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

Podemos ver o caminho atual do arquivo em nosso sistema e o caminho absoluto do arquivo que é obtido da função absoluta do sistema de arquivos.

Conclusão

A biblioteca STD :: FileSystem, que possui uma gama de funcionalidades, é introduzida em C ++ 17. Mas cobrimos apenas algumas funções do sistema de arquivos. Uma biblioteca padrão contém classes e funções altamente benéficas e cuidadosamente construídas para lidar, e o manuseio específico do sistema operacional é abstraído. Implementamos a função do sistema de arquivos file_exist para conhecer a existência do arquivo em nosso primeiro exemplo. Em seguida, usamos a função de tamanho do arquivo para obter o tamanho do arquivo. Além disso, empregamos a função de erro do sistema de arquivos para mostrar como as exceções são geradas em um arquivo. Além disso, usamos a função absoluta do sistema de arquivos para buscar o caminho absoluto do arquivo.