Click here to Skip to main content
12,254,393 members (66,189 online)
Click here to Skip to main content
Add your own
alternative version

Tagged as


15 bookmarked

Obtaining the size of a C++ array using templates and other techniques (from C++11) - Part 2

, 6 Dec 2011 CPOL
Rate this:
Please Sign up or sign in to vote.
How to obtain the size of a C++ array using templates and other techniques.

Welcome back! In Part 1 we saw a nifty technique to obtain the size of an array via function template argument deduction. However, this ended with the problem of how to use this value at compile time, e.g. as the size of another array. This proves hard in C++98 but C++11 changes things.

The simplest way to enable compile time use is to make use of the new constexpr keyword. This tells the compiler that the function can be completely evaluated (to a constant value) at compile. As such C++11 allows this function to be called at compile time though instead the evaluated constant value is used. Adding this to the definition of GetNumberOfElements as below:

template<typename T, size_t sizeOfArray>
constexpr size_t GetNmberOfElements(T (&)[sizeOfArray])
    return sizeOfArray;

now allows the following to compile:

char a[100];
char b[GetNumberOfElements(a)];

Is this the best that we can do? Using raw array types isn't that good. Even though the size of the array is known and can now be discovered at compile time using it in std::for_each is somewhat burdensome as the length must be obtained in order to obtain the end iterator, i.e.

std::for_each(&a[0], &a[GetNumberOfElements(a)], SomeFunctor());

Due to the raw array not being an object it doesn't have an end method which means the code must rely on the programmer specifying the correct index for the end of an array or using the technique above.

This can be remedied by moving from raw array types to std::array (first made available in TR1), e.g.

std::array<char, 100> a;
std::for_each(std::begin(a), std::end(a), SomeFunctor());

(Note the use of the C+11 non-member versions begin and end functions)

The downside of using std::array is that even though it can be initialized when defined, e.g.

std::array<int, 4> a = { 0, 1, 2, 3 };

It effectively requires the length of the array specifying twice. Firstly as the template parameter and then again implicitly by the number of elements in the initializer list.

Given the new initializer list feature of C++11 it could be expected that this would allow initialization without the length parameter. However it seems this is not supported "out of the box" though there are some interesting techniques to allow this.

All is not lost though. Taking a step back and returning to the raw array the size issue can be circumvented by use of C++11's range-for statement.

char a[100];
SomeFunctor sf;

for (auto x : a)

To backtrack once again, the use of the non-member versions of begin and end can also be used on raw arrays so the example above can also be written as:

char a[100];
std::for_each(std::begin(a), std::end(a), SomeFunctor());

Which if the purpose of the loop is to invoke a functor then std::for_each is more succinct than range-for as it doesn't require an explicit instance of the functor.

I suspect the same technique for finding the length of a naked array along with constexpr is used by the non-member version of end to obtain the length. In fact one version of end is probably a function template overloaded to accept a raw array as its container parameter, e.g.:

template<typename T, size_t>
constexpr T* example_begin(T (&array)[])
    return &array[0];

template<typename T, size_t sizeOfArray>
constexpr T* example_end(T (&array)[sizeOfArray])
    return &array[sizeOfArray];
char a[100];
std::for_each(example_begin(a), example_end(a), SomeFunctor());

However, any looping mechanism that requires both the start and end to be specified rather than just the container does allow for an error to occur by having begin and end of different containers specified whereas range-for eliminates this possibility!

In summary, it's possible to find the size of a raw array using function template deduction and using C++11 features that value can be used at compile time. However, if the reason that the size needs obtaining is to obtain the end iterator then C++11 makes this redundant through the use of range-for and the non-member versions of begin and more accurately end.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Team Leader
United Kingdom United Kingdom
My day job is mostly working in C++ with a bit of C#. I write a fair amount of command line based tools and really wish they could have a GUI front-end to them hence why I spend my spare time working with WPF.

I started a blog few years back but didn't do a lot with it. I've started describing some of the interesting programming things I come across on it. Please take a look.

You may also be interested in...

Comments and Discussions

QuestionI have a question Pin
paladin_t1-Feb-12 22:46
memberpaladin_t1-Feb-12 22:46 
GeneralMy vote of 5 Pin
Addy Tas14-Jan-12 8:58
memberAddy Tas14-Jan-12 8:58 
GeneralMy vote of 5 Pin
Stefan_Lang12-Dec-11 23:57
memberStefan_Lang12-Dec-11 23:57 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.160426.1 | Last Updated 6 Dec 2011
Article Copyright 2011 by PeteBarber
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid