std::is_bounded_array(3)

💖 std::is_bounded_array(3) 💖

okay so bestie, welcome to the C++ Standard Library corner of the man pages — this one is std::is_bounded_array and it's genuinely one of the cutest little type traits out there. no cap.

✨ NAME ✨

std::is_bounded_array — literally just std::is_bounded_array, that's the whole name, she said what she said 💅

🌸 Synopsis 🌸

Defined in header <type_traits>:

template< class T >              (since C++20)
struct is_bounded_array;

std::is_bounded_array is a UnaryTypeTrait. (yes that's a whole category of trait, she's fancy like that 🎀)

What does she actually do? She checks whether T is an array type of known bound. And she provides the member constant value, which is equal to true if T is an array type of known bound. Otherwise, value is equal to false. periodt.

⚠️ okay important warning bestie: if the program adds specializations for std::is_bounded_array or std::is_bounded_array_v, the behavior is undefined. like, don't do that. not iconic, don't try it 🙈

🧚 Template parameters

• T — a type to check

🦋 Helper variable template

template< class T >
inline constexpr bool is_bounded_array_v =   (since C++20)
    is_bounded_array<T>::value;

⭐ Inherited from std::integral_constant

👑 Member constants

• value — true if T is an array type of known bound, 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

• value_type — bool
• type — std::integral_constant<bool, value>

🍓 Possible implementation

like, this is roughly the vibe of how she's built under the hood:

template<class T>
struct is_bounded_array : std::false_type {};

template<class T, std::size_t N>
struct is_bounded_array<T[N]> : std::true_type {};

🎀 Notes

Feature-test macro moment!! 🕵️‍♀️

• __cpp_lib_bounded_array_traits — value 201902L — Std (C++20) — Feature: std::is_bounded_array, std::is_unbounded_array

💖 Example

// Run this code

#include <iostream>
#include <type_traits>

#define OUT(...) std::cout << #__VA_ARGS__ << " : " << __VA_ARGS__ << '\n'

class A {};

int main()
{
    std::cout << std::boolalpha;
    OUT(std::is_bounded_array_v<A>);
    OUT(std::is_bounded_array_v<A[]>);
    OUT(std::is_bounded_array_v<A[3]>);
    OUT(std::is_bounded_array_v<float>);
    OUT(std::is_bounded_array_v<int>);
    OUT(std::is_bounded_array_v<int[]>);
    OUT(std::is_bounded_array_v<int[3]>);
}

Output:

std::is_bounded_array_v<A> : false
std::is_bounded_array_v<A[]> : false
std::is_bounded_array_v<A[3]> : true
std::is_bounded_array_v<float> : false
std::is_bounded_array_v<int> : false
std::is_bounded_array_v<int[]> : false
std::is_bounded_array_v<int[3]> : true

see how A[3] and int[3] ate and left zero crumbs? 🍽️ known bound = true. the [] girls with no number? false. iconic behavior honestly.

🌟 See also

• is_array — checks if a type is an array type — (C++11) (class template)
• is_unbounded_array — checks if a type is an array type of unknown bound — (C++20) (class template)
• extent — obtains the size of an array type along a specified dimension — (C++11) (class template)

---

okay that's the whole page bestie, you're officially a bounded-array knower now 🧠✨ go forth and static_assert responsibly. mwah 🫶

source: http://cppreference.com — version 2024.06.10 — std::is_bounded_array(3) 💅