How to store string constants that will be accessed by a number of different classes?

Question

There are too many different answers on stack overflow:

1. Declare a namespace, and in the hpp file mark all strings as extern const, and in the cpp file put their definitions.

   C++ How to share constants with extern between cpp - Error: storage class specified

2. Use static const instead of extern const:

   https://softwareengineering.stackexchange.com/questions/351827/is-it-bad-practice-to-define-constants-using-class-static-methods

3. Use an inline function :

   static string constants in class vs namespace for constants [c++]

4. Use anonymous namespaces!

   Where do I put constant strings in C++: static class members or anonymous namespaces?

This is all really confusing. Using an inline function seems like a really lengthy and tedious way to return a string constant.

Why can't we just use namespaces containing static strings, which are defined in the cpp file ?

Can someone please provide an categorical / unequivocal answer of how one should store strings in a constant file, so multiple cpp files can access them ?

EDIT: In C# and Java it seems to be a non-issue to store all your constants in a "Constants" file. What is the easiest way to do this in C++ ?

EDIT: These answers in Java seem specific and understandable. In C++ it is unclear which is the way likely to have least compilation time, least memory usage at run time.

Sharing constant strings in Java across many classes?

https://dzone.com/articles/constants-in-java-the-anti-pattern-1

Answer 1

This question is way too broad to be answered. But based on further clarifications concerning the nature of the application (names used internally for registering events) given in comments, I would probably suggest something along the lines of using a header like this

#ifndef INCLUDED_EVENT_NAMES
#define INCLUDED_EVENT_NAMES

#pragma once

#include <string_view>

namespace event_names
{
    using namespace std::literals;

    inline constexpr auto name1 = "value1"sv;
    inline constexpr auto name2 = "value2"sv;
}

#endif

Using std::string_view constants rather than plain const char* or const char[N] means that you know the length of each string and don't have to rely on null termination. Using std::string would almost certainly entail memory overhead and initialization cost at runtime. The std::string_views defined here will compile down to code that's directly referring to statically-allocated string literal objects. Even when the same constant is used in multiple translation units (.cpp files) modern compilers will almost certainly store the same string literal in the binary only once (a standard optimization enabled by [lex.string]/15)

If you're stuck with C++11, then it's simplest (and most likely sufficient for what you need to do) to just make some named references for the string literal objects you need:

#ifndef INCLUDED_EVENT_NAMES
#define INCLUDED_EVENT_NAMES

#pragma once

namespace event_names
{
    constexpr auto& name1 = "value1";
    constexpr auto& name2 = "value2";
}

#endif

Since references are not objects, it is impossible for anyone to do anything (accidentally or otherwise) that would cause an actual object to be created for the constant itself (except for the string literal object of course). Also, since it's a reference, it will carry the information about the size of the array, in case anything may be able to take advantage of that (be aware that that size includes the terminating null). And since there still is the implicit conversion to const char* you will be able to use these whereever a plain old C-string is required.

Answer 2

You need to define them in a C++ file (otherwise you will get multiple definitions error):

strings_id.cpp

const char* TXT_TEST1 = "Test1";

And you need to declare them in a header file that will be included where you need them:

strings_id.h

extern const char* TXT_TEST1;

Namespace usage recommended.

class1.cpp

#include "strings_id.h"
printf(TXT_TEST1);

class2.cpp

#include "strings_id.h"
printf(TXT_TEST1);

Answer 3

You cannot just define them in .cpp file because you want their declaration to be visible in other header and cpp files. You don't include .cpp files, so compiler won't know how to resolve your strings' names at compilation time. It will compile your definitions separately to an object file that corresponds to cpp file where you define the strings, but it won't be able to compile files that use the strings, and therefore link the program alltogether. You should use some way of declaring your strings (or way to access these strings, inline wrapper function for example) in a header file.

You can not just define them without any additional keyword in header file because it will create them in every object file that will be compiled from .cpp that includes this header.

So you should use some storage class keyword that will define the strings globally. You can read difference between static and extern in this question.

Anonymous namespace will make your string visible only in translation unit (.h or .cpp file) where you define them. So this is not what you want.

Also note that an inline function is implicitly extern.

Edit:

I personaly would use just extern keyword as I don't see any point in using inline wrapper functions. But you still could use them in combination with static for constants definition where you define your wrapper function. Still using only static keyword in constats definition will make constants accessible only from file where you define them.

Answer 4

Sharing constant strings in Java across many classes?

If you want some thing similar to that, then you can create a header file

#ifndef EVENT_NAME_LITERALS_HXX_
#define EVENT_NAME_LITERALS_HXX_

namespace eventnames
{
    constexpr const char* EVENT1 = "event1";
    constexpr const char* EVENT2 = "event2";
}

#endif

Let's name it as test.hpp

You can define the constants that you want in this header file and reuse the same in any CPP file you wish to use.

The below question provides more information:

use of constexpr in header file

constexpr implies const and const on global/namespace scope implies static (internal linkage), which means that every translation unit including this header gets its own copy of EVENT1 and EVENT2. The memory for that static is only going to be allocated if an address or reference to it is taken, and the address is going to be different in each translation unit.

That implied static for const variables was introduced specifically to use const instead of #define in header files in C++ to define constants. Without static there would be multiple symbol definitions linker error if that header file is included in more than one translation unit which were linked together.

If you don't want to have copies of the constants in each translation units that uses this header file, however the linker will be smart enough to optimize the multiple copies. Also you can "extern" as specified in other answers.