home | help 
std::experi...stem::exists(3)  C++ Standard Libary std::experi...stem::exists(3)

NAME
     std::experimental::filesystem::exists  - std::experimental::filesystem::ex-
     ists

Synopsis
	Defined in header <experimental/filesystem>
	bool exists( file_status s )		     (1) (filesystem TS)
	bool exists( const path& p );		     (2) (filesystem TS)
	bool exists( const path& p, error_code& ec )

	Checks if the given file status or path corresponds to an existing  file
     or
	directory.

	1) Equivalent to status_known(s) && s.type() != file_type::not_found.
	2)  Equivalent	to  exists(status(p)) or exists(status(p, ec)) (symlinks
     are followed).
	The non-throwing overload returns false if an error occurs.

Parameters
	s  - file status to check
	p  - path to examine
	ec - out-parameter for error reporting in the non-throwing overload

Return value
	true if the given path or file status corresponds to an existing file or
     directory,
	false otherwise.

Exceptions
	1)
	noexcept specification:
	noexcept

	2) The overload that does  not	take  an  error_code&  parameter  throws
     filesystem_error
	on  underlying	OS  API errors, constructed with p as the first argument
     and the OS
	error code as the error code argument. std::bad_alloc may be  thrown  if
     memory
	allocation  fails.  The overload taking an error_code& parameter sets it
     to the OS API
	error code if an OS API call fails, and executes ec.clear() if no errors
     occur. This
	overload has
	noexcept specification:
	noexcept

Notes
	The information provided by this function is usually also provided as  a
     byproduct of
	directory  iteration. During directory iteration, calling exists(*itera-
     tor) is less
	efficient than exists(iterator->status()).

Example
     // Run this code

      #include <cstdint>
      #include <experimental/filesystem>
      #include <fstream>
      #include <iostream>
      namespace fs = std::experimental::filesystem;

      void demo_exists(const fs::path& p, fs::file_status s = fs::file_status{})
      {
	  std::cout << p;
	  if (fs::status_known(s) ? fs::exists(s) : fs::exists(p))
	      std::cout << " exists\n";
	  else
	      std::cout << " does not exist\n";
      }

      int main()
      {
	  fs::create_directory("sandbox");
	  std::ofstream("sandbox/file"); // create regular file
	  fs::create_symlink("non-existing", "sandbox/symlink");

	  demo_exists("sandbox");
	  for (auto it =  fs::directory_iterator("sandbox");  it  !=  fs::direc-
     tory_iterator(); ++it)
	      demo_exists(*it,	it->status());	// use cached status from direc-
     tory entry
	  fs::remove_all("sandbox");
      }

Output:
      "sandbox" exists
      "sandbox/file" exists
      "sandbox/symlink" does not exist

See also
	status	       determines file attributes
	symlink_status determines file attributes, checking the symlink target
		       (function)
	file_status    represents file type and permissions
		       (class)
		       cached status of the file designated  by  this  directory
     entry
	status		cached symlink_status of the file designated by this di-
     rectory entry
	symlink_status (public member function of
		       std::experimental::filesystem::directory_entry)

Categories:
	  * Noindexed pages
	  * unconditionally noexcept

Hidden categories:
	  * Pages with unreviewed unconditional noexcept template
	  * Pages with unreviewed noexcept template

http://cppreference.com 	   2024.06.10	   std::experi...stem::exists(3)
home | help