Как правильно создать динамический массив unique_ptr в C ++ 11? - PullRequest
Новая
       30

Как правильно создать динамический массив unique_ptr в C ++ 11?

0 голосов
/ 07 апреля 2019

Я хотел бы определить канонический подход к выделению эквивалента массива указателей для указателей на int (например: int ** int_array), но с использованием unique_ptr.

Мне бы хотелось, чтобы решение на C ++ 11 было расширяемым для массива указателей на указатели на экземпляр класса, если это возможно (я использовал здесь int для упрощения, и я понимаю, что могут возникнуть другие проблемы, когда используя экземпляры классов).

Я понимаю, как создать массив unique_ptr фиксированного размера, размер которого известен заранее. Цель состоит в том, чтобы сделать то же самое, когда размер массива неизвестен.

Я рассмотрел ряд связанных решений, включая приведенное ниже, но, похоже, они имеют дело только с фиксированным распределением массивов unique_ptr (то есть размер массива unique_ptr уже известен заранее):

Правильный способ создания unique_ptr, который содержит выделенный массив

Я реализовал простую программу, которая пытается продемонстрировать и сравнить 3 подхода: традиционные динамические создания указателей, фиксированный массив unique_ptr и цель: динамический массив unique_ptr. 

#include <iostream> // include iostream
#include <memory> // include memory

using namespace std;

int main() {

  cout << "Testing dynamic arrays of pointers\n";

  int **num_array; // typical dynamic array of pointers to int
  int count;       // count of ints the user wants to generate

  unique_ptr<int[]> f_num_array(new int[200]()); 
       // above: fixed array of unique pointers to int - not what I want

  unique_ptr<int[]> u_num_array; 
       // above:  GOAL: dynamic array of unique pointers to int

  int sum, u_sum, f_sum; 
       // above: test sum of each type of array (should match user count)

  cout << "How many pointers would you like? ";

  cin >> count; // get user input

  num_array = new int*[count]; // allocate array of pointers on heap

  //u_num_array = new int[count](); // GOAL - would like to do this
       // above: ERROR: no overload for =; cannot allocate this way

  for(int i=0; i<count; i++) { // allocate ints and store pointer
    num_array[i] = new int(1); // pointer to an int on the heap 
    f_num_array[i] = 1; // assign 1 to the pre-allocated unique pointer array

    unique_ptr<int> u_tmp(new int(1)); // temporary unique_ptr to int
    // u_num_array[i] = u_tmp; // GOAL - would like to do this...
        // ERROR: cannot assign unique_ptr this way
  }

  sum = 0; f_sum = 0; u_sum = 0; // init our sums to verify

  for(int i=0; i<count; i++){
    sum += *(num_array[i]); // summing our traditional array of pointers
    f_sum += f_num_array[i]; // summing our fixed unique array of pointers
  }

  cout << "Sum = " << sum << "\n";
  cout << "Sum (fixed unique_ptr array) = " << f_sum << "\n";
  cout << "Sum (dynamic unique_ptr array) = " << u_sum << "\n";

  delete[] num_array; // delete the dynamic array
  f_num_array.release();  // delete the dynamic array

  cout << "\nDone!\n"; 

}

1 Ответ

3 голосов
/ 07 апреля 2019 
#include <iostream>
#include <memory>
#include <vector>

int main() {

  std::cout << "Testing dynamic arrays of pointers\n";

  //int **num_array; - Never use except you are forced by some external interface.
  int count = 0; // Always initialize variables

  std::vector<std::unique_ptr<int>> num_array; 

  std::cout << "How many pointers would you like? ";

  std::cin >> count; // get user input

  num_array.resize(count);
  for (auto& p : num_array) // You can do it with some algorithm, but I prefer this way
    p = std::make_unique<int>(1);

  int sum = 0; // Don't declare variables before you use them.
  for (auto& p : num_array)
    sum += *p;

  std::cout << "Sum = " << sum << "\n";

  num_array.clear();

  std::cout << "\nDone!\n"; 

}
...