The size of std::array is known at compile time, but the size member function isn't static. Is there any reason for that? It's slightly inconvenient not to be able to calculate the size without instantiating an object. (Well, I know about std::tuple_size specialization, but it doesn't work for classes derived from std::array.)
可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试):
问题:
回答1:
Since C++11 you can use std::tuple_size on std::array to obtain the size as a compile time constant. See
回答2:
There is no good reason for that. In fact, boost::array, the precursor of std::array, actually defines static size_t size(){return N;} (although a modern more useful version should use constexpr also).
I agree with the OP that this is an unfortunate omission and underexplotaition of the language features.
Problem
I faced this problem before and the logic leads to couple of solution. The OP situation is the following: you have a class that derives from std::array and you need to access to the size at compile time.
#include template struct myarray : std::array{ ... very cool functions... }; and later you have
template functionOnArrayConcept(Array const& a){...} Where you need to know N at compile time.
As it is now, there is no code ??? that you can write that works both for std::array and myarray, because std::tuple_size will not work.
Solution
(this was suggested by @T.C. here Access maximum template depth at compile? . I am just copying it here.)
template auto array_size_impl(const std::array&) -> std::integral_constant<:size_t n="">; template using array_size = decltype(array_size_impl(std::declval())); template constexpr auto static_size() -> decltype(array_size::value){ return array_size::value; } template constexpr auto static_size(Array const&) -> decltype(static_size()){ return static_size(); } Now you can use it as this:
template()> functionOnArrayConcept(Array const& a){...} If you are using std::tuple_size already, unfortunately (I think) you need to specialize std::tuple_size for each of your derived classes:
namespace std{ template // can be more complicated if myarray is not parametrized by classes only struct tuple_size> : integral_constant>()>{}; } (In my opinion this is caused by another mistake in the STL design that std::tuple_size doesn't have the default template.)
The solutions beyond this point are near obsolete compared to @T.C. solution described above. I'll keep them here for reference only.
Solution 1 (idiomatic)
If the function is decoupled from you class you have to use std::tuple_size because that is the only standard way of accessing the size of std::array at compile time. Therefore you have to do this, 1) provide a specialization of std::tuple_size and if you can control myclass, 2) std::array doesn't have static size() but your derived class could (that simplifies the solution).
So, this can be a pretty general solution within the framework of STD, that consists in the specialization of std::tuple_size. (Unfortunately providing specialization in std:: sometimes is the only way to make real generic code. See http://en.cppreference.com/w/cpp/language/extending_std)
template struct myarray : std::array<...something that="" depends="" on="" t...="">{ ... very cool functions... static constexpr size_t size(){return std::tuple_size<:array that="" depends="" on="" t...="">>::value;} }; namespace std{ // specialization of std::tuple_size for something else that `std::array<...>`. template // can be more complicated if myarray is not parametrized by classes only struct tuple_size> : integral_constant::size()>{}; } // now `functionOnArrayConcept` works also for `myarray`. (static size_t size() can be called differently, and there may be other ways to deduce the size of the base of myarray without adding any static function to size.)
Note
In the compilers I tried the following trick doesn't work. If this worked, the whole discussion would be less important, because std::tuple_size wouldn't be so necessary.
template // error "illegal expression", `std::declval()` doesn't work either. functionOnArrayConcept(ArrayConcept const& a){...} Conceptualization
Due to this shortcoming in the implementation (or specification?) of std::array by which the only way to extract the compile time size is through std::tuple_size. Then std::tuple_size is conceptually part of the necessary interface of std::array. Therefore when you inherit from std::array you have also "inherit" std::tuple_size in some sense. And unfortunately you need to do this for further derivations. This is the concept behind this answer.
Solution 2 (a GNU hack)
If you are using GNU's STD library (that includes gcc and clang), there is a hack that can be used without adding any code, and that is by using the _M_elems member which is of (member) type ::_AT_Type::_Type (a.k.a. type T[N]) of std::array.
This function will effectively behave like a static function ::size() (except that it cannot be used for instances of an object) of std::array or any type derived from std::array.
std::extent::value which can be wrapped into:
template constexpr size_t array_size(){ return std::extent::value } This work because the member type _AT_Type::_Type is inherited. (I wonder why GNU left this implementation detail public. Another omission?)
Solution 3 (a portable hack)
Finally, a solution using template recursion one can figure out what is the dimension of the base std::array.
template, Array>::value> struct size_of : size_of, Array>::value>{}; template struct size_of : std::integral_constant{}; // this is a replacement for `static Array::size()` template::value> constexpr size_t static_size(){return N;} // this version can be called with an object like `static Array::size()` could template::value> constexpr size_t static_size(Array const&){return N;} This is how one will get:
struct derived : std::array{}; static_assert( static_size<:array>>() == 3 ); static_assert( static_size() == 3 ); constexpr derived d; static_assert( static_size(d) == 3 ); If this function is called with some type unrelated to std::array, it will give a recursion error. If you want a "soft" error instead, you have to add the specialization.
template struct size_of {}; where 250 stands for a large number but smaller than the recursion limit. (I don't know how to get this number automatically, I only know the the recursion limit in my compiler is 256.)
回答3:
It can indeed be static, however, this would break "container" interface which won't play well with other generic algorithms that do expect containers to have size() member function. There is nothing to worry about, though, as std::array::size() is a constexpr function, so there is absolutely no overhead associated with it.
UPDATE:
Mr. Jrok have pointed out that one can call static member functions with "normal" syntax. Below is an example when it won't:
#include struct array { static unsigned int size() { return 0; } }; template static auto do_stuff(T& data) -> decltype(data.size()) { typedef decltype(data.size()) size_type; size_type (T::*size_calc)() const = &T::size; size_type n = 0; for (size_type i = 0, e = (data.*size_calc)(); i data { 1, 2, 3, 4, 5 }; do_stuff(data); // This, however, won't work as "size()" is not a member function. #if 0 array fake; do_stuff(fake); #endif } 回答4:
array::size is constexpr, so unless the stored type has a constructor or destructor, the operation array_t().size() is very unlikely to have any runtime effect. You can embed it in a template argument to ensure it doesn't. It does otherwise look like runtime code, though.
I think that it's nonstatic simply for uniformity with other containers. For example, you can form a pointer-to-member-function to it. Discovering the true rationale of anything often takes tough research, though. It could be that the authors never thought of it.
The other thing that comes to mind is that some special functions such as operator () () cannot be static, so any opportunistic application of static can only be piecemeal. Generic problems are better solved in uniform fashion, even if it means changing the core language.
回答5:
Note that the Microsoft Visual C++ doesn't currently support constexpr (http://msdn.microsoft.com/en-us/library/hh567368.aspx), so the following valid code won't work:
array dog; array cat; The following class provides a compile time static variable:
/** * hack around MSVC's 2012 lack of size for const expr */ template struct vcarray : public std::array { static const size_t ArraySize= N; }; which can be used as:
vcarray cat; vcarray dog; 回答6:
In my opinion it does not make sense to make the size member function static insofar as it provides no added value. It is possible to make it static, but you gain nothing from it.
The way the array class is designed, you can query the size of a given array object without explicitly knowing/remembering its exact type (which includes its size) at that location where you need the size. This is a convenience, and it removes the opportunity to make copy/edit errors. You can write code like this:
std::array blah; // 50 lines of code do_something_with(blah.size()); // blah knows its size As you can see, at the location where I'm consuming the array's size, I don't actually remember what it was, but my code will work anyway, regardless of what the value actually is, and regardless whether maybe one day I change the array's type to be a different size.
Since the size function merely returns a template parameter, the compiler can trivially prove that the return value is a compile-time constant and optimize accordingly too (the function is also constexpr, so you can also use the return value as template parameter or enumeration).
Now what will be different if we make the size member function static?
If size was a static function, you could still use the static member function in the exact same way (that is, on an object instance, in a "not static way"), but that would be "cheating". After all, this is something that already works anyway, whether the member is static or not.
Further, you now have the possibility of invoking the member function without an object instance. While this seems like a good thing at first glance it really is no advantage at all for the array class template (...where the returned size is a template parameter).
In order to call a member function without an object (that is, in a "static member function way"), you must properly qualify the function with the class name and its proper template parameters.
In other words, you must write something like:
std::array blah; // 50 lines of code do_something_with(std::array::size()); // I must tell size what to return Now what have we gained from calling the size function? Nothing at all. In order to call the function, we needed to provide the correct template parameters, which includes the size.
That means no more and no less than that we must supply the information that we wish to query. Calling the function doesn't tell us anything we didn't already know.