Member 14771149 Ответов: 4

C++ передача динамических массивов в функции


Как написать функцию, которая берет динамический массив из main и создает 2 массива, 1 для положительных значений и другой для отрицательных, и возвращает два массива в main?

это то, что я пробовал:

Что я уже пробовал:

#include <iostream>
using namespace std;
void PosNegArr(int* arr, int s, int* p, int* n, int cp, int cn) {

    for (int i = 0; i < s; i++) {
        if (arr[i] < 0) {
            arr[i] = n[i];
        }
        else {
            arr[i] = p[i];
        }
    }
}

int main() {
    int s, c1, c2;

    cout << "Enter number of elements:";
    cin >> s;
    int* A = new int[s];
    cout << "Enter the elements:";
    for (int i = 0; i < s; i++) {
        cin >> A[i];
    }
    for (int i = 0; i < s; i++) {
        if (A[i] < 0) {
            c2++;
        }
        else {
            c1++;
        }
    }
   int* p = new int[c1];
    int* n = new int[c2];
   
    PosNegArr(A, s, p, n, c1, c2);
    cout << "positive elements are :" << endl;
    for (int i = 0; i < c1; i++) {
        cout << p[i] << ' ' << endl;
    }
    cout << "Negative elements are:" << endl;
    for (int i = 0; i < c2; i++) {
        cout << n[i] << ' ' << endl;
    }
}

4 Ответов

Рейтинг:
7

John R. Shaw

Учитывая, что он/она действительно предоставляет достаточно информации для решения проблемы, я оставлю ее там.

Остановитесь и подумайте о проблеме. Аргументы для "PosNetarr" не являются произвольными, они встречаются для использования. Что вы делаете с аргументом/параметрами? Насколько я понимаю, ничего. Вы, предполагают, чтобы быть скопировав их на 'P' и 'N' не оригинал 'Арр'. Лимиты на 'Р' 'СР' (отсчет длины P) и 'спицы' (отсчет длины n). Предполагается, что вы копируете элементы из 'Arr' в 'p' и 'n', а не наоборот.

У меня было искушение предложить решение, но я оставлю это на ваше усмотрение.

Подсказка:

if (arr[i] < 0 && n_index < cn)
{
    n[n_index++] = arr[i];
}


Рейтинг:
31

Richard MacCutchan

В инструкциях говорится, что функция должна создавать новые массивы и возвращать их вызывающему объекту. Поэтому вам нужно что-то вроде:

void PosNegArr(int* source, int size, int** newpos, int** newneg)
{
    int* positives = new int[size];
    int* negatives = new int[size];
    memset(positives, 0, size);
    memset(negatives, 0, size);

    for (int i = 0; i < size; i++)
    {
        if (source[i] < 0)
        {
            negatives[i] = source[i];
        }
        else
        {
            positives[i] = source[i];
        }
    }
    *newpos = positives;
    *newneg = negatives;
}


Тогда вы можете назвать это так:
int* positiveList;
int* negativeList;

// collect input values ...

PosNegArr(array, countize, &positiveList, &negativeList)

// on return the two arrays will be populated with the numbers


Member 14771149

Я не понимаю, как вы дали 2 новым массивам тот же размер основного массива.
также при печати 2 массивов в основном мы используем цикл for, каков размер каждого из них.
и большое вам спасибо за то, что уделили мне время.

Richard MacCutchan

Новые массивы должны быть достаточно большими, чтобы вместить все существующие числа, потому что все они могут быть положительными или отрицательными. После их создания они устанавливаются равными нулю, поэтому будут добавлены только ненулевые числа (хотя эта проверка должна быть добавлена во входной цикл). Для печати массива вам просто нужно использовать исходное количество элементов и цикл до тех пор, пока это количество не будет достигнуто или не будет найдено нулевое значение.

Рейтинг:
2

CPallini

Ричард уже дал тебе решение. Во всяком случае, немного современного C++ стоило бы посмотреть.

#include <iostream>
#include <vector>
#include <tuple>
#include <algorithm>

using namespace std;

tuple < vector <int>, vector <int> > pos_neg(const vector<int> & v );

int main()
{
  size_t count;
  cout << "Enter number of elements: ";
  cin >> count;
  vector <int > v(count);
  for (size_t n=0; n<count; ++n)
  {
    cin >> v[n];
  }

  auto  [vp, vn] = pos_neg(v);

  cout << "non-negative: ";
  for (const auto & x : vp)
    cout << x << " ";
  cout << "\n";

  cout << "negative: ";
  for (const auto & x : vn)
    cout << x << " ";
  cout << "\n";
}


tuple < vector <int>, vector <int> >  pos_neg(const vector<int> & v )
{
  vector <int> vpos, vneg;
  for_each( v.begin(), v.end(), [&vpos, &vneg](int i){ i < 0 ? vneg.push_back(i) : vpos.push_back(i); } );
  return make_tuple(vpos, vneg);
}


Richard MacCutchan

Круто!

Рейтинг:
1

Patrice T

Метод проб и ошибок-это метод обучения, при котором вы учитесь на своих ошибках.
Отладчик-это инструмент, который позволяет вам шаг за шагом видеть, что делает ваш код.

Ваш код ведет себя не так, как вы ожидаете, или вы не понимаете, почему !

Существует почти универсальное решение: запускайте свой код на отладчике шаг за шагом, проверяйте переменные.
Отладчик здесь, чтобы показать вам, что делает ваш код, и ваша задача-сравнить с тем, что он должен делать.
В отладчике нет никакой магии, он не знает, что должен делать ваш код, он не находит ошибок, он просто помогает вам, показывая, что происходит. Когда код не делает того, что ожидается, вы близки к ошибке.
Чтобы увидеть, что делает ваш код: просто установите точку останова и посмотрите, как работает ваш код, отладчик позволит вам выполнять строки 1 на 1 и проверять переменные по мере их выполнения.

Отладчик - Википедия, свободная энциклопедия[^]

Освоение отладки в Visual Studio 2010 - руководство для начинающих[^]
Базовая отладка с помощью Visual Studio 2010 - YouTube[^]

1.11 — отладка программы (пошаговое выполнение и останова) | выучить C++[^]

Отладчик здесь только для того, чтобы показать вам, что делает ваш код, и ваша задача-сравнить его с тем, что он должен делать.
[Обновление]

Цитата:
Как написать функцию, которая берет динамический массив из main и создает 2 массива, 1 для положительных значений и другой для отрицательных, и возвращает два массива в main?

Всего лишь небольшое письмо должно было дать вам ключ к разгадке:
a[0]=1  => p[0]=1
a[1]=0  => p[1]=0
a[2]=-1 => n[0]=-1
a[3]=3  => p[2]=3
a[4]=-3 => n[1]=-3
a[5]=1  => p[3]=1

очевидно, что вам нужно 3 индекса для a, p и n.