C++ 在编译时用 constexpr char 数组指针分配静态数组？答案

【问题标题】：C++ assign static array with constexpr char array pointers at compile time?C++ 在编译时用 constexpr char 数组指针分配静态数组？
【发布时间】：2018-08-09 18:18:57
【问题描述】：

我目前有一个为数组类型生成类型名称的函数。它目前正在使用在编译时已经运行的其他代码。例如int data[4]这样的变量，函数返回字符串int[4]：

template<typename Class, int Size>
constexpr auto getName(Class (&)[Size])
{
    // code that already runs at compile time:
    constexpr auto name = getName<Class>();
    constexpr auto length = getNumericString<Size>();
    constexpr auto size = getStrLen(name) + getStrLen(length) + 3;

    // code I would like to run at compile time:
    static char buffer[size] = {0};
    if (buffer[0] == 0) {
        auto i = 0, j = 0;
        while (name[j] != 0) {
            buffer[i++] = name[j++];
        }
        buffer[i++] = '[';
        j = 0;
        while (length[j] != 0) {
            buffer[i++] = length[j++];
        }
        buffer[i++] = ']';
    }
    return buffer;
}

是否可以编写该函数的底部以某种方式在编译时运行？它只是将两个const char* 与[ 和] 字符放在一起来表示数组大小。如果可能的话，怎么做？

谢谢！

【问题讨论】：

技术上可行吗？是的。模板是图灵完备的。阅读：Template Metaprogramming。但是你应该吗？
可能重复：stackoverflow.com/questions/38955940/…
@IvanRubinson 我会在任何地方使用它们。
只要它仅限于Code Golf 并且不用于生产，我可以忍受。滥用一种编程语言可能会导致很多问题，尤其是在团队中工作时。
有了std::array<char, size>，会更容易...

标签： c++ templates constexpr

【解决方案1】：

是的，这是可能的。最棘手的部分是您要求一个返回const char*（而不是拥有数据的东西）的解决方案。

正如您在示例中注意到的那样，const char* 需要一个缓冲区来指向。这很棘手，因为 constexpr 函数目前 (C++17)不允许拥有 static constexpr char buffer[size]{/* whatever*/};。相反，您可以使用模板化帮助程序类的静态数据成员。

以下是我使用 -std=c++14 在 clang 6.0.1 和 GCC 8.1.1 上测试过的完整演示。

#include <cassert>
#include <cstddef>

#include <iostream>

template<class T>
constexpr const char* getName();

template<>
constexpr const char* getName<int>() {
  return "int";
}

template<std::size_t N>
constexpr const char* getNumericString();

template<>
constexpr const char* getNumericString<16>() {
  return "16";
}

constexpr std::size_t getStrLen(const char* str) {
  std::size_t ret = 0;
  while(str[ret] != '\0') ret++;
  return ret;
}

static_assert(getStrLen("") == 0, "");
static_assert(getStrLen("ab") == 2, "");
static_assert(getStrLen("4\0\0aaa") == 1, "");

struct Wrapper {
  const char* str;

  constexpr auto begin() const { return str; }
  constexpr auto end() const {
    auto it = str;
    while(*it != '\0') ++it;
    return it;
  }
};

template<class T, std::size_t size>
class Array {
 private:
  T data_[size]{};
 public:
  constexpr T& operator[](std::size_t i) { return data_[i]; }
  constexpr const T& operator[](std::size_t i) const { return data_[i]; }
  constexpr const T* data() const { return data_; }
};

template<std::size_t buffer_size, class... Args>
constexpr Array<char, buffer_size> cat(Args... args) {
  Array<char, buffer_size> ret{};

  std::size_t i = 0;
  for(auto arg : {Wrapper{args}...}) {
    for(char c : arg) ret[i++] = c;
  }

  return ret;
}

template<class T, std::size_t N>
struct StaticDataForConstexprFunction {
  static constexpr const char* name = getName<T>();
  static constexpr const char* length = getNumericString<N>();
  static constexpr std::size_t size = getStrLen(name) + getStrLen(length) + 10;

  using Buffer = Array<char, size>;
  static constexpr Buffer buffer = cat<size>(name, "[", length, "]\0");
};

template<class T, std::size_t N>
constexpr typename StaticDataForConstexprFunction<T, N>::Buffer StaticDataForConstexprFunction<T, N>::buffer;

template<class T, std::size_t N>
constexpr const char* getName(T (&)[N]) {
  return StaticDataForConstexprFunction<T, N>::buffer.data();
}

int main() {
  int foobar[16];
  constexpr auto res = getName(foobar);
  std::cout << res << std::endl;
}

【讨论】：