Using new and removing in C ++

I need help understanding when I will use the following parameters

char *a = new char();



char *a = new char[sizeof(int)+1];


and how should the corresponding memory deallocation calls be made?


source to share

5 answers

The first die allocates one char. You remove it with:

delete a;


The second selects an array of characters. The length you chose is a little odd. You free it up with:

delete[] a;


Now ... I hope you don't think you can put a string number in the second a

(something like "123456"

, because you will need many more bytes). Let's say at least 12 if int

- 32 bits. A funny formula is needed to calculate the minimum length. This is an approximation of log10 / ...

To be clear, on my machine sizeof(int)

== 4, but in int

I can put -2147483648

, which is 10 digits plus -

, so 11 (plus the null terminator)



Anytime you use new T

, you must call delete

on the resulting pointer afterwards.

Anytime you use new T[n]

, you must call delete[]

on the resulting pointer later.

And that's really all there is.

But note that you usually shouldn't use them at all.

If you need a string, don't allocate a char array. Just declare std::string

(no use new

). If you want an array that is sized at runtime, don't allocate the array. Declare std::vector

(no use new




None of the expressions you show make sense.

Also, as a general rule of thumb, never use explicit delete

(leave that for smart pointers and collections) and try to avoid using explicit new


For simple strings with elements, char

just use

std::string a;


This is an example of outputting new

-ing and delete

-ing to a library class (which is very preferable), in this case std::string


Include a title <string>

to get the type declaration std::string




char *a = new char();


This creates a pointer to one initialized one char


char *a = new char;


Creates a pointer to one uninitialized one char


char *a = new char[sizeof(int)+1];


Creates a dynamically allocated char array of size sizeof(int)+1

, i.e. uninitialized c-string of size sizeof(int)+1

. Probably 5 or 9, depending on sizeof(int)


char *a = new char[sizeof(int)+1]();


The same, but the string is initialized.

You need to explicitly free the memory with delete

for one char*

and delete[]

for an array char




One more thing to note, as well as other answers, is not to confuse the two statements: you have to know if you have allocated a pointer or an array to char* c

so that:

  • You are calling the correct delete

    / operator delete[]

    when clearing memory
  • You are not trying to access data outside the scope of the pointer.

For example, if you did this:

// Create a pointer to a single char and set the value
char* c = new char();
*c = 'a';

// Access the pointer using array syntax
char tmp1 = c[0];    // Works, returns 'a'
char tmp2 = c[1];    // Illegal!


Since there are no pointers to pointers trying to access c[1]

it will do something, but in this context it will not return what you expect, most likely it will return the memory saved after the pointer char* c

or random memory.



All Articles