Cómo comprobar si un archivo existe en C++

Usa std::filesystem::exists para comprobar si una ruta corresponde a una entrada existente del sistema de archivos. Devuelve true tanto para archivos como para directorios. El ejemplo crea un directorio temporal pequeño y un archivo para que la comprobación tenga una entrada autocontenida; sustituye file por la ruta que necesite inspeccionar tu programa.

Usa std::filesystem::exists para comprobar si un archivo existe en un directorio

Ejecuta este ejemplo:

#include <chrono>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

int main() {
  namespace fs = std::filesystem;
  const auto unique = std::chrono::steady_clock::now().time_since_epoch().count();
  const fs::path folder = fs::temp_directory_path() /
                          ("cpp-exists-" + std::to_string(unique));
  std::error_code ec;
  if (!fs::create_directory(folder, ec) || ec) {
    std::cout << "Could not prepare example\n";
    return 1;
  }

  struct cleanup_guard {
    fs::path path;
    ~cleanup_guard() {
      std::error_code cleanup_error;
      fs::remove_all(path, cleanup_error);
    }
  } cleanup{folder};

  const fs::path file = folder / "notes.txt";
  {
    std::ofstream output(file);
    if (!output) {
      std::cout << "Could not prepare example\n";
      return 1;
    }
  }

  std::cout << (fs::exists(file) ? "Path exists\n" : "Path does not exist\n");
  std::cout << (fs::is_regular_file(file) ? "It is a regular file\n"
                                          : "It is not a regular file\n");

}

Path exists
It is a regular file

La llamada fs::exists(file) comprueba la ruta que recibe. No busca archivos con un nombre coincidente. En este ejemplo, folder / "notes.txt" combina un directorio elegido con un nombre de archivo mediante std::filesystem::path, que se encarga del separador de rutas propio de cada plataforma. Usa el mismo patrón con la ruta de tu directorio cuando el archivo esté fuera del directorio de trabajo actual del proceso.

Una ruta relativa como "notes.txt" se resuelve desde el directorio de trabajo actual del proceso, que establece el entorno desde el que se inicia el programa. No se resuelve automáticamente desde el directorio que contiene el ejecutable. Para consultar el directorio de trabajo actual, llama a fs::current_path(); para cambiarlo durante la ejecución, usa fs::current_path(path) y gestiona cualquier error del sistema de archivos que se informe. Si solo necesitas comprobar una ubicación, normalmente es más claro construir una ruta a partir de un directorio conocido.

exists indica si hay una entrada en esa ruta, pero no qué tipo de entrada es. Usa fs::is_regular_file(path) si debe coincidir únicamente un archivo normal, o fs::is_directory(path) si esperas un directorio. Estas comprobaciones también pueden no dar una respuesta utilizable si el programa no tiene acceso al sistema de archivos o si la ruta cambia durante la inspección. Si el código debe distinguir esos casos, usa las sobrecargas que aceptan std::error_code y examina el error por separado del valor booleano devuelto.

Por ejemplo, std::error_code ec; const bool found = fs::exists(path, ec); permite examinar tanto found como ec: un resultado falso sin error significa que no se encontró la ruta; si se establece un error, este indica por qué no pudo completarse la comprobación. La sobrecarga sin un argumento de código de error informa de los fallos del sistema de archivos mediante una excepción. Elige la forma con código de error si el programa debe continuar ante problemas previsibles del sistema de archivos; en los demás casos, la forma que lanza excepciones permite escribir una comprobación sencilla y legible. Además, la entrada puede dejar de ser la misma entre la comprobación y una apertura posterior, así que considera el resultado una respuesta sobre la búsqueda y no una garantía de que la operación posterior vaya a funcionar.

El ejemplo usa std::filesystem y crea su propio conjunto temporal de prueba. Si falla la preparación del directorio o del archivo, imprime el mensaje de preparación y devuelve un estado distinto de cero. El mecanismo de limpieza intenta eliminar el directorio temporal al finalizar normalmente e ignora los errores de limpieza. La consulta usa la sobrecarga que lanza excepciones, por lo que una excepción del sistema de archivos que no se capture y salga de main puede terminar el programa sin garantizar que se ejecute el destructor de protección. En la ejecución normal, la salida consta de las dos líneas mostradas arriba; cualquier etiqueta del bloque de salida se conserva en inglés junto con el ejemplo inalterado.