Question

我有很多像这样的代码

MyClass v = {1,2,3,4,5,6};

不幸的是，我的项目是针对愚蠢的ARM编译器，它不支持花哨的C ++ 11功能，特别是它不支持＆＃39; initialyzer_list＆＃39;。目前唯一的解决方案如下：

MyClass v(6);
v[0]=1;
v[1]=2;
...

上面有很多代码和手动编辑的问题是灾难。用更少的血来克服它的任何方法？宏，库，漂亮的技巧，其他任何可以允许在MyClass中使用一些编码的find-replace-regexp？

Answer 1

如果您可以先将列表声明为数组，则可以将大小作为模板参数：

class MyClass {
  public:
    template <std::size_t N>
    MyClass(const int (&in)[N]);
};

int main() {
    static const int arr[] = {1,2,3,4,5,6};
    MyClass mc(arr);
}

Answer 2

template<class T>
struct span {
  T* b;
  T* e;
  span( T* s, T* f ):b(s), e(f) {}

  T* begin() const { return b; }
  T* end() const { return e; }
  std::size_t size() const { return end()-begin(); }
};

template<class T, std::size_t N>
struct chain_array {
  T arr[N];

  T const& operator[](std::size_t i) const {return arr[i];}
  std::size_t size() const { return N; }
  T const* begin() const { return arr; }
  T const* end() const { return arr+N; }

  operator span<T>() const {
    return span<T>(begin(), end());
  }

  chain_array<T, N+1> operator,( T rhs ) {
    chain_array<T, N+1> r;
    for (std::size_t i=0; i < N; ++i)
      r[i]=(*this)[i];
    r[N] = rhs;
    return r;
  }
};

template<class T>
chain_array<T, 1> chain( T t ) {
  chain_array<T, 1> r;
  r[0] = t;
  return r;
}

现在写下这个：

MyClass v = (chain(1),2,3,4,5,6);

并添加MyClass::MyClass(span<T>)的重载。

这个解决方案效率很低，因为我创建了中间数组，直到行结束才会丢弃它们。智能编译器可以解决这个问题。

我们可以创建一系列指针或引用（基本上是一个表达式模板），如果我们关心的话，我们只会在转换为最终的il<T>类型时崩溃。

Answer 3

作为Ryan Haining上述解决方案的一个简单替代方案，您实际上并不需要将数组放在变量行之前：

#include <iostream>

struct A {
  template<size_t N>
  A(const int (&list)[N]) {
    size = N;
    myArr = new int[N];
    int *tmp = myArr;
    for(const int *i = list; i < list + N; ++i) {
      *tmp++ = *i;
    }
  }

  ~A() {
    delete[] myArr;
  }

  int *myArr;
  size_t size;
};

int main(int argc, char **argv) {
  A a = (int[]) {1, 2, 3, 4, 5};
  for(int i = 0; i < a.size; ++i) {
    std::cout << a.myArr[i] << std::endl;
  }
  return 0;
}

由于复制省略和隐式构造函数，你可以在同一行上只使用一个强制转换。数组被隐式转换为您的类型，然后通过复制省略有效地将临时值移动到堆栈动态存储。这意味着修改代码只需要几个(type[])并将构造函数重新编译为基于数组而不是基于initializer_list。不幸的是，如果没有c ++ 11 foreach循环，这可能会有点烦人，但是如果有一些指针工作它并不可怕，你可以随时制作一些方便的宏：

#define FOREACH(type, name, arr, N)\
  for(type *__foreach__ptr__ = arr, (name) = *__foreach__ptr__;\
  __foreach__ptr__ < (arr) + (N);\
  ++__foreach__ptr__, (name) = *__foreach__ptr__)

将使用如下：

int N = 5;
int arr[N] = {1, 2, 3, 4, 5};
FOREACH(int, val, arr, N) {
  std::cout << val << std::endl;
}

在C ++ 11之前替代initializer_list

3 个答案: