在必须连接两个 const char* 变量的情况下，如何避免在 C++ 中使用 #define 宏？

Question

我想在我的代码中删除对 #define 宏的依赖，但我无法使用constexpr实现相同的功能。

实际考虑以下示例：

#define PRODUCT_NAME "CloysterHPC"
constexpr const char* productName = PRODUCT_NAME;

class Newt : public View {
private:
    struct TUIText {

#if __cpp_lib_constexpr_string >= 201907L
        static constexpr const char* title = 
            fmt::format("{} Installer", productName).data();
#else
        static constexpr const char* title = PRODUCT_NAME " Installer";
#endif

    };
};

我已经了解到fmt::format() function 不是一个constexpr function 而它只是一个运行时 function 的艰难方式。我期待我可以在代码上更具表现力，但我不能。 所以我尝试使用std::string ，但在将代码更改为类似以下内容后，我再次得到了完全相同的结果：

#define PRODUCT_NAME "CloysterHPC"
constexpr const char* productName = PRODUCT_NAME;

class Newt : public View {
private:
    struct TUIText {

#if __cpp_lib_constexpr_string >= 201907L
        static constexpr const char* title = std::string{
            std::string{productName} + std::string{" Installer"}}.data();
#else
        static constexpr const char* title = PRODUCT_NAME " Installer";
#endif

    };
};

那么我的误解是什么：

1. 我可以在constexpr上下文中使用fmt 。 这是不真实的。
2. std::string在libstdc++的适当支持下应该是constexpr以在编译时评估字符串操作，但似乎并非如此。
3. 我误解了标准库中__cpp_lib_constexpr_string宏的用途。
4. C++20 将在constexpr上下文中为文本操作提供更大的灵活性。

我已经完成了作业，并在 StackOverflow 上遇到了关于类似问题的其他问题，或者如何在constexpr上下文中使用std::string ：

• `constexpr` 和 `#define` 的区别
• C++20 中的 constexpr std::string，它是如何工作的？
• 是否可以在 constexpr 中使用 std::string？

但是他们都没有清楚地回答我的问题：如何在编译时连接两个给定的字符串以正确地删除代码中的#define宏？

这似乎是微不足道的，因为两个字符串在编译时都是已知的，而且它们也是constexpr 。 最终目标是拥有第三个constexpr const char*内容： CloysterHPC Installer ，而不在代码上使用任何#define宏。

如何做到这一点？ 这在当前的 state 语言中甚至可能吗？ 我应该继续使用宏吗？ 我当前的设置是 GCC 12.1.1，在 RHEL 8.7 系统上使用默认的libstdc++ ：

gcc-toolset-12-12.0-5.el8.x86_64
gcc-toolset-12-libstdc++-devel-12.1.1-3.4.el8_7.x86_64

谢谢。

PS：请注意，有时我在问题中提到字符串时知道它们不是std::string但实际上是const char* ，这只是一种语言约定而不是类型定义。

Answer 1

您可以使用FMT_COMPILE在编译时格式化std::array 。

constexpr auto make_title() {
  constexpr std::size_t size = fmt::formatted_size(
    FMT_COMPILE("{} Installer"), productName);
  std::array<char, size + 1> title{};
  fmt::format_to(title.data(), FMT_COMPILE("{} Installer"), productName);
  return title;
}

struct Newt {
  struct TUIText {
    static constexpr auto title = make_title();
  };
};

演示

Answer 2

我可以在 constexprcontext 中使用 fmt。 这是不真实的。

是的，我实际上不确定为什么会这样。 也许有一些问题会导致目前难以实施（例如，在实施中依赖于一些非constexpr function）。

但即使它是constexpr ，它也无济于事，因为它返回std::string和以下几点：

std::string 在 libstdc++ 的适当支持下应该是 constexpr 以在编译时评估字符串操作，但似乎并非如此。

Libstdc++ 确实支持 C++20 constexpr友好的std::string并且可以在编译时操作它们。 这里没有实施问题。 但是，目前语言中没有机制可以让编译时的动态分配一直持续到运行时。 然而， std::string确实需要动态分配，因为它可以存储任意长度的字符串。 因此不可能将std::string从编译时上下文传递到运行时上下文（即使用constexpr关键字定义std::string ）。 编译时使用的任何std::string都必须在编译时上下文结束之前销毁。

我误解了标准库中 __cpp_lib_constexpr_string 宏的用途。

它仅表示std::string可以在编译时使用，如上所述。

C++20 将在 constexpr 上下文中为文本操作提供更大的灵活性。

自 C++20 以来，在constexpr上下文中，您可以自由地以任何您想要的方式操作std::string 。 但是您不仅试图在编译时上下文中操作std::string ，您还试图跨编译时/运行时边界传递std::string 。

---

但是他们都没有清楚地回答我的问题：如何在编译时连接两个给定的字符串以正确地删除代码中的#define 宏？

如上所述，根本问题是std::string需要动态分配以提供任意长度的字符串。 所以它不能用于这个目的。 也不能只使用const char* ，因为即使您在编译时评估常量，它仍然是一个具有生命周期的 object，而原始指针无法管理 object 的生命周期。（字符串文字是一个例外，因为该语言仅通过在代码中编写就专门为它们提供了生命周期。）

因此，要解决您的问题，您需要一种可以拥有和管理字符串内容的生命周期并且不需要动态 memory 分配的类型，这意味着它必须存储固定长度的字符串，例如：

template<std::size_t N>
using fixed_string = std::array<char, N>;

在这里，我会将N解释为包含空终止符的空间。

这里的字符串长度是类型的一部分，所以我们不能简单地编写一个 function 将输入作为 function arguments 不在其类型中编码长度。 或者对于更一般的字符串操作，output 字符串的长度可能取决于字符串输入的内容。

因此，我们需要确保输入以其类型对字符串进行编码的方式传递。 一种方法是作为模板 arguments 传递。

现在你可以编写如下 function：

template<auto str1, auto str2>
constexpr auto concat_constant_strings() {
    constexpr auto size = (std::ranges::size(str1)-1) + (std::ranges:::size(str2)-1) + 1;
    fixed_string<size> result;
    std::ranges::copy(str1, std::ranges::begin(result));
    std::ranges::copy(str2, std::ranges::begin(result)+std::ranges::size(str1)-1);
    return result;
}

可以用fixed_string作为模板 arguments 调用。

现在剩下的问题是将字符串文字作为模板 arguments 传递，这是不允许直接使用的，即模板参数可能不是指字符串文字的const char*类型。 我们需要一种方法将字符串字面量转换为fixed_string ，但这并不难，实际上这就是库 function std::to_array所做的（假设我们定义了 fixed_string）：

static constexpr auto title = concat_constant_strings<std::to_array(PRODUCT_NAME), std::to_array(" Installer")>();

现在title.data()可以像你原来的title一样使用（如果你愿意，你可以存储一个constexpr const char*到它，但是你需要将fixed_string存储在一个实际的constexpr变量中以管理数据的生命周期).

所有这些都可以通过使用字符串和范围语义实际定义您自己的fixed_string class 而不是依赖std::array来改进。 例如， fixed_string可以从字符串文字（作为对const char数组的引用）中获得一个构造函数。 使用匹配的推导指南， auto模板参数也可以替换为fixed_string ，这样 CTAD 就可以允许直接接受字符串文字作为模板 arguments 而不是通过std::to_array等。上面的实现是一个最小的实现。 很多事情可以做得更干净。

此外，可以使用std::integral_constant或类似的模板和字符串文字运算符从模板 arguments 移动到 function arguments。

另外，在concat_constant_strings的实现中，您可以首先从str1和str2形成std::string s，然后生成一个新字符串，最后构造一个fixed_string以返回。 这样你就可以解除任何正常的std::string操作：

template<auto str1, auto str2>
constexpr auto some_constant_string_operation() {
    constexpr auto lambda = []{
        std::string string1(std::ranges::begin(str1), std::prev(std::ranges::end(str1)));
        std::string string2(std::ranges::begin(str2), std::ranges::prev(std::ranges::end(str2)));
        std::string result;
        /* any std::string manipulation */;
        return result;
    };
    constexpr auto size = std::ranges::size(lambda())+1;
    fixed_string<size> result;
    std::ranges::copy(lambda(), std::ranges::begin(result));
    return result;
}

Answer 3

您为“连接字符串”编写的代码是等待发生的访问冲突：

static constexpr const char* title = std::string{
    std::string{productName} + std::string{" Installer"}}.data();

您在那里构建的所有临时字符串都在该行的末尾到期，留下的指针将指向未分配的 memory。同样，访问冲突等待发生。

现在关于您的连接， string上的operator+和string或文字常量确实有效，它确实是constexpr 。 如果您通过连接两个constexpr string对象查看编译器 output，您可以看到它正确连接了它们：

constexpr string a = "meep";
constexpr string b = "moop";
constexpr string c = a + b;

// look at the end of this:
// error: 'std::__cxx11::basic_string<char>{std::__cxx11::basic_string<char>::_Alloc_hider{((char*)(& c.std::__cxx11::basic_string<char>::<anonymous>.std::__cxx11::basic_string<char>::<unnamed union>::_M_local_buf))}, 8, std::__cxx11::basic_string<char>::<unnamed union>{char [16]{'m', 'e', 'e', 'p', 'm', 'o', 'o', 'p', 0}}}' is not a constant expression

您不能做的是“泄漏”动态 memory 分配（例如，通过将结果分配给变量）。 C++20 constexpr的完成方式，动态分配在函数内部工作（在这种情况下，在operator+内部），但它们不能泄漏到外部，它们必须在 function 内部收集和释放。我们需要更多支持你正在尝试做的事情。