Question

例如，我有一个对数组（这是一个静态变量）a []表示点A，B，C的坐标：

pair<float,float> MyClass::a[]={{0,0},{320,568},{640,0}};

我想要另一个存储AB和BC长度的数组b []：

float MyClass::b[sizeof(a)/sizeof(pair<float,float>)-1]={
    sqrt((a[1].first-a[0].first)*(a[1].first-a[0].first)+(a[1].second-a[0].second)*(a[1].second-a[0].second)),
    sqrt((a[2].first-a[1].first)*(a[2].first-a[1].first)+(a[2].second-a[1].second)*(a[2].second-a[1].second))
};

但是b []不是很容易维护，因为如果我向[]添加元素，我需要手动更改b []。有没有可以自动生成b []的方法？有什么像例如：宏

float b[]={MACRO(a)};

或

float b[]={MACRO(sizeof(a)/sizeof(pair<float,float>))};

或模板：

template<int i>
struct s{
    float b[]={something a[i+1]-a[i]};
};

s<sizeof(a)/sizeof(pair<float,float>)> _s;

或其他设计模式，允许我在不改变b []的情况下手动更改[]的大小，甚至不需要修改代码的其他部分？

Answer 1

一个明显的答案是使用向量而不是数组：

template <class T, size_t N>
size_t elements(T (&array)[N]) {
    return N;
}

// could also use a vector for a, if desired:
pair<float,float> a[]={{0,0},{320,568},{640,0}};
vector<float> b;

for (int i=1; i<elements(a); i++) {
    float dx = a[i].first - a[i-1].first;
    float dy = a[i].second - a[i-1].second;
    b.push_back(sqrt(dx*dx + dy * dy));
}

有了这个，a大小的变化不需要b的任何其他更改来正确跟踪其大小。

当然，还有其他方式可以完成这项工作。例如，如果你这么做很多，你可以将它全部包装在class中。我不确定这真的有什么意义。

Answer 2

这里最大的问题是使用C数组;它们不容易初始化。使用std :: array，它非常简单：

pair<float,float> MyClass::a[]={{0,0},{320,568},{640,0}};
auto b = sqrt(a);

带

template<typename T, size_t N>
std::array<T, N> sqrt(std::pair<T,T> (&points)[N])
{
   using std::sqrt;
   std::array<T, N> retval;
   for (int i = 0; i != N; ++i) {
       retval[i] = sqrt(points[i].first * points[i].first + 
                        points[i].second * points[i].second) ;
   }
  return retval;

}

是否可以根据另一个硬编码阵列的数据自动生成硬编码阵列？

2 个答案: