我需要从一个 10 元素数组制作两个 5 元素数组。 我做了这样的代码

#include <iostream>
using namespace std;

int main() {
    const int size1 = 10, size2 = 5;

    int array[size1]{ 1,3,6,2,82,10,6,34,2,5 }, arb[size2]{}, arc[size2]{};

    for (size_t i = 0; i < 5; i++)
    {
        arb[i] = array[i];
    }
    for (size_t i = 5; i < 9; i++) {
        
        for (size_t e = 0; e < 4; e++)
        {
            arc[e] = array[i];
        }
        
    }

    for (size_t i = 0; i < 5; i++)
    {
        cout << arb[i] << "\t";
    }
    cout << endl;

    for (size_t i = 0; i < 5; i++)
    {
        cout << arc[i] << "\t";
    }
}

但是第二个数组给出了“2 2 2 2 0”。 我没有任何想法如何解决这个问题。

除非你有一个特定的原因，这些必须是数组（这非常罕见，至少在我的经验中），否则我会使用std::vector s。 这使得用较大的正确部分初始化较小的“数组”变得微不足道：

std::vector<int> array { 1,3,6,2,82,10,6,34,2,5 };
std::vector<int> arb { array.begin(), array.begin() + size2};
std::vector<int> arc { array.begin() + size2, array.end() };

这也使得（例如）将主数组一分为二变得容易，无论其确切大小如何：

std::vector<int> array { 1,3,6,2,82,10,6,34,2,5, 12, 17, 92, 101, -3 };
auto half = array.size() / 2;
std::vector<int> arb { array.begin(), array.begin() + half};
std::vector<int> arc { array.begin() + half, array.end() };

[就目前而言，如果主数组具有奇数个元素，这将使后半部分更大，但如果这不是您想要的，您可以更改half的计算以满足您的需要。]

这些嵌套循环

for (size_t i = 5; i < 9; i++) {
    
    for (size_t e = 0; e < 4; e++)
    {
        arc[e] = array[i];
    }
    
}

没有意义。 此外，还使用了未知的幻数9和4 。 事实上，除了最后一个元素之外，数组arc所有元素都被设置为元素array[8]的值，也就是在外循环的最后一次迭代中使用的数组array元素的值。

该程序可以如下所示

#include <iostream>

int main() 
{
    const size_t size1 = 10, size2 = 5;

    int array[size1]{ 1,3,6,2,82,10,6,34,2,5 }, arb[size2]{}, arc[size2]{};

    for ( size_t i = 0; i < size2; i++ )
    {
        arb[i] = array[i];
    }
    
    for ( size_t i = 0; i < size2; i++ )
    {
        arc[i] = array[i + size2];
    }
    
    for ( const auto &item : arb )
    {
        std::cout << item << ' ';
    }
    
    std::cout << '\n';
    
    for ( const auto &item : arc )
    {
        std::cout << item << ' ';
    }
    
    std::cout << '\n';
    
    return 0;
}

程序输出是

1 3 6 2 82 
10 6 34 2 5 

或者，您可以使用标准算法std::copy和std::copy_n 。 例如

#include <iostream>
#include <algorithm>
#include <iterator>
#include <algorithm>

int main() 
{
    const size_t size1 = 10, size2 = 5;

    int array[size1]{ 1,3,6,2,82,10,6,34,2,5 }, arb[size2]{}, arc[size2]{};

    std::copy_n( std::begin( array ), size2, std::begin( arb ) );
    std::copy_n( std::next( std::begin( array ), size2 ), size2, std::begin( arc ) );
    
    for ( const auto &item : arb )
    {
        std::cout << item << ' ';
    }
    
    std::cout << '\n';
    
    for ( const auto &item : arc )
    {
        std::cout << item << ' ';
    }
    
    std::cout << '\n';
    
    return 0;
}

程序输出与上图相同。

1 3 6 2 82 
10 6 34 2 5 

您通过第二次迭代在第二个循环中犯了错误，在这个循环之后，您只设置了新数组中的最后一个元素......

这是代码的正确版本：

#include <iostream>

int main() {
  const int size1 = 10, size2 = 5;

  int array[size1]{ 1, 3, 6, 2, 82, 10, 6, 34, 2, 5 };
  int arb[size2]{};
  int arc[size2]{};

  for (size_t i = 0; i < 5; i++) {
    arb[i] = array[i];
  }
  for (size_t i = 5; i < 10; i++) {
    arc[i-5] = array[i];
  }

  for (size_t i = 0; i < 5; i++) {
    std::cout << arb[i] << "\t";
  }
  std::cout << std::endl;

  for (size_t i = 0; i < 5; i++) {
    std::cout << arc[i] << "\t";
  }
}

另外，我建议使用std::copy的代码更简单的版本：

#include <iostream>

int main() {
  const int size1 = 10, size2 = 5;

  int array[size1]{ 1, 3, 6, 2, 82, 10, 6, 34, 2, 5 };
  int arb[size2]{};
  int arc[size2]{};

  std::copy(&array[0], &array[5], arb);
  std::copy(&array[5], &array[10], arc);

  for (size_t i = 0; i < 5; i++) {
    std::cout << arb[i] << "\t";
  }
  std::cout << std::endl;

  for (size_t i = 0; i < 5; i++) {
    std::cout << arc[i] << "\t";
  }
}

问题出在嵌套的for循环中

for (size_t i = 5; i < 10; i++)
{ 
    //essentially what you're doing in this loop is that for each element 5, 6, 7, 8, 9 
    // for the first loop you are assigning for instance arc[0] till arc[3] to be all equal to array[5]
    // so whats happening is n=by the time you reach arc
    // take care you are assigning only 4 elements

    for (size_t e = 0; e < 4; e++)          // size here 
    {
        arc[e] = array[i];
    }

}

另一种方法是这样做：

for (size_t i = 0; i < size2; i++)
{
    arc[i] = array[i+5];
}

让我们试试脏变体，O(1)

警告如果数组在 arb 或 arc 之前超出范围，这将在您的脸上爆炸

int main() {
    const int size1 = 10, size2 = 5;

    int array[size1]{ 1,3,6,2,82,10,6,34,2,5 };
    int *arb = array, *arc = &array[size2];

    for (size_t i = 0; i < size2; i++) {
        cout << arb[i] << "\t";
    }
    cout << endl;

    for (size_t i = 0; i < size2; i++) {
        cout << arc[i] << "\t";
    }
}

使用memcpy复制普通旧值类型的数组。

memcpy(arb, array, size2);
memcpy(arc, array+size2, size2);

这两个语句都替换了您的两个 for 循环。

通过在源文件的顶部声明#include <string.h>可以使用memcpy函数。