c++ runtime dispatch of 2 sets of static constants - c++

Question

Motivation
A CLI app tries to make use of box drawing characters. But depending on the stdout device this may not be appropriate so there is a -t option to use pure ASCII text.
The concept is just an example, this applies anywhere where we want to select from two or more sets of static constants at runtime.
The question is what is reasonable c++ technique to facilitate this cleanly.
Desired usage Syntax
This is indicative only, but it the constant "invocation" should be terse
int main(int argc, char* argv[]) {
// using derived class style here, but anything would do
auto t = std::strcmp(argv[1], "-t") == 0 ? TxtTerminal() : BdTerminal();
// here we want the syntax to be short
std::cout << "text" << t.horiz << t.right_t << '\n';
}
Already tried
I have tried Base and Derived class style (as above) but there are issues. I can't put one set of constants in TxtTerminal and one in BdTerminal (which extends TxtTerminal).
Using static constants doesn't work, because C++ doesn't support "late static binding" , so it always uses the constants of whichever class you have the instance of.
Using member variables and proper instances of those classes (as hinted at above) doesn't work (nicely) either because the Derived class can't initialise the Base class members directly....
Nor via its constructor initialiser list ...
The derived class would have to pass the entire set to the base class constructor which then modifies the already (BaseClass)initialised values. Really awkward and long winded. I guess passing some struct config { .. }; could work
Similarly using a single class, putting both sets of constants in there in a map<key,config> and using a getter to retrieve the appropriate constant using a constructor initialised bool textmode member state variable.
Maybe with a templated solution taking some template parameter? Well no, because this is a runtime switch.
Similar to the template idea would be some kind of solution with using aliases for 2 separate constant namespaces..same problem..compile time..not runtime.
Using variable templates a bit like the new c++20 maths constants . Same problem, not runtime.
Of course all this const, ie strings of the control character for the "box drawing terminal" are just a bytes long each. Ideally these would just be compacted together as literal initialised const char* in the .text (linux) segment of the executable (std::string seems overkill). Wherever we compose these constants we would want easy concatenation to make the code readable and maintainable. That's not so easy with const char* string literals?
Many options, none seem great. Am I missing something obvious?
EDIT In response to questions below and also to the initial answer by #walnut here is some more fleshed out code using the "static non-instance" approach.
Some unsolved problems therein, see comments:
// NOTE this code compiles and runs, but doesn't quite do what we need
// see comments
#include <cstring>
#include <iostream>
struct TextMode {
static inline const auto cls = "TM cls";
static inline const auto right_t = "TM right_t";
static inline const auto left_t = "TM left_t";
};
struct BlockDrawMode {
static inline const auto cls = "BD cls";
static inline const auto right_t = "BD right_t";
static inline const auto left_t = "BD left_t";
};
struct Terminal {
Terminal(bool textmode = true) { mode = textmode ? &text_mode : &block_drawing_mode; }
// what is this type? some parent class of TextMode/BlockDrawMode?!
// then we get the initilisation loop again...
// ??????? // could be a reference initilised in cstr initilisation, but that's a detail
const TextMode* mode;
static inline const auto text_mode = TextMode{};
static inline const auto block_drawing_mode = TextMode{};
// obviously this needs to be .. ^ BlockDrawMode
// but then doesn't compile because there is no class hierarchy ...
};
int main(int argc, char* argv[]) {
Terminal t{strcmp(argv[1], "-t") == 0};
std::cout << t.mode->cls << '\n' << t.mode->right_t << '\n';
// output (-t makes no difference right now, due to the above issues)
// TM cls
// TM right_t
return 0;
}
EDIT2: I have added a self answer below which uses aggregate initialisation to avoid a lot of the unwanted inheritance complications. Feels a bit "dirty", but looks clean and works fine?

Answer 1

From the comments I gather that what you are looking for is:
If there aren't any other differences in behavior requiring a virtual interface or inheritance, then you can just define a pointer member which is chosen for the correct implementation at construction:
struct Terminal {
Terminal(/* parameters */) {
chooseConfig(/* some arguments */);
}
static constexpr char config1[]{/*...*/};
static constexpr char config2[]{/*...*/};
const char* config;
void chooseConfig(/*arguments*/) {
config = /*condition*/ ? config1 : config2;
};
// use `config` everywhere
};
int main(int argc, char* argv[]) {
Terminal terminal{/* arguments */};
//...
}
If all instances of this class are supposed to share the same configuration and passing the arguments to choose the configuration each time is too cumbersome, then you can also make config and chooseConfig static and instead of calling it in the constructor, call it once in main with Terminal::chooseConfig(/*arguments*/);.

Answer 2

A proposed "self answer":
Here is a version that avoids the hierarchy complications of the config structs. Basically aggregate initialization to the rescue...
This final version shows some proper terminal control strings and some tweaks using a ref to static inline struct. plus it uses designated initialisers. Note selective overrides from the Base Struct Config details would be possible if desired. All the "keys" are automatically checked at compile time, so prevent mistakes during maintenance.
struct Mode {
const char* const esc = "";
const char* const cls = "";
const char* const bd_on = "";
const char* const bd_off = "";
const char* const underline_on = "";
const char* const black = "";
const char* const red = "";
const char* const green = "";
const char* const yellow = "";
const char* const blue = "";
const char* const magenta = "";
const char* const cyan = "";
const char* const white = "";
const char* const reset = "";
const char horiz = '-';
const char vert = '|';
const char right_t = '|';
const char left_t = '|';
const char bottom_t = '|';
const char top_t = '|';
const char intersec = '|';
};
struct Terminal {
static inline const Mode text_mode;
// warning: this is a C99 extension until C++20 comes in
// but it nicely compile checks and self documents the code
// supported by gcc4.7, clang3.0 and msvc19.21
static inline const Mode box_draw_mode{
.esc = "\x1b",
.cls = "\x1b[2J",
.bd_on = "\x1b(0",
.bd_off = "\x1b(B",
.underline_on = "\x1b[4m",
.black = "\x1b[30m",
.red = "\x1b[31m",
.green = "\x1b[32m",
.yellow = "\x1b[33m",
.blue = "\x1b[34m",
.magenta = "\x1b[35m",
.cyan = "\x1b[36m",
.white = "\x1b[37m",
.reset = "\x1b[0m",
.horiz = '\x71',
.vert = '\x78',
.right_t = '\x75',
.left_t = '\x74',
.bottom_t = '\x76',
.top_t = '\x77',
.intersec = '\x6e',
};
const Mode& m;
Terminal(bool textmode = true) : m{textmode ? text_mode : box_draw_mode} {}
};
int main(int argc, char* argv[]) {
Terminal t1{true};
Terminal t2{false};
// usage
// std::cout << t1.m.cls << '\n' << t1.m.right_t << '\n';
// std::cout << t2.m.cls << '\n' << t2.m.right_t << '\n';
return 0;
}
Here is a godbolt (note that clang>3 and gcc>4.7 compile the designated initialisers just fine already). Also note that the godbolt shows that on -O3 the initializers get optimized away to the point were the char values just become inlined register loads. On O1 we can clearly see the strings laid out in .text segment and literally the only thing that happen during Terminal construction is the setting of a single pointer for Mode& m to point to one of the 2 structures: mov qword ptr [rdi], rcx. Good?