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

我目前有一个函数，可以为数组类型生成类型名。它目前正在使用编译时已经运行的其他代码。例如，对于变量，如

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;
}

模板
constexpr自动获取名称（类（&）[Size]）
{
//已在编译时运行的代码：
constexpr auto name=getName（）；
constexpr auto length=getNumericString（）；
constexpr auto size=getStrLen（名称）+getStrLen（长度）+3；
//我希望在编译时运行的代码：
静态字符缓冲区[大小]={0}；
如果（缓冲区[0]==0）{
自动i=0，j=0；
while（名称[j]！=0）{
缓冲区[i++]=名称[j++]；
}
缓冲区[i++]='['；
j=0；
while（长度[j]！=0）{
缓冲区[i++]=长度[j++]；
}
缓冲区[i++]=']'；
}
返回缓冲区；
}

是否有可能以某种方式编写该函数的底部以在编译时运行？它只是将两个

常量char*

与

[

和

]

字符放在一起，以表示数组大小。如果可能的话，怎么做

---

谢谢

是的，这是可能的。最棘手的部分是，您需要一个返回

常量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;
}

#包括
#包括
#包括
模板
constexpr const char*getName（）；
模板
constexpr const char*getName（）{
返回“int”；
}
模板
constexpr const char*getNumericString（）；
模板
constexpr const char*getNumericString（）{
返回“16”；
}
constexpr std:：size\u t getStrLen（const char*str）{
标准：尺寸=0；
while（str[ret]！='\0'）ret++；
返回ret；
}
静态断言（getStrLen（“”==0，“”）；
静态断言（getStrLen（“ab”）==2，”）；
静态断言（getStrLen（“4\0\0aaa”）==1，”；
结构包装器{
常量字符*str；
constexpr auto begin（）const{return str；}
constexpr auto end（）常量{
自动it=str；
而（*it！='\0'）++it；
归还它；
}
};
模板
类数组{
私人：
T数据{[size]{}；
公众：
constexpr T&运算符[]（std:：size_T i）{返回数据u[i]；}
constexpr const T&运算符[]（std:：size_T i）const{return data_u[i]；}
constexpr const T*data（）常量{返回数据}
};
模板
constexpr阵列类别（Args…Args）{
数组ret{}；
标准：尺寸i=0；
对于（自动参数：{Wrapper{args}…}）{
for（char c:arg）ret[i++]=c；
}
返回ret；
}
模板
struct StaticDataForConstExport函数{
静态constexpr const char*name=getName（）；
static constexpr const char*length=getNumericString（）；
静态constexpr std:：size\u t size=getStrLen（名称）+getStrLen（长度）+10；
使用Buffer=Array；
静态constexpr Buffer=cat（名称“[”，长度“]\0”）；
};
模板
constexpr typename StaticDataForConstexprFunction:：Buffer StaticDataForConstexprFunction:：Buffer；
模板
constexpr const char*getName（T（&）[N]）{
返回StaticDataForConstexprFunction:：buffer.data（）；
}
int main（）{
int foobar[16]；
constexpr auto res=getName（foobar）；
std:：从技术上讲可能吗？是的。模板是图灵完整的。阅读：。但是你应该吗？可能的副本：@IvanRubinson我会在任何地方使用它们。只要它仅限于并且不用于生产，我就可以接受。滥用编程语言可能会有很多问题，特别是在团队中工作时。使用
std:：array
，这样会更容易。。。