Initialize array of compile time defined size as constant expression

Question

I have an array of strings that must be allocated once and their underlying c_str must remain valid for entire duration of the program.

There's some API that provides info about some arbitrary data types. Could look like this:

// Defined outside my code #define NUMBER_OF_TYPES 23 const char* getTypeSuffix(int index);

The getTypeSuffix is not constexpr, so this must work at least partially in runtime.

The interface that I must provide:

// Returned pointer must statically allocated (not on stack, not malloc) const char* getReadableTypeName(int type);

Now my array should have following type:

std::string typeNames[NUMBER_OF_TYPES];

For my purposes, it will be initialized within a wrapper class, right in the constructor:

class MyNames { MyNames() { for (int i = 0; i < NUMBER_OF_TYPES; ++i) { names[i] = std::string("Type ") + getTypeSuffix(i); } } const char* operator[](int type) { return _names[(int)type].c_str(); } private: std::string _names[NUMBER_OF_TYPES]; };

This is then used in an singleton-ish kind of way, for example:

const char* getReadableTypeName(int type) { static MyNames names; return names[type]; }

Now what I want to improve is that I can see that the for loop in the constructor could be replaced as such:

 MyNames() : _names{std::string("Type ") + getTypeSuffix(0), std::string("Type ") + getTypeSuffix(1), ... , std::string("Type ") + getTypeSuffix(NUMBER_OF_TYPES-1)} {}

Obviously a pseudocode, but you get the point - the array can be initialized directly, leaving the constructor without body, which is neat. It also means that the array member _names can be const, further enforcing the correct usage of this helper class.

I'm quite sure there would be many other uses to filling an array by expressions in compile time, instead of having loop. I would even suspect that this is something that happens anyway during 03.

Is there a way to write a C++11 style array initializer list that has flexible length and is defined by an expression? Another simple example would be:

constexpr int numberCount = 10; std::string numbers[] = {std::to_string(1), std::to_string(2), ... , std::to_string(numberCount)};

Again, an expression instead of a loop.

I'm not asking this question because I was trying to drastically improve performance, but because I want to learn about new, neat, features of C++14 and later.

I honestly don't see your problem, the array is an implementation detail of the MyNames class. The only public accessor is your operator which provides a constant output. (You could still make the method const) What extra advantage do you want? — JVApen
– JVApen, Commented Jun 6, 2019 at 15:59

Jarod42 · Accepted Answer · 2019-06-06 16:02:39Z

instead of C-array use std::array, then you might write your function to return that std::array and your member can then be const:

std::array<std::string, NUMBER_OF_TYPES> build_names() { std::array<std::string, NUMBER_OF_TYPES> names; for (int i = 0; i < NUMBER_OF_TYPES; ++i) { names[i] = std::string("Type ") + getTypeSuffix(i); } return names; } class MyNames { MyNames() : _names(build_names()) {} const char* operator[](int type) const { return _names[(int)type].c_str(); } private: const std::array<std::string, NUMBER_OF_TYPES> _names; };

Now you have std::array, you might use variadic template instead of loop, something like (std::index_sequence stuff is C++14, but can be implemented in C++11):

template <std::size_t ... Is> std::array<std::string, sizeof...(Is)> build_names(std::index_sequence<Is...>) { return {{ std::string("Type ") + getTypeSuffix(i) }}; }

and then call it:

MyNames() : _names(build_names(std::make_index_sequence<NUMBER_OF_TYPES>())) {}

I mean cool, but why does writing that I am looking to learn about new features prompt answers that use approaches that I already know and are still the old for-loop thing?
@TomášZato Possibly because something being old doesn't in of itself mean that it's bad?
@TomášZato You can make build_names() return auto. New enough?

Barry · Accepted Answer · 2019-06-06 16:16:26Z

You can defer to an initialization function:

std::array<std::string, NUMBER_OF_TYPES> initializeNames() { std::array<std::string, NUMBER_OF_TYPES> names; for (int i = 0; i < NUMBER_OF_TYPES; ++i) { names[i] = std::string("Type ") + getTypeSuffix(i); } return names; } const char* getReadableTypeName(int type) { static auto const names = initializeNames(); return names[type].c_str(); }

which can be an immediately invoked lambda:

static auto const names = []{ std::array<std::string, NUMBER_OF_TYPES> names; // ... return names; }();

or do you really need the array requirement? We're making strings anyway so I don't understand, then you can just use range-v3:

char const* getReadableTypeName(int type) { static auto const names = view::iota(0, NUMBER_OF_TYPES) | view::transform([](int i){ return "Type "s + getTypeSuffix(i); }) | ranges::to<std::vector>(); return names[type].c_str(): }

I already do that by deferring to a constructor. Making a member const is different though - it's a very mean way of preventing further assignmens.
@TomášZato Sure, but introducing a type for this seems awkward as compared to introducing a function. I don't know what is "mean" about this.
@Barry I meant that I had the mean intention to enforce that this type is const by making it's only member const. Your solution is nice alternative of what I have, but really not what I was looking for.

Artyer · Accepted Answer · 2019-06-06 16:03:55Z

You can use std::make_integer_sequence and a delegating constructor in C++14 (Implementations of std::make_integer_sequence exist in C++11, so this is not really C++14 specific) to get a template parameter pack of integers

#include <string> #include <utility> #define NUMBER_OF_TYPES 23 const char* getTypeSuffix(int index); class MyNames { MyNames() : MyNames(std::make_integer_sequence<int, NUMBER_OF_TYPES>{}) {} template<int... Indices> MyNames(std::integer_sequence<int, Indices...>) : _names{ (std::string("Type ") + getTypeSuffix(Indices))... } {} const char* operator[](int type) { return _names[(int)type].c_str(); } private: const std::string _names[NUMBER_OF_TYPES]; };

This means that no strings are being default constructed.

Max Langhof · Accepted Answer · 2019-06-06 16:39:31Z

Since you ache to use new features, let's use range-v3 (soon-to-be the ranges library in C++2a) to write some really short code:

const char* getReadableTypeName(int type) { static const std::vector<std::string> names = view::ints(0, 23) | view::transform([](int i) { return "Type " + std::to_string(i); }); return names[type].c_str(); }

https://godbolt.org/z/UVoENh

Collectives™ on Stack Overflow

Initialize array of compile time defined size as constant expression

4 Answers 4

3 Comments

4 Comments

Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

3 Comments

4 Comments

Comments

Comments

Related