Qual é a melhor maneira de verificar se existe um arquivo em C ++? (plataforma cruzada)

Eu li as respostas para Qual é a melhor maneira de verificar se existe um arquivo em C? (plataforma cruzada) , mas estou me perguntando se há uma maneira melhor de fazer isso usando libs c ++ padrão? De preferência, sem tentar abrir o arquivo.

Ambos state accesssão praticamente indigestíveis. O que devo #includeusar isso?

Use boost :: filesystem :

#include <boost/filesystem.hpp>

if ( !boost::filesystem::exists( "myfile.txt" ) )
{
  std::cout << "Can't find my file!" << std::endl;
}

Tenha cuidado com as condições de corrida: se o arquivo desaparecer entre a verificação "existe" e o momento em que você o abrir, seu programa falhará inesperadamente.

É melhor abrir o arquivo, verificar se há falhas e se tudo está bem, fazer algo com o arquivo. É ainda mais importante com código crítico de segurança.

Detalhes sobre segurança e condições de corrida: http://www.ibm.com/developerworks/library/l-sprace.html

Sou um usuário feliz e certamente usaria a solução do Andreas. Mas se você não teve acesso às bibliotecas de impulso, você pode usar a biblioteca de fluxo:

ifstream file(argv[1]);
if (!file)
{
    // Can't open file
}

Não é tão bom quanto boost :: filesystem :: exists uma vez que o arquivo será realmente aberto ... mas geralmente é a próxima coisa que você quer fazer de qualquer maneira.

Use stat (), se for multiplataforma o suficiente para suas necessidades. Não é o padrão C ++, mas POSIX.

No MS Windows, existe _stat, _stat64, _stati64, _wstat, _wstat64, _wstati64.

Que tal access?

#include <io.h>

if (_access(filename, 0) == -1)
{
    // File does not exist
}

Outra possibilidade consiste em usar a good()função no stream:

#include <fstream>     
bool checkExistence(const char* filename)
{
     ifstream Infield(filename);
     return Infield.good();
}

Eu reconsideraria tentar descobrir se existe um arquivo. Em vez disso, você deve tentar abri-lo (em C padrão ou C ++) no mesmo modo em que pretende usá-lo. Qual a utilidade de saber que o arquivo existe se, digamos, não for gravável quando você precisa usá-lo?

Se o seu compilador suporta C ++ 17, você não precisa de impulso, você pode simplesmente usar std::filesystem::exists

#include <iostream> // only for std::cout
#include <filesystem>

if (!std::filesystem::exists("myfile.txt"))
{
    std::cout << "File not found!" << std::endl;
}

NÃO impulsoREQUERIDO , o que seria um exagero .

Use stat () (não plataforma cruzada, embora conforme mencionado por pavon), assim:

#include <sys/stat.h>
#include <iostream>

// true if file exists
bool fileExists(const std::string& file) {
    struct stat buf;
    return (stat(file.c_str(), &buf) == 0);
}

int main() {
    if(!fileExists("test.txt")) {
        std::cerr << "test.txt doesn't exist, exiting...\n";
        return -1;
    }
    return 0;
}

Resultado:

C02QT2UBFVH6-lm:~ gsamaras$ ls test.txt
ls: test.txt: No such file or directory
C02QT2UBFVH6-lm:~ gsamaras$ g++ -Wall main.cpp
C02QT2UBFVH6-lm:~ gsamaras$ ./a.out
test.txt doesn't exist, exiting...

Outra versão (e essa) pode ser encontrada aqui .

Se você já estiver usando a classe de fluxo de arquivo de entrada ( ifstream), poderá usar sua função fail().

Exemplo:

ifstream myFile;

myFile.open("file.txt");

// Check for errors
if (myFile.fail()) {
    cerr << "Error: File could not be found";
    exit(1);
}