empty_view class (C++ Standard Library)
A view with no elements. This view is useful for test purposes such as calling code that needs to be provided with a view but doesn't need to access its underlying data.
Syntax
template<class T>
requires std::is_object_v<T>
class empty_view : public ranges::view_interface<empty_view<T>>;
Template parameters
T
The type of the element. Even though there are no elements in an empty_view, all ranges are homogeneous. That is, they have elements of a particular type. So even though an empty_view has no elements, it still has a type, such as an empty_view of int, or strings, etc.
View characteristics
For a description of the following entries, see View class characteristics
| Characteristic | Description |
|---|---|
| Range adaptor | views::empty |
| Underlying range | None |
| Element type | As specified when the empty_view is created |
| View iterator category | contiguous_range |
| Sized | Yes. Always returns 0 |
Is const-iterable |
Yes |
| Common range | Yes |
| Borrowed range | Yes |
Members
| Member functions | Description |
|---|---|
| ConstructorsC++20 | Construct an empty_view. |
begin C++20 |
Returns nullptr. |
endC++20 |
Returns nullptr. |
sizeC++20 |
Returns 0 |
Inherited from view_interface |
Description |
backC++20 |
Results in undefined behavior. |
dataC++20 |
Returns nullptr. |
emptyC++20 |
Returns true. |
frontC++20 |
Results in undefined behavior. |
operator[]C++20 |
Results in undefined behavior. |
operator boolC++20 |
Returns false. |
Remarks
The best way to create a empty_view is by using the empty range adaptor. Range adaptors are the intended way to create view classes. The view types are exposed in case you want to create your own custom view type.
Because there can never be any elements in an empty_view, certain compiler optimizations are possible. For example, the compiler will eliminate for (auto e : std::views::empty<int>) {...} because it knows that there's nothing to iterate over.
Another use for empty_view is splitting a split_view with an empty_view delimiter, which results in a range of single element ranges.
Requirements
Header: <ranges> (since C++20)
Namespace: std::ranges
Compiler Option: /std:c++20 or later is required.
Constructors
Create an instance of a empty_view.
template<class T>
inline constexpr empty_view<T> empty{};
Parameters
T
The type of the underlying element, of which there is none.
Remarks
The best way to create a empty_view is by using the empty range adaptor.
Example empty_view
// requires /std:c++20 or higher
#include <ranges>
#include <iostream>
int main()
{
auto anEmptyView = std::views::empty<int>;
bool isNotEmpty = (bool)anEmptyView;
std::cout << std::boolalpha << isNotEmpty << "\n"; // false
std::cout << std::boolalpha << anEmptyView.empty(); // true
}
false
true
back
Results in undefined behavior.
constexpr auto back()
requires ranges::bidirectional_range<T> && ranges::common_range<T>;
constexpr auto back() const
requires ranges::bidirectional_range<const T> && ranges::common_range<const T>;
Parameters
None.
Return value
None.
Remarks
Calling this function in a debug build raises an assertion that the function has been called on an empty view_interface.
begin
Returns nullptr because there isn't a first element in the view.
static constexpr T* begin() noexcept
Return value
nullptr
data
Returns nullptr because there isn't a first element in the view to get a pointer to.
static constexpr T* data() noexcept
Return value
nullptr.
empty
Test whether the derived view is empty.
static constexpr bool empty() noexcept
Parameters
None.
Return value
Returns true.
end
Returns nullptr because there aren't any elements in the view.
static constexpr T* end() noexcept
Return value
nullptr.
front
Results in undefined behavior.
constexpr auto front()
requires ranges::forward_range<T>;
constexpr auto front() const
requires ranges::forward_range<const T>;
Parameters
None.
Return value
None.
Remarks
Calling this function in a debug build raises an assertion that the function has been called on an empty view_interface.
operator[]
Results in undefined behavior.
template<ranges::random_access_range R = T>
constexpr decltype(auto) operator[](ranges::range_difference_t<R> pos);
template<ranges::random_access_range R = const T>
constexpr decltype(auto) operator[](ranges::range_difference_t<R> pos) const;
Parameters
pos
The position, relative to the beginning iterator, of the element to return.
Return value
None.
Remarks
Calling this function in a debug build raises an assertion that index is out of range for view_interface.
operator bool
Test whether the derived view isn't empty.
constexpr explicit operator bool()
requires requires { ranges::empty(T ()); };
constexpr explicit operator bool() const
requires requires { ranges::empty(T ()); };
Parameters
None.
Return value
Returns false.
Example (bool)
// requires /std:c++20 or higher
#include <ranges>
#include <iostream>
int main()
{
auto anEmptyView = std::views::empty<int>;
if (anEmptyView) // check if anEmptyView isn't empty
{
std::cout << "Error: why does an empty_view have elements?\n";
}
else
{
std::cout << "Correct: an empty_view is not not empty\n";
}
}
Correct: an empty_view is not not empty
size
Get the number of elements in the view, which will always be 0.
static constexpr size_t size()
Parameters
None.
Return value
0.