I have a string which is used across different files and translation unit, should I use constexpr const char* or const std::string?

If I have a string variable in a header file which will be used across different files and translation units, should I store it in a constexpr const char* or const std::string?

Here is an example:

// config.h

constexpr const char* string_a = "stringA"; // <--should i declare it like this?

const std::string string_b = "stringB";     // <--or like this?

// a.h

#include "config.h"

class A{
public:
    A();
};

// a.cpp

#include "a.h"

A::A(){
    cout << string_a << endl;
}

// b.h

#include "config.h"

class B{
public:
    B();
};

// b.cpp

#include "b.h"

B::B(){
    cout << string_b << endl;
}

// main.cpp

#include "a.h"
#include "b.h"

int main(){
    A a;
    B b;
    cout << string_a << endl;
    cout << string_b << endl;
    return 0;
}

I have read from books that it is recommended to always use string instead of char*, but I have also heard that constexpr is initialized in compile time which is quite good.

Any time you consider making a tradeoff between speed vs. readability/maintainability, it is vital to profile your code to determine whether or not you see a non-negligible speed increase.

For your case, it is unlikely that constexpr will provide a significant speed increase. The significant downside is that you will have to manage the memory in the const char*, and you will lose access to std::string's convenient features.

There is no definitive answer to the question without knowing the specific context.

In many situations, it will not matter to the result which one you choose, and thus you should go for the one which fits the code base you are working with (i.e. think of code clarity and let the compiler worry about optimizing).

If you need to apply functions offered by the std::string class, then creating the std::string may be a good idea.

On the other hand, if you are coding for an environment with limited resources, e.g. an embedded application with a small amount of RAM and the program stored in non-volatile memory, it may be important that the the compiler is able to construct it at compile time. You would have to make the experiment, but this would certainly work with the const char *, but not so certainly with the std::string (though compilers get better all the time, so this may change).

Whether or not the compiler would be able to construct the variable at compile time also impacts whether or not it is a good idea to define the string in a header file at all. This is a question of its own, see https://stackoverflow.com/questions/12042549/define-constant-variables-in-c-header.

Finally, the const char * would be preferable if you need to access the string from code modules not written in C++, e.g. a plain C module.

It depends on the usage , for example if down the line you want to use the const char* as std::string in some functionality then it will have the overhead of creating the std::string out of const char*. But i would still move away from const char* and use std::string_view which you can constexpr but has the ability to tranform into const char* or std::string and vice-versa. Just be careful about the life time of object from which std::string_view is constructed. Here its not the problem as its gloabl.