Define array, then change its size

you want to use std::vector in most cases.

std::vector<int> array;

array.resize(someSize);

But if you insist on using new, then you have do to a bit more work than you do in Java.

int *array;
array = new int[someSize];

// then, later when you're done with array

delete [] array;

No c++ runtimes come with garbage collection by default, so the delete[] is required to avoid leaking memory. You can get the best of both worlds using a smart pointer type, but really, just use std::vector.

Best way would be for you to use a std::vector. It does all you want and is easy to use and learn. Also, since this is C++, you should use a vector instead of an array. Here is an excellent reason as to why you should use a container class (a vector) instead of an array.

Vectors are dynamic in size and grow as you need them - just what you want.

The exact answer:

char * array = new char[64]; // 64-byte array

// New array
delete[] array;
array = new char[64];

std::vector is a much better choice in most cases, however. It does what you need without the manual delete and new commands.

As others have mentioned, std::vector is generally the way to go. The reason is that vector is very well understood, it's standardized across compilers and platforms, and above all it shields the programmer from the difficulties of manually managing memory. Moreover, vector elements are required to be allocated sequentially (i.e., vector elements A, B, C will appear in continuous memory in the same order as they were pushed into the vector). This should make the vector as cache-friendly as a regular dynamically allocated array.

While the same end result could definitely be accomplished by declaring a pointer to int and manually managing the memory, that would mean extra work:

1. Every time you need more memory, you must manually allocate it
2. You must be very careful to delete any previously allocated memory before assigning a new value to the pointer, lest you'll be stuck with huge memory leaks

3. Unlike std::vector, this approach is not RAII-friendly. Consider the following example:

   void function()
   {
       int* array = new int[32];
       char* somethingElse = new char[10];
       // Do something useful.... No returns here, just one code path.
       delete[] array;
       delete[] somethingElse;
   }
   

It looks safe and sound. But it isn't. What if, upon attempting to allocate 10 bytes for "somethingElse", the system runs out of memory? An exception of type std::bad_alloc will be thrown, which will start unwinding the stack looking for an exception handler, skipping the delete statements at the end of the function. You have a memory leak. That is but one of many reasons to avoid manually managing memory in C++. To remedy this (if you really, really want to), the Boost library provides a bunch of nice RAII wrappers, such as scoped_array and scoped_ptr.

use std::array when size is known at compile time otherwise use std::vector

#include <array>
constexpr int someSize = 10;
std::array<int, someSize> array;

or

#include <vector>
std::vector<int> array;  //size = 0
array.resize(someSize);  //size = someSize

Declare a pointer:

int * array;