C++ 将数组拆分为单独的正数组和负数组c++；

我需要编写一个函数，它接受一个给定的数组，然后将它拆分为两个单独的数组，其中一个数组的元素是主数组的正元素，另一个数组的元素是主数组的负元素。我似乎不知道这个循环会是什么样子

我编写了一个单独的函数来确定主数组中有多少正值和负值：

void count(int ARRAY[], int SIZE, int&NEG, int&POS)
{

  for (int x=0; x<SIZE; x++)
    {
      if(ARRAY[x]>=0)
      {
      POS=POS+1 ;
      }
      if(ARRAY[x]<0)
      {
      NEG=NEG+1 ;
      }
    }
}

我只是不知道如何将主数组中的每个正元素设置为新的仅正数组中的元素，同样地，也不知道如何设置负数组中的元素

谢谢你的帮助

在使用给出的答案并尽我所能处理其余的代码之后，我在试图编译它时遇到了大约一百万行错误。我如何删除三个动态分配的数组是否有问题？什么样的巨大错误阻止了编译？ 这是我的密码：

#include <iostream>
using namespace std;


void count(int ARRAY[], int SIZE, int&NEG, int&POS);
void split(int ARRAY[], int SIZE, int&NEG_ARRAY, int NEG, int&POS_ARRAY, int POS);
void print_array(int ARRAY[], int SIZE);


int main()
{

  int SIZE (0);
  int * ARRAY ;

  cout<<"Enter number of elements: " ;
  cin>> SIZE ;

  ARRAY = new int[SIZE] ;
  int x(0);
  int numEle(0);

  cout<<"Enter list: " <<endl;

  while(numEle<SIZE)
    {
      ARRAY[numEle] = x ;
      numEle++;
      cin>>x;
    }

  int POS(0), NEG(0) ;
  count(ARRAY, SIZE, NEG, POS) ;

  int * NEG_ARRAY;
  NEG_ARRAY = new int[NEG];

  int * POS_ARRAY;
  POS_ARRAY = new int[POS];


  split(ARRAY, SIZE, NEG_ARRAY, NEG, POS_ARRAY, POS) ;

  cout<<"Negative elements: "<<endl;
  cout<<print_array(NEG_ARRAY, NEG) <<endl;

  cout<<"Non-negative elements: "<<endl;
  cout<<print_array(POS_ARRAY, POS)<<endl;


  delete[] ARRAY;
  delete[] NEG_ARRAY;
  delete[] POS_ARRAY;

  return 0;
}



void count(int ARRAY[], int SIZE, int&NEG, int&POS)
{

  for (int x=0; x<SIZE; x++)
    {
      if(ARRAY[x]>=0)
      {
      POS=POS+1 ;
      }
      if(ARRAY[x]<0)
      {
      NEG=NEG+1 ;
      }
    }
}

void split(int ARRAY[], int SIZE, int&NEG_ARRAY, int NEG, int&POS_ARRAY, int POS)
{

  NEG=POS=0;
  for(int x=0; x<SIZE; x++)
    {
      if(ARRAY[x]<0)
    { NEG_ARRAY[NEG++]=ARRAY[x]; }
      else {POS_ARRAY[POS++]=ARRAY[x]; }

    }
}

void print_array(int ARRAY[], int SIZE)
{

  for(int i=0; i<SIZE; i++)
    {

      cout << ARRAY[i] << " " ;
    }
  cout<<endl;
}

#包括
使用名称空间std；
无效计数（整数数组[]，整数大小，整数和负数，整数和负数）；
无效分割（整数数组[]，整数大小，整数和负数组，整数和负数组，整数和正数组，整数和正数组）；
无效打印_数组（int数组[]，int大小）；
int main（）
{
整数大小（0）；
int*数组；
cout大小；
数组=新整数[大小]；
int x（0）；
整数（0）；
cout很容易修改您的
count（）
函数：

void split(int ARRAY[], int SIZE, int NEG [], int POS [])
{
  int ncount = 0, pcount = 0;
  for (int x=0; x<SIZE; x++)
    {
      if(ARRAY[x]>=0)
      {
          POS[pcount++] = ARRAY[x];
      }
      if(ARRAY[x]<0)
      {
          NEG[ncount++] = ARRAY[x];
      }
    }
}

void拆分（整数数组[]，整数大小，整数负[]，整数位[]）
{
int ncount=0，pcount=0；
对于（int x=0；x=0）
{
POS[pcount++]=数组[x]；
}
如果（数组[x]很容易修改
count（）
函数：

void split(int ARRAY[], int SIZE, int NEG [], int POS [])
{
  int ncount = 0, pcount = 0;
  for (int x=0; x<SIZE; x++)
    {
      if(ARRAY[x]>=0)
      {
          POS[pcount++] = ARRAY[x];
      }
      if(ARRAY[x]<0)
      {
          NEG[ncount++] = ARRAY[x];
      }
    }
}

void拆分（整数数组[]，整数大小，整数负[]，整数位[]）
{
int ncount=0，pcount=0；
对于（int x=0；x=0）
{
POS[pcount++]=数组[x]；
}
如果（数组[x]，您可能会得到一些C风格的答案

但这里我将如何使用STL算法，因为这是为
C++

使用

此外，您还应该为此类操作使用

演示
您可能会得到一些C风格的答案

但这里我将如何使用STL算法，因为这是为
C++

使用

此外，您还应该为此类操作使用

演示
此代码将负数和正数分成不同的数组

void split(int ARRAY[], int SIZE, int NEG_ARRAY[], int&NEG, int POS_ARRAY[], int&POS)
{
    NEG=POS=0;
    for (int i(0); i<SIZE; i++)
    {
        if (ARRAY[i]<0) NEG_ARRAY[NEG++]=ARRAY[i];
        else POS_ARRAY[POS++]=ARRAY[i];
    }
}

void split（int数组[]，int大小，int负数组[]，int&NEG，int POS_数组[]，int&POS）
{
负=正=0；
对于（int i（0）；i此代码将负数和正数划分为单独的数组

void split(int ARRAY[], int SIZE, int NEG_ARRAY[], int&NEG, int POS_ARRAY[], int&POS)
{
    NEG=POS=0;
    for (int i(0); i<SIZE; i++)
    {
        if (ARRAY[i]<0) NEG_ARRAY[NEG++]=ARRAY[i];
        else POS_ARRAY[POS++]=ARRAY[i];
    }
}

void split（int数组[]，int大小，int负数组[]，int&NEG，int POS_数组[]，int&POS）
{
负=正=0；
对于（int i（0）；i关于零是什么？它们应该属于哪一边？是否有理由使用原始数组而不是像
std:：vector
？为什么输入数组
int数组[]
，而负和正
int&
？是“正”和“负”数组被认为是预先存在的，或者这个函数必须为它们分配空间吗？我发布了我的全部代码。它不会编译，并且给了我一个荒谬的错误量。零呢？它们应该属于哪一边？是否有理由使用原始数组而不是像
std:：vector
这样的更高级别的构造？为什么输入数组
int数组[]
，但是负的和正的
int&
？是“正的”和“负的”数组被认为是预先存在的，或者这个函数必须为它们分配空间吗？我发布了我的全部代码。它不会编译，并且会给我带来大量的错误。非常灵活，但是对于像OP这样的初学者来说非常高级。非常灵活，但是对于像OP这样的初学者来说非常高级。