So erstellen Sie ein dynamisches Array von Ganzzahlen

So erstellen Sie ein dynamisches Array von Ganzzahlen in C++ mit der new Stichwort?

int main()
{
  int size;

  std::cin >> size;

  int *array = new int[size];

  delete [] array;

  return 0;
}

Vergiss es nicht delete jedes Array, mit dem Sie zuweisen new.

Seit C++11 gibt es eine sichere Alternative zu new[] und delete[] was im Gegensatz zu Null-Overhead ist std::vector:

std::unique_ptr<int[]> array(new int[size]);

In C++14:

auto array = std::make_unique<int[]>(size);

Beides stützt sich auf die gleiche Header-Datei, #include <memory>

Vielleicht möchten Sie die Verwendung der Standard-Vorlagenbibliothek in Betracht ziehen. Es ist einfach und leicht zu bedienen, und Sie müssen sich keine Gedanken über Speicherzuweisungen machen.

http://www.cplusplus.com/reference/stl/vector/vector/

int size = 5;                    // declare the size of the vector
vector<int> myvector(size, 0);   // create a vector to hold "size" int's
                                 // all initialized to zero
myvector[0] = 1234;              // assign values like a c++ array

int* array = new int[size];

Sobald es um dynamische Arrays geht, möchten Sie möglicherweise nicht nur Arrays mit variabler Größe erstellen, sondern auch deren Größe während der Laufzeit ändern. Hier ein Beispiel mit memcpykönnen Sie verwenden memcpy_s oder std::copy auch. Je nach Compiler, <memory.h> oder <string.h> wird vielleicht benötigt. Bei Verwendung dieser Funktionen weisen Sie einen neuen Speicherbereich zu, kopieren Werte von ursprünglichen Speicherbereichen dorthin und geben sie dann frei.

//    create desired array dynamically
size_t length;
length = 100; //for example
int *array = new int[length];

//   now let's change is's size - e.g. add 50 new elements
size_t added = 50;
int *added_array = new int[added];

/*   
somehow set values to given arrays
*/ 

//    add elements to array
int* temp = new int[length + added];
memcpy(temp, array, length * sizeof(int));
memcpy(temp + length, added_array, added * sizeof(int));
delete[] array;
array = temp;

Sie können stattdessen die Konstante 4 verwenden sizeof(int).

Weisen Sie dynamisch etwas Speicher zu new:

int* array = new int[SIZE];

Die obigen Antworten sind alle gut für die Zuweisung eindimensionaler Int-Arrays. Wie auch immer, ich möchte hinzufügen, dass dies auch für mehrdimensionale Arrays möglich ist, die Sie normalerweise so definieren würden int[][] matrix = {{1,2}, {3,4}}.

Der Schlüssel ist, dass Sie alle Elemente dynamisch in einem Array speichern und die Tatsache nutzen, dass das Array ein kontinuierlicher Block im Speicher ist (siehe hier für eine Erläuterung von “Block”), was bedeutet, dass Sie sich selbst durch Dimensionen “schneiden” können. Unten sehen Sie ein Beispiel für ein 2d-Array.

Eine Diskussion zu diesem Thema finden Sie hier auf SO.

/*Defining a 2d-matrix.*/
struct Matrix {

    int rows, columns;
    int* matrix;

    Matrix(int rows, int columns) : rows(rows), columns(columns) {
        // Keep in mind that arrays cannot be generated during runtime
        // since the compiler needs to know the size to allocate in memory.
        // Thus, use dynamic memory and keep in mind to delete it!

        // This only uses a single array since "new" cannot create 
        // multidimensional arrays by default. Thus, everything is
        // written in a single memory-block and accessed via getElement().
        matrix = new int[columns * rows];
    }

    ~Matrix() {
        // Release the memory after destroying the Matrix-object
        delete matrix;
    }

    /*Access the element at position [r]ow and [c]olumn.*/
    int getElement(int r, int c) {
        // matrix[c][r] is rewritten as matrix[column + columns * rows] 
        // -> matrix <=> Single memory block
        return matrix[c + columns * r];
    }

    /*Set the element at position [r]ow and [c]olumn with given [val]ue.*/
    void setElement(int r, int c, int val) {
        matrix[c + columns * r] = val;
    }
};

Ein Beispiel zum Befüllen einer solchen Matrix-Objekt wäre:

    /*Initialize the matrix with the continuous numbers 0..N*/
    void Matrix::initDummyMatrix(){
        int counter = 0;
        for (int row = 0; row < rows; ++row) {
            for (int col = 0; col < columns; ++col) {
                setElement(row, col, counter++);
            }
        }
    }