Question

在C＃中，我可以使用函数生成静态数组：

private static readonly ushort[] circleIndices = GenerateCircleIndices();

....

    private static ushort[] GenerateCircleIndices()
    {
        ushort[] indices = new ushort[MAXRINGSEGMENTS * 2];
        int j = 0;

        for (ushort i = 0; i < MAXRINGSEGMENTS; ++i)
        {
            indices[j++] = i;
            indices[j++] = (ushort)(i + 1);
        }

        return indices;
    }

使用C ++我相信以下是生成静态数组的正确方法：

·H

static const int BOXINDICES[24];

.cpp（构造函数）

static const int BOXINDICES[24] =
{ 
    0, 1, 1, 2, 
    2, 3, 3, 0, 
    4, 5, 5, 6, 
    6, 7, 7, 4, 
    0, 4, 1, 5, 
    2, 6, 3, 7 
};

我如何为circleIndices做同样的事情，但是使用函数来生成值？

·H

static const int CIRCLEINDICES[];

.cpp（构造函数）

static const int CIRCLEINDICES[] = GenerateCircleIndices();  // This will not work

我是否必须使用值0初始化数组元素然后调用函数？

Answer 1

这取决于您是否希望在运行时或编译时评估该函数。在C＃中，它将在运行时发生，但C ++为您提供了在编译时执行此操作的选项。

如果要在运行时执行此操作，可以使用静态初始化类：

struct S
{
    int X[N];

    S() { for (int i = 0; i < N; i++) X[i] = ...; }
};

S g_s;

这里构造函数在进入main之前调用，以设置数组。

如果你想在编译时这样做，你可以用C＃中不可能的各种方式使用模板或宏。如果在编译时执行此操作，则数组的数据将由编译器计算，并由加载程序从应用程序映像的静态区域直接填充到进程地址空间中的memcpy。这是一个例子：

#include <iostream>
#include <array>
using namespace std;

constexpr int N = 10;
constexpr int f(int x) { return x % 2 ? (x/2)+1 : (x/2); }

typedef array<int, N> A;

template<int... i> constexpr A fs() { return A{{ f(i)... }}; }

template<int...> struct S;

template<int... i> struct S<0,i...>
{ static constexpr A gs() { return fs<0,i...>(); } };

template<int i, int... j> struct S<i,j...>
{ static constexpr A gs() { return S<i-1,i,j...>::gs(); } };

constexpr auto X = S<N-1>::gs();

int main()
{
        cout << X[3] << endl;
}

请参阅：C++11: Compile Time Calculation of Array

Answer 2

#include <array>        // std::array
#include <utility>      // std::begin, std::end
#include <stddef.h>     // ptrdiff_t
using namespace std;

typedef ptrdiff_t Size;

template< class Collection >
Size countOf( Collection const& c )
{
    return end( c ) - begin( c );
}

typedef array<int, 24> CircleIndices;

CircleIndices generateCircleIndices()
{
    CircleIndices   result;
    for( int i = 0;  i < countOf( result );  ++i )
    {
        result[i] = i;
    }
    return result;
}

CircleIndices const circleIndices = generateCircleIndices();

#include <iostream>
int main()
{
    for( int i = 0;  i < countOf( circleIndices );  ++i )
    {
        wcout << circleIndices[i] << ' ';
    }
    wcout << endl;
}

Answer 3

在C ++中，函数不能返回数组，因此不能用于初始化数组。您拥有的两个选项是：

static const int* CIRCLEINDICES = GenerateCircleIndices();

或者

static int CIRCLEINDICES[some_size];
GenerateCircleIndices(CIRCLEINDICES);

从头中的函数生成静态数组值

3 个答案: