Question

假设我有一个班级：

class MyClass{
  char array[12];
  public:
  MyClass(const char* arr) {
    for (int x = 0; x < 12; x++){
      array[x] = arr[x];
    }
  }
};

是否可以制作MyClass构造函数constexpr。棘手的部分是初始化新数组......

Answer 1

我想（我希望）以下示例可以提供帮助。

我在模板化的类中转换了你的MyClass，其中模板参数是数组的维度（12）;我希望不是问题。

应该适用于C ++ 11和C ++ 14

#include <iostream>

template <std::size_t ...>
struct range
 { };

template <std::size_t N, std::size_t ... Next>
struct rangeH 
 { using type = typename rangeH<N-1U, N-1U, Next ... >::type; };

template <std::size_t ... Next >
struct rangeH<0U, Next ... >
 { using type = range<Next ... >; };

template <std::size_t Dim>
class MyClass
 {
   public:
      char array[Dim];

      template <std::size_t ... rng>
         constexpr MyClass (const char arr[Dim], const range<rng...> &)
         : array{ arr[rng]... }
          { }

      constexpr MyClass (const char arr[Dim]) 
         : MyClass(arr, typename rangeH<Dim>::type())
          { }
 };


int main ()
 {
   constexpr MyClass<12> mc1("0123456789a");
   constexpr MyClass<37> mc2("0123456789abcdefghijklmnopqrstuvwxyz");

   std::cout << mc1.array << std::endl;
   std::cout << mc2.array << std::endl;

   return 0;
 }

p.s：抱歉我的英语不好

---编辑：添加了C ++ 14示例 -

如果你（当你）可以使用C ++ 14，你可以使用std::index_sequence和std::make_index_sequence，避免使用range和rangeH。

示例变为

#include <utility>
#include <iostream>

template <std::size_t Dim>
class MyClass
 {
   public:
      char array[Dim];

      template <std::size_t ... rng>
         constexpr MyClass (const char arr[Dim],
                            const std::index_sequence<rng...> &)
         : array{ arr[rng]... }
          { }

      constexpr MyClass (const char arr[Dim]) 
         : MyClass(arr, std::make_index_sequence<Dim>())
          { }
 };


int main ()
 {
   MyClass<12> mc1("0123456789a");
   MyClass<37> mc2("0123456789abcdefghijklmnopqrstuvwxyz");

   std::cout << mc1.array << std::endl;
   std::cout << mc2.array << std::endl;

   return 0;
 }

- 附录：如何避免显式维度指示 -

如果你发现烦人计算常量字符串中的字符，auto是你的朋友;如果以这种方式声明constexpr函数

template <std::size_t Dim>
constexpr MyClass<Dim> makeMyClass (const char (&arr)[Dim])
 { return MyClass<Dim> { arr }; }

您可以用这种方式声明类型MyClass<N>的变量（或常量）

constexpr auto mc1 = makeMyClass("0123456789a");
constexpr auto mc2 = makeMyClass("0123456789abcdefghijklmnopqrstuvwxyz");

代替

constexpr MyClass<12> mc1("0123456789a");
constexpr MyClass<37> mc2("0123456789abcdefghijklmnopqrstuvwxyz");

也适用于C ++ 14和C ++ 11。

Answer 2

您可以使用std::array代替C阵列和everything just works：

#include <array>

class MyClass{
  std::array<char, 12> array;
  public:
  constexpr MyClass(std::array<char, 12> arr) : array(arr){
  }
};
int main() {
    MyClass m({'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'});
}

我不知道如何使用"Hello World!"而不是字符列表初始化数组。

Answer 3

这是一个不需要您在使用该类之前指定大小的解决方案。

请注意，这是一个C ++ 14解决方案无论如何，您可以轻松找到整数序列内容的C ++ 11实现，并使解决方案适应C ++ 11。

以下是代码：

#include<functional>

class MyClass{
    const char arr[12];
    const std::size_t sz;

    template<std::size_t... I>
    constexpr
    MyClass(std::integer_sequence<std::size_t, I...>, const char *str)
        : arr{str[I]...}, sz{sizeof...(I)}
    { }

public:
    template<int N>
    constexpr
    MyClass(const char (&str)[N])
        : MyClass(std::make_index_sequence<N>(), str)
    { static_assert(N < 12, "!"); }

    constexpr std::size_t size() const { return sz; }
    constexpr char operator[](int n) const { return arr[n]; }
};

int main() {
    constexpr MyClass c{"foo"};
    static_assert(c.size() == 4, "!");
    static_assert(c[0] == 'f', "!");
    static_assert(c[1] == 'o', "!");
    static_assert(c[2] == 'o', "!");
    static_assert(c[3] == '\0', "!");
}

模板技巧，如评论中所述，但它确实有效。

Answer 4

如果您可以访问c ++ 14编译器，只需使用for循环即可。但是，必须初始化内存。缺点是数组被写入两次，但可能在编译时完成。优点是代码更简单。

struct array_wrapper{
    char array[11]{};
    constexpr array_wrapper(const char (& other)[11])   {
        for (unsigned j=0;j<sizeof(other)-1;j++){
            other[j]+=text[j];

        }
    }
};

将constexpr数组复制到类中

4 个答案: