Re: Expose 'array_length()' macro in or
On 2020-09-30 17:58, Joseph Myers wrote: For some reason http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2529.pdf doesn't seem to have reached the agenda of a WG14 meeting yet, but adding a language feature like that to the standard would be another approach. Hi Joseph, Yes, that would be great! I hope they add that to the language. When/if that happens, nitems() could be `#define nitems(arr) _Lengthof(arr)` for std >= c2x. In the meantime, I would add this macro to libc. Maybe gcc could add such a great feature as an extension even before the standard does... Too many wishes :) BTW, I sent a PATCH v4 that I should've sent --in-reply-to PATCH v3 in this thread (but I forgot to do so); I'll link to it here: https://sourceware.org/pipermail/libc-alpha/2020-September/117986.html Thanks, Alex
Re: Expose 'array_length()' macro in
Thanks again for your improvements. I think this might be ready for a patch already. Any more thoughts? Thanks, Alex #if defined(__cplusplus) # include # if __cplusplus >= 201103L template constexpr inline std::size_t __array_length(const _Tp(&)[_Len]) __THROW { return _Len; } template constexpr inline std::ptrdiff_t __array_slength(const _Tp(&)[_Len]) __THROW { return _Len; } # else /* __cplusplus < 201103L */ template char (&__array_length(const _Tp(&)[_Len]))[_Len]; # define __array_length(_Arr) (sizeof(__array_length(_Arr))) # define __array_slength(_Arr) \ (static_cast(__array_length(_Arr))) # endif /* __cplusplus >= 201103L */ #else /* !defined(__cplusplus) */ #include # define __is_same_type(_A, _B) \ __builtin_types_compatible_p(__typeof__(_A), __typeof__(_B)) # define __is_array(_Arr) (!__is_same_type((_Arr), &(_Arr)[0])) # if __STDC_VERSION__ >= 201112L # define __must_be(_Expr, _Msg)( \ 0 * (int)sizeof(\ struct {\ _Static_assert((_Expr), _Msg); \ char _ISO_C_forbids_a_struct_with_no_members; \ } \ ) \ ) # else # define __must_be(_Expr, _Msg)( \ 0 * (int)sizeof(\ struct {\ int : (-!(_Expr)); \ char _ISO_C_forbids_a_struct_with_no_members; \ } \ ) \ ) # endif # define __must_be_array(_Arr) __must_be(__is_array(_Arr), "Must be an array!") # define __array_len(_Arr) (sizeof(_Arr) / sizeof((_Arr)[0])) # define __array_length(_Arr) (__array_len(_Arr) + __must_be_array(_Arr)) # define __array_slength(_Arr) ((ptrdiff_t)__array_length(_Arr)) #endif /* defined(__cplusplus) */ static int a[5]; static int v[__array_slength(a)]; static int w[__array_length(v)]; static int *p; int main(void) { int aa[5]; const int xx = 6; int vv[xx]; int yy = 7; int ww[yy]; int *pp; (void)p; (void)pp; (void)ww; return __array_slength(a) + __array_length(v) + __array_slength(w) /* + __array_length(p) */ /* Always breaks :) */ + __array_length(aa) + __array_slength(vv) + __array_length(ww) /* Not in C++ */ /* + __array_length(pp) */ /* Always breaks :) */ ; }
Re: Expose 'array_length()' macro in
* Jonathan Wakely: > I don't see much point in using std::size here. If you're going to > provide the alternative implementation for when std::size isn't > defined, why not just use it always? > > template > #if __cplusplus >= 201103L > constexpr > #endif > inline std::size_t > __array_length(const _Tp(&)[_Num]) __THROW > { > return _Num; > } > > This only requires , not . I agree that this is an advantage. But the version without constexpr is not sufficient because __array_length does not produce a constant expression. I've seen something like this used instead: template char (&___array_length(const _Tp(&)[_Num]))[_Num]; #define __array_length(v) (sizeof(___array_length(v))) If the function type is too cute, a helper struct could be used instead. Thanks, Florian -- Red Hat GmbH, https://de.redhat.com/ , Registered seat: Grasbrunn, Commercial register: Amtsgericht Muenchen, HRB 153243, Managing Directors: Charles Cachera, Brian Klemm, Laurie Krebs, Michael O'Neill
Re: Expose 'array_length()' macro in
On 22/09/20 11:10 +0200, Alejandro Colomar via Libstdc++ wrote: [[ CC += LKML ]] Thanks for all your input. I learned some C++ :) The following code works for all C and C++ standards: g++ --std={c++98, c++03, c++11, c++14, c++17, c++20} gcc --std={c89, c99, c11, c18, c2x} With `-Wall -Wextra -Werror -pedantic -Wno-vla -Wno-sizeof-pointer-div`. It doesn't compile when '+ __array_length(p)' is uncommented. It compiles, and returns the correct value (18). With some exceptions: c++ doesn't accept the VLA (w[]): array_length.c: In function 'int main()': array_length.c:101:22: error: no matching function for call to '__array_slength(int [y])' 101 | + __array_slength(w) | ^ array_length.c:38:1: note: candidate: 'template std::ptrdiff_t __array_slength(const T (&)[N])' 38 | __array_slength(const T(&)[N]) | ^~~ array_length.c:38:1: note: template argument deduction/substitution failed: array_length.c:101:22: note: variable-sized array type 'long int' is not a valid template argument 101 | + __array_slength(w) | ^ But we can live with limited support for VLAs in C++. So I needed to comment '+ __array_slength(w)', and then the program correctly returns 11. As Ville suggested, I renamed the function/macro to __array_[s]length(). However, (some) BSDs already provide nitems() in , so it probably wouldn't be very drastic to provide this function/macro with the name '[s]nitems()' there. Would you like to add anything else before I write the patch? BTW, I should note one more thing: Linux has a macro named '__must_be_array()' with the same API, but slightly different internal implementation, so they should be aware of this change. However, I don't think they include a lot, so maybe it doesn't break anything; but they should be aware anyway. I CC'd the LKML so they are aware and can give any suggestions. Thanks, Alex #if defined(__cplusplus) # include # if __cplusplus >= 201703L # include # endif template You need to use reserved names here. # if __cplusplus >= 201103L constexpr # endif inline std::size_t # if __cplusplus >= 201703L __array_length(const T()[N]) # else __array_length(const T(&)[N]) # endif # if __cplusplus >= 201103L noexcept If this is going to be part of Glibc then you can use its __THROW macro instead. # endif { # if __cplusplus >= 201703L return std::size(arr); # else return N; # endif } I don't see much point in using std::size here. If you're going to provide the alternative implementation for when std::size isn't defined, why not just use it always? template #if __cplusplus >= 201103L constexpr #endif inline std::size_t __array_length(const _Tp(&)[_Num]) __THROW { return _Num; } This only requires , not . template This declaration is wrong, the array extent has type std::size_t. The type you return from the function doesn't change that. The __array_slength definition should be identical to __array_length except for its name and return type. template #if __cplusplus >= 201103L constexpr #endif inline std::ptrdiff_t __array_slength(const _Tp(&)[_Num]) __THROW { return _Num; } #else /* !defined(__cplusplus) */ #include # define __is_same_type(a, b) \ __builtin_types_compatible_p(__typeof__(a), __typeof__(b)) # define __is_array(arr)(!__is_same_type((arr), &(arr)[0])) # if __STDC_VERSION__ >= 201112L # define __must_be(e, msg) ( \ 0 * (int)sizeof(\ struct {\ _Static_assert((e), msg); \ char ISO_C_forbids_a_struct_with_no_members__; \ } \ ) \ ) # else # define __must_be(e, msg) ( \ 0 * (int)sizeof(\ struct {\ int : (-!(e)); \ char ISO_C_forbids_a_struct_with_no_members__; \ } \ ) \ ) # endif # define __must_be_array(arr) __must_be(__is_array(arr), "Must be an array!") # define __array_len(arr) (sizeof(arr) / sizeof((arr)[0])) # define __array_length(arr)(__array_len(arr) + __must_be_array(arr)) # define __array_slength(arr) ((ptrdiff_t)__array_length(arr)) #endif int main(void) { int a[5]; const int x = 6; int v[x]; int y =
Re: Expose 'array_length()' macro in
[[ CC += LKML ]] Thanks for all your input. I learned some C++ :) The following code works for all C and C++ standards: g++ --std={c++98, c++03, c++11, c++14, c++17, c++20} gcc --std={c89, c99, c11, c18, c2x} With `-Wall -Wextra -Werror -pedantic -Wno-vla -Wno-sizeof-pointer-div`. It doesn't compile when '+ __array_length(p)' is uncommented. It compiles, and returns the correct value (18). With some exceptions: c++ doesn't accept the VLA (w[]): array_length.c: In function 'int main()': array_length.c:101:22: error: no matching function for call to '__array_slength(int [y])' 101 | + __array_slength(w) | ^ array_length.c:38:1: note: candidate: 'template std::ptrdiff_t __array_slength(const T (&)[N])' 38 | __array_slength(const T(&)[N]) | ^~~ array_length.c:38:1: note: template argument deduction/substitution failed: array_length.c:101:22: note: variable-sized array type 'long int' is not a valid template argument 101 | + __array_slength(w) | ^ But we can live with limited support for VLAs in C++. So I needed to comment '+ __array_slength(w)', and then the program correctly returns 11. As Ville suggested, I renamed the function/macro to __array_[s]length(). However, (some) BSDs already provide nitems() in , so it probably wouldn't be very drastic to provide this function/macro with the name '[s]nitems()' there. Would you like to add anything else before I write the patch? BTW, I should note one more thing: Linux has a macro named '__must_be_array()' with the same API, but slightly different internal implementation, so they should be aware of this change. However, I don't think they include a lot, so maybe it doesn't break anything; but they should be aware anyway. I CC'd the LKML so they are aware and can give any suggestions. Thanks, Alex #if defined(__cplusplus) # include # if __cplusplus >= 201703L # include # endif template # if __cplusplus >= 201103L constexpr # endif inline std::size_t # if __cplusplus >= 201703L __array_length(const T()[N]) # else __array_length(const T(&)[N]) # endif # if __cplusplus >= 201103L noexcept # endif { # if __cplusplus >= 201703L return std::size(arr); # else return N; # endif } template # if __cplusplus >= 201103L constexpr # endif inline std::ptrdiff_t # if __cplusplus >= 202002L __array_slength(const T()[N]) # else __array_slength(const T(&)[N]) # endif # if __cplusplus >= 201103L noexcept # endif { # if __cplusplus >= 202002L return std::ssize(arr); # else return N; # endif } #else /* !defined(__cplusplus) */ #include # define __is_same_type(a, b) \ __builtin_types_compatible_p(__typeof__(a), __typeof__(b)) # define __is_array(arr)(!__is_same_type((arr), &(arr)[0])) # if __STDC_VERSION__ >= 201112L # define __must_be(e, msg) ( \ 0 * (int)sizeof(\ struct {\ _Static_assert((e), msg); \ char ISO_C_forbids_a_struct_with_no_members__; \ } \ ) \ ) # else # define __must_be(e, msg) ( \ 0 * (int)sizeof(\ struct {\ int : (-!(e)); \ char ISO_C_forbids_a_struct_with_no_members__; \ } \ ) \ ) # endif # define __must_be_array(arr) __must_be(__is_array(arr), "Must be an array!") # define __array_len(arr) (sizeof(arr) / sizeof((arr)[0])) # define __array_length(arr)(__array_len(arr) + __must_be_array(arr)) # define __array_slength(arr) ((ptrdiff_t)__array_length(arr)) #endif int main(void) { int a[5]; const int x = 6; int v[x]; int y = 7; int w[y]; int *p; (void)p; (void)v; (void)w; return __array_slength(a) + __array_slength(v) + __array_slength(w) // + __array_length(p) ; }