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

FreeBSD Manual Pages

  
 
  

home | help 
std::is_fundamental(3)	      C++ Standard Libary	std::is_fundamental(3)

NAME
       std::is_fundamental - std::is_fundamental

Synopsis
	  Defined in header <type_traits>
	  template< class T >		   (since C++11)
	  struct is_fundamental;

	  std::is_fundamental is a UnaryTypeTrait.

	  If  T	 is  a	fundamental  type  (that is, arithmetic	type, void, or
       nullptr_t), provides
	  the member constant value equal true.	For any	other type,  value  is
       false.

	  If the program adds specializations for std::is_fundamental or
	  std::is_fundamental_v, the behavior is undefined.

Template parameters
	  T - a	type to	check

	  Helper variable template

	  template<		     class		   T		     >
       (since C++17)
	  inline constexpr bool	is_fundamental_v = is_fundamental<T>::value;

       Inherited from std::integral_constant

Member constants
	  value	   true	if T is	a fundamental type, false otherwise
	  [static] (public static member constant)

Member functions
	  operator bool	converts the object to bool, returns value
			(public	member function)
	  operator()	returns	value
	  (C++14)	(public	member function)

Member types
	  Type	     Definition
	  value_type bool
	  type	     std::integral_constant<bool, value>

Possible implementation
	  template<class T>
	  struct is_fundamental
	      :	std::integral_constant<
		  bool,
		  std::is_arithmetic<T>::value ||
		  std::is_void<T>::value ||
		  std::is_same<std::nullptr_t,	      typename	      std::re-
       move_cv<T>::type>::value
		  // you can also use 'std::is_null_pointer<T>::value' instead
       in C++14
	  > {};

Example
       // Run this code

	#include <type_traits>

	static_assert(std::is_fundamental_v<int> == true);
	static_assert(std::is_fundamental_v<int&> == false);
	static_assert(std::is_fundamental_v<int*> == false);
	static_assert(std::is_fundamental_v<void> == true);
	static_assert(std::is_fundamental_v<void*> == false);
	static_assert(std::is_fundamental_v<float> == true);
	static_assert(std::is_fundamental_v<float&> == false);
	static_assert(std::is_fundamental_v<float*> == false);
	static_assert(std::is_fundamental_v<std::nullptr_t> == true);
	static_assert(std::is_fundamental_v<std::is_fundamental<int>>	    ==
       false);

	class A	{};
	static_assert(std::is_fundamental_v<A> == false);
	static_assert(std::is_fundamental_v<std::is_fundamen-
       tal<A>::value_type>);

	int main() {}

See also
	  is_compound	  checks if a type is a	compound type
	  (C++11)	  (class template)
	  is_arithmetic	  checks if a type is an arithmetic type
	  (C++11)	  (class template)
	  is_void	  checks if a type is void
	  (C++11)	  (class template)
	  is_null_pointer checks if a type is std::nullptr_t
	  (C++14)	  (class template)

http://cppreference.com		  2024.06.10		std::is_fundamental(3)

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

home | help