将一个阵列设置为一个不循环的阵列

Question

在C 中说我们有两个数组：

a[5] = {1,2,3,4,5};
b[5] = {5,4,3,2,1};

如果我们想设置等于b的设置，那么我们如何在不使用循环的情况下实现它？

我的想法是使用递归，但我不确定如何。

编辑：对不起，应该清楚地表明我不想使用标准库功能（包括你们中有些人提到的memcpy）

Answer 1

int a[5] = {1,2,3,4,5};
int b[5] = {5,4,3,2,1};
memcpy(a, b, sizeof(a));

Answer 2

您可以使用标准库中的复制算法。

std::copy(std::begin(b), std::end(b), std::begin(a));

std::begin和std::end在C 标准库中是新的，但是它们易于实现不支持它们的编译器：

template <typename T, std::size_t N>
T* begin(T(&a)[N]) {
    return &a[0];
}
template <typename T, std::size_t N>
T* end(T(&a)[N]) {
    return begin(a) + N;
}

另外，您可以使用std::array（或较老编译器的Boost等效物）和分配运算符：

std::array<int, 5> a = {1,2,3,4,5};
std::array<int, 5> b = {5,4,3,2,1};
a = b;

Answer 3

带有递归：

void copy(int *a, int *b, int b_size) {
     if(b_size == 0) return;    
     *a = *b;
     copy(++a, ++b, b_size-1);
}

我不明白需要递归的需要，而是使用memcpy()更好。

Answer 4

您可以使用memcpy()：

memcpy(a, b, sizeof(a));

Answer 5

memcpy有效，但是您还可以使用 memmove，如果您有过重的内存位置（在示例中不太可能），则可以轻松爆炸，但是如果您具有"克隆"函数的逻辑例如，它可能发生）。

memmove( a, b, sizeof(a) );

当然，如果您确定源和目的地不重叠，则memcpy很好。