Difference between revisions of "cpp/iterator/size"
From cppreference.com
Andreas Krug (Talk | contribs) m (@-@ -> @,@, {{c}}, fmt) |
|||
| Line 40: | Line 40: | ||
Returns the size of the given range. | Returns the size of the given range. | ||
| − | @1 | + | @1,2@ Returns {{c|c.size()}}, converted to the return type if necessary. |
| − | @3 | + | @3,4@ Returns {{tt|N}}. |
===Parameters=== | ===Parameters=== | ||
| Line 50: | Line 50: | ||
===Return value=== | ===Return value=== | ||
| − | The size of {{ | + | The size of {{c|c}} or {{c|array}}. |
===Exceptions=== | ===Exceptions=== | ||
| − | @1 | + | @1,2@ {{cpp/impldef exception item}} |
===Overloads=== | ===Overloads=== | ||
| Line 65: | Line 65: | ||
{{eq impl | {{eq impl | ||
|title1=size (1)|ver1=1|1= | |title1=size (1)|ver1=1|1= | ||
| − | template <class C> | + | template<class C> |
constexpr auto size(const C& c) -> decltype(c.size()) | constexpr auto size(const C& c) -> decltype(c.size()) | ||
{ | { | ||
| Line 71: | Line 71: | ||
} | } | ||
|title2=ssize (2)|ver2=2|2= | |title2=ssize (2)|ver2=2|2= | ||
| − | template <class C> | + | template<class C> |
constexpr auto ssize(const C& c) | constexpr auto ssize(const C& c) | ||
-> std::common_type_t<std::ptrdiff_t, | -> std::common_type_t<std::ptrdiff_t, | ||
| Line 81: | Line 81: | ||
} | } | ||
|title3=size (3)|ver3=3|3= | |title3=size (3)|ver3=3|3= | ||
| − | template <class T, std::size_t N> | + | template<class T, std::size_t N> |
constexpr std::size_t size(const T (&array)[N]) noexcept | constexpr std::size_t size(const T (&array)[N]) noexcept | ||
{ | { | ||
| Line 87: | Line 87: | ||
} | } | ||
|title4=ssize (4)|ver4=4|4= | |title4=ssize (4)|ver4=4|4= | ||
| − | template <class T, std::ptrdiff_t N> | + | template<class T, std::ptrdiff_t N> |
constexpr std::ptrdiff_t ssize(const T (&array)[N]) noexcept | constexpr std::ptrdiff_t ssize(const T (&array)[N]) noexcept | ||
{ | { | ||
| Line 136: | Line 136: | ||
assert(i == -1); | assert(i == -1); | ||
} | } | ||
| − | |p=true <!-- sizeof pointer and int --> | + | |p=true<!--sizeof pointer and int--> |
|output= | |output= | ||
size of a[]: 12 | size of a[]: 12 | ||
Revision as of 23:37, 1 October 2023
| 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 > constexpr auto size( const C& c ) -> decltype(c.size()); |
(1) | (since C++17) |
template< class C > constexpr auto ssize( const C& c ) |
(2) | (since C++20) |
template< class T, std::size_t N > constexpr std::size_t size( const T (&array)[N] ) noexcept; |
(3) | (since C++17) |
template< class T, std::ptrdiff_t N > constexpr std::ptrdiff_t ssize( const T (&array)[N] ) noexcept; |
(4) | (since C++20) |
Returns the size of the given range.
1,2) Returns c.size(), converted to the return type if necessary.
3,4) Returns
N.Contents |
Parameters
| c | - | a container or view with a size member function
|
| array | - | an array of arbitrary type |
Return value
The size of c or array.
Exceptions
1,2) May throw implementation-defined exceptions.
Overloads
Custom overloads of size may be provided for classes and enumerations that do not expose a suitable size() member function, yet can be detected.
|
Overloads of |
(since C++20) |
Possible implementation
| size (1) |
|---|
template<class C> constexpr auto size(const C& c) -> decltype(c.size()) { return c.size(); } |
| ssize (2) |
template<class C> constexpr auto ssize(const C& c) -> std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>> { using R = std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>>; return static_cast<R>(c.size()); } |
| size (3) |
template<class T, std::size_t N> constexpr std::size_t size(const T (&array)[N]) noexcept { return N; } |
| ssize (4) |
template<class T, std::ptrdiff_t N> constexpr std::ptrdiff_t ssize(const T (&array)[N]) noexcept { return N; } |
Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_nonmember_container_access |
201411L | (C++17) | std::size(), std::data and std::empty
|
__cpp_lib_ssize |
201902L | (C++20) | std::ssize() and unsigned std::span::size()
|
Example
Run this code
#include <cassert> #include <iostream> #include <vector> int main() { // Works with containers std::vector<int> v{3, 1, 4}; assert(std::size(v) == 3); // And works with built-in arrays too int a[]{-5, 10, 15}; // Returns the number of elements (not bytes) as opposed to sizeof assert(std::size(a) == 3); std::cout << "size of a[]: " << sizeof a << '\n'; // 12, if sizeof(int) == 4 // Provides a safe way (compared to sizeof) of getting string buffer size const char str[] = "12345"; // These are fine and give the correct result assert(std::size(str) == 6); assert(sizeof(str) == 6); // But use of sizeof here is a common source of bugs const char* str_decayed = "12345"; // std::cout << std::size(str_decayed) << '\n'; // Usefully fails to compile std::cout << sizeof(str_decayed) << '\n'; // Prints the size of the pointer! // Since C++20 the signed size (std::ssize) is available auto i = std::ssize(v); for (--i; i != -1; --i) std::cout << v[i] << (i ? ' ' : '\n'); assert(i == -1); }
Possible output:
size of a[]: 12 8 4 1 3
See also
| signed integer type returned when subtracting two pointers (typedef) | |
| unsigned integer type returned by the sizeof operator (typedef) | |
| (C++20) |
returns an integer equal to the size of a range (customization point object) |
| (C++20) |
returns a signed integer equal to the size of a range (customization point object) |
