std::empty(3)

NAME
std::empty - std::empty

Synopsis
   Defined in header <array>
   Defined in header <deque>
   Defined in header <forward_list>
   Defined in header <iterator>
   Defined in header <list>
   Defined in header <map>
   Defined in header <regex>
   Defined in header <set>
   Defined in header <span> (since
                        C++20)
   Defined in header <string>
   Defined in header <string_view>
   Defined in header <unordered_map>
   Defined in header <unordered_set>
   Defined in header <vector>
   template <class C> (since
   constexpr auto empty(const C& c) -> C++17)
   decltype(c.empty()); (until
                        C++20)
   template <class C> (since
   [[nodiscard]] constexpr auto empty(const C& c) -> C++20)
   decltype(c.empty());
   template <class T, std::size_t N> (since
   constexpr bool empty(const T (&array)[N]) C++17)
   noexcept; (until
                        (1) C++20)
   template <class T, std::size_t N> (since
   [[nodiscard]] constexpr bool empty(const T C++20)
   (&array)[N]) noexcept; (2)
   template <class E> (since
   constexpr bool empty(std::initializer_list<E> il) C++17)
   noexcept; (until
                        (3) C++20)
   template <class E> (since
   [[nodiscard]] constexpr bool C++20)
   empty(std::initializer_list<E> il) noexcept;
   Returns whether the given range is empty.
   1) returns c.empty()
   2) returns false
   3) returns il.size() == 0

Parameters
   c - a container or view with an empty member function
   array - an array of arbitrary type
   il - an initializer list

Return value
   true if the range doesn't have any element.

Exceptions
   1) May throw implementation-defined exceptions.

Notes
   The overload for std::initializer_list is necessary because it does not have a
   member function empty.
   Feature-test macro: __cpp_lib_nonmember_container_access

Possible implementation

First version
   template <class C>
   [[nodiscard]] constexpr auto empty(const C& c) -> decltype(c.empty())
   {
       return c.empty();
   }

Second version
   template <class T, std::size_t N>
   [[nodiscard]] constexpr bool empty(const T (&array)[N]) noexcept
   {
       return false;
   }
                        Third version
   template <class E>
   [[nodiscard]] constexpr bool empty(std::initializer_list<E> il) noexcept
   {
       return il.size() == 0;
   }

Example
// Run this code
 #include <iostream>
 #include <vector>
 template <class T>
 void print(const T& container)
 {
     if ( std::empty(container) )
     {
         std::cout << "Empty\n";
     }
     else
     {
         std::cout << "Elements:";
         for ( const auto& element : container )
             std::cout << ' ' << element;
         std::cout << '\n';
     }
 }
 int main()
 {
     std::vector<int> c = { 1, 2, 3 };
     print(c);
     c.clear();
     print(c);
     int array[] = { 4, 5, 6 };
     print(array);
     auto il = { 7, 8, 9 };
     print(il);
 }

Output:
 Elements: 1 2 3
 Empty
 Elements: 4 5 6
 Elements: 7 8 9

See also
   ranges::empty checks whether a range is empty
   (C++20) (customization point object)