Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::filesy...egular_file(3)  C++ Standard Libary std::filesy...egular_file(3)

NAME
       std::filesystem::is_regular_file	- std::filesystem::is_regular_file

Synopsis
	  Defined in header <filesystem>
	  bool	is_regular_file(  std::filesystem::file_status	s  ) noexcept;
       (1) (since C++17)
	  bool is_regular_file(	const std::filesystem::path& p );
	  bool	  is_regular_file(     const	 std::filesystem::path&	    p,
       (2) (since C++17)
	  std::error_code& ec )	noexcept;

	  Checks  if  the  given  file status or path corresponds to a regular
       file.

	  1) Equivalent	to s.type() == file_type::regular.
	  2) Equivalent	to is_regular_file(status(p)) or  is_regular_file(sta-
       tus(p, ec))
	  respectively.

Parameters
	  s  - file status to check
	  p  - path to examine
	  ec - error code to store the error status to

Return value
	  true if the file indicated by	p or if	the type indicated by s	refers
       to a regular
	  file,	false otherwise. The non-throwing overload returns false if an
       error occurs.

Exceptions
	  2)  The  overload  that  does	 not take a std::error_code& parameter
       throws
	  filesystem::filesystem_error	on  underlying	OS  API	 errors,  con-
       structed	with p as the
	  first	 path  argument	 and the OS error code as the error code argu-
       ment. The overload
	  taking a std::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. Any overload
       not marked
	  noexcept may throw std::bad_alloc if memory allocation fails.

Notes
	  The throwing overload	is additionally	specified to throw
	  std::filesystem::filesystem_error if status(p) would throw.

Example
       // Run this code

	#include <iostream>
	#include <fstream>
	#include <cstdio>
	#include <cstring>
	#include <filesystem>
	#include <unistd.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <sys/stat.h>

	namespace fs = std::filesystem;

	void demo_status(const fs::path& p, fs::file_status s)
	{
	    std::cout << p;
	    // alternative: switch(s.type())  {	 case  fs::file_type::regular:
       ...}
	    if(fs::is_regular_file(s)) std::cout << " is a regular file\n";
	    if(fs::is_directory(s)) std::cout << " is a	directory\n";
	    if(fs::is_block_file(s)) std::cout << " is a block device\n";
	    if(fs::is_character_file(s))  std::cout  <<	 "  is a character de-
       vice\n";
	    if(fs::is_fifo(s)) std::cout << " is a named IPC pipe\n";
	    if(fs::is_socket(s)) std::cout << "	is a named IPC socket\n";
	    if(fs::is_symlink(s)) std::cout << " is a symlink\n";
	    if(!fs::exists(s)) std::cout << " does not exist\n";
	}

	int main()
	{
	    // create files of different kinds
	    fs::create_directory("sandbox");
	    std::ofstream("sandbox/file"); // create regular file
	    fs::create_directory("sandbox/dir");
	    mkfifo("sandbox/pipe", 0644);
	    sockaddr_un	addr;
	    addr.sun_family = AF_UNIX;
	    std::strcpy(addr.sun_path, "sandbox/sock");
	    int	fd = socket(PF_UNIX, SOCK_STREAM, 0);
	    bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof	addr);
	    fs::create_symlink("file", "sandbox/symlink");

	    // demo different status accessors
	    for(auto it	= fs::directory_iterator("sandbox"); it	!=  fs::direc-
       tory_iterator();	++it)
		demo_status(*it,  it->symlink_status());  // use cached	status
       from directory entry
	    demo_status("/dev/null", fs::status("/dev/null")); // direct calls
       to status
	    demo_status("/dev/sda", fs::status("/dev/sda"));
	    demo_status("sandbox/no", fs::status("/sandbox/no"));

	    // cleanup
	    close(fd);
	    fs::remove_all("sandbox");
	}

Possible output:
	"sandbox/file" is a regular file
	"sandbox/dir" is a directory
	"sandbox/pipe" is a named IPC pipe
	"sandbox/sock" is a named IPC socket
	"sandbox/symlink" is a symlink
	"/dev/null" is a character device
	"/dev/sda" is a	block device
	"sandbox/no" does not exist

See also
	  file_type	    the	type of	a file
	  (C++17)	    (enum)
	  status	    determines file attributes
	  symlink_status    determines file attributes,	checking  the  symlink
       target
	  (C++17)	    (function)
	  (C++17)
	  file_status	    represents file type and permissions
	  (C++17)	    (class)
	  status_known	    checks whether file	status is known
	  (C++17)	    (function)
	  is_block_file	     checks whether the	given path refers to block de-
       vice
	  (C++17)	    (function)
	  is_character_file checks whether the given path refers to a  charac-
       ter device
	  (C++17)	    (function)
	  is_directory	     checks  whether the given path refers to a	direc-
       tory
	  (C++17)	    (function)
	  is_fifo	    checks whether the given path refers  to  a	 named
       pipe
	  (C++17)	    (function)
	  is_other	     checks  whether  the  argument refers to an other
       file
	  (C++17)	    (function)
	  is_socket	    checks whether the argument	refers to a named  IPC
       socket
	  (C++17)	    (function)
	  is_symlink	     checks  whether the argument refers to a symbolic
       link
	  (C++17)	    (function)
	  exists	    checks whether path	refers to existing file	system
       object
	  (C++17)	    (function)
	  is_regular_file   checks whether the directory  entry	 refers	 to  a
       regular file
			    (public member function of std::filesystem::direc-
       tory_entry)

http://cppreference.com		  2022.07.31	  std::filesy...egular_file(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::filesystem::is_regular_file&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help