Re: array_size(T(&)[N])
On 1 Nov., 16:58, courp...@gmail.com wrote:
On 30 oct, 23:15, Jeff Schwab <j...@schwabcenter.com> wrote:
annamalai wrote:
#define array_size(obj) (sizeof(obj)/sizeof(*obj))
C and C++ are very different languages. I recently defended the use of
macros in C on this basis (in a thread on c.l.c++). What you've posted
isn't an alternative to the traditional array_size template. The C++
preprocessor has valid uses, but this isn't one of them.
Unfortunately, this IS, and will be, a valid preprocessor use till C++
has constexpr. The array_size template can't be used as a compile-time
constant expression whereas the macro can.
With only small limitations a minor variant of array_size the
function can be used as an ICE (integral constant expression):
#include <stddef.h>
template<class T, size_t N>
char (&array_size(T(&)[N]))[N]; // no definition
double data[5];
const int N = sizeof(array_size(data));
typedef bool OK[N == 5 ? 1 : -1];
Btw.: The originally written array_size function could not be
a constexpr function as currently written, because the function
uses references as function argument, which is (unfortunably)
infeasible for a constexpr function.
I agree that a macro basing on this definition is more
convenient to use:
#define ARRAY_SIZE(a) sizeof(::array_size(a))
typedef bool OK[ARRAY_SIZE(data) == 5 ? 1 : -1];
silent failure if
passed a pointer rather than an array (a situation made likely
by decay)
This can be easily implemented. Something like :
namespace ARRAY_SIZE_impl {
template<class T, int N> char is_array_check(T(&)[N]);
}
#define ARRAY_SIZE(obj) (sizeof(obj) / sizeof(*obj) \
/ sizeof(ARRAY_SIZE_impl::is_array_check(obj)))
Yeah, this is similar to above shown approach with the
same kind of limitations (e.g. not valid for arrays of
types defined in function-scope). This limitation has
now been removed in the most recent draft.
lack of overloading (e.g. to work with the new TR1 array)
It is possible to simulate overloading using the preprocessor, but in
this case this is useless since we can't get the size of tr1::array as
a compile-time constant ( at least AFAICT, but I'm not very familiar
with tr1::array ).
tr1::array supports access of the size as a compile-time
constant via the tuple interface specialized for std::array,
see [tr.array.tuple]/1 in N1836:
tuple_size<array<T, N> >::value
Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]