Can a C++ pointer point to a static member array of string literals?

Question

Everything works in Visual Studio 2017, but I get linker errors in GCC (6.5.0).

Here is some sample code that isolates my problem:

#include <iostream>

struct Foo{
    static constexpr const char* s[] = {"one","two","three"};
};

int main(){
    std::cout << Foo::s[0] << std::endl;  //this works in both compilers
    const char* const* str_ptr = nullptr;
    str_ptr = Foo::s;                     //LINKER ERROR in GCC; works in VS
    std::cout << str_ptr[1] << std::endl; //works in VS
    return 0;
}

In GCC, I get undefined reference to 'Foo::s'. I need the initialization of Foo::s to stay in the declaration of the struct, which is why I used constexpr. Is there a way to reference Foo::s dynamically, i.e. with a pointer?

More Background Info

I'll now explain why I want to do this. I am developing embedded software to control configuration of a device. The software loads config files that contain the name of a parameter and its value. The set of parameters being configured is determined at compile-time, but needs to be modular so that it's easy to add new parameters and expand them as development of the device continues. In other words, their definition needs to be in one single place in the code base.

My actual code base is thousands of lines and works in Visual Studio, but here is a boiled-down toy example:

#include <iostream>
#include <string>
#include <vector>

//A struct for an arbitrary parameter
struct Parameter {
    std::string paramName;
    int max_value;
    int value;
    const char* const* str_ptr = nullptr;
};

//Structure of parameters - MUST BE DEFINED IN ONE PLACE
struct Param_FavoriteIceCream {
    static constexpr const char* n = "FavoriteIceCream";
    enum { vanilla, chocolate, strawberry, NUM_MAX };
    static constexpr const char* s[] = { "vanilla","chocolate","strawberry" };
};
struct Param_FavoriteFruit {
    static constexpr const char* n = "FavoriteFruit";
    enum { apple, banana, grape, mango, peach, NUM_MAX };
    static constexpr const char* s[] = { "apple","banana","grape","mango","peach" };
};

int main() {
    //Set of parameters - determined at compile-time
    std::vector<Parameter> params;
    params.resize(2);

    //Configure these parameters objects - determined at compile-time
    params[0].paramName = Param_FavoriteIceCream::n;
    params[0].max_value = Param_FavoriteIceCream::NUM_MAX;
    params[0].str_ptr = Param_FavoriteIceCream::s; //!!!! LINKER ERROR IN GCC !!!!!!

    params[1].paramName = Param_FavoriteFruit::n;
    params[1].max_value = Param_FavoriteFruit::NUM_MAX;
    params[1].str_ptr = Param_FavoriteFruit::s; //!!!! LINKER ERROR IN GCC !!!!!!

    //Set values by parsing files - determined at run-time
    std::string param_string = "FavoriteFruit"; //this would be loaded from a file
    std::string param_value = "grape"; //this would be loaded from a file
    for (size_t i = 0; i < params.size(); i++) {
        for (size_t j = 0; j < params[i].max_value; j++) {
            if (params[i].paramName == param_string
            && params[i].str_ptr[j] == param_value) {
                params[i].value = j;
                break;
            }
        }
    }
    return 0;
}

As you can see, there are enums and string arrays involved and these need to match, so for maintenance purposes I need to keep these in the same place. Furthermore, since this code is already written and will be used in both Windows and Linux environments, the smaller the fix, the better. I would prefer not to have to re-write thousands of lines just to get it to compile in Linux. Thanks!

Answer 1

The program is valid in C++17. The program is not valid in C++14 or older standards. The default standard mode of GCC 6.5.0 is C++14.

To make the program conform to C++14, you must define the static member (in exactly one translation unit). Since C++17, the constexpr declaration is implicitly an inline variable definition and thus no separate definition is required.

Solution 1: Upgrade your compiler and use C++17 standard (or later if you're from the future), which has inline variables. Inline variables have been implemented since GCC 7.

Solution 2: Define the variable outside the class definition in exactly one translation unit (the initialisation remains in the declaration).

Answer 2

It looks like you are not using C++17, and pre-C++17 this is undefined behavior, and one that I really dislike. You do not have a definition for your s, but you are ODR-using it, which means that you need to have a definition.

To define this, you have to define it in .cpp file.

In C++17 that would be the valid code. I am not familiar with MSVC, so I am not sure why it works fine there - be it that it is compiled as C++17, or because it is just a different manifestation of undefined behavior.

Answer 3

For C++98, C++11, and C++14 you need to explicitly tell the compiler where the initialization of Foo::s lives (see below) and you are good to go.

struct Foo{
    static const char* s[];
};
const char* Foo::s[] = {"one","two","three"};

And as explained in one of the comments your initialization is OK from C++17.