C++ – Confusing with delete and free function in C++

cdelete-operatordestructorfree

Possible Duplicate:
What is the difference between new/delete and malloc/free?

class Foo
   {
    public:
     Foo() { x =  new int; } 
     ~Foo() { delete x; }
    private:
        int *x;
   };

  Foo *p = new Foo[10];
  free ( p );

I am getting confuse with the above code.
Is there any problem about it?

Best Answer

When you call free() for an object allocated with new, its destructor is not called, so in this example you get memory leaks. Also, in this example you must use delete[] because memory is allocated with new[].

Related Solutions

C++ – What are the differences between a pointer variable and a reference variable in C++

A pointer can be re-assigned:

int x = 5;
int y = 6;
int *p;
p = &x;
p = &y;
*p = 10;
assert(x == 5);
assert(y == 10);

A reference cannot be re-bound, and must be bound at initialization:

int x = 5;
int y = 6;
int &q; // error
int &r = x;

A pointer variable has its own identity: a distinct, visible memory address that can be taken with the unary & operator and a certain amount of space that can be measured with the sizeof operator. Using those operators on a reference returns a value corresponding to whatever the reference is bound to; the reference’s own address and size are invisible. Since the reference assumes the identity of the original variable in this way, it is convenient to think of a reference as another name for the same variable.
```
int x = 0;
int &r = x;
int *p = &x;
int *p2 = &r;

assert(p == p2); // &x == &r
assert(&p != &p2);
```

You can have arbitrarily nested pointers to pointers offering extra levels of indirection. References only offer one level of indirection.

int x = 0;
int y = 0;
int *p = &x;
int *q = &y;
int **pp = &p;

**pp = 2;
pp = &q; // *pp is now q
**pp = 4;

assert(y == 4);
assert(x == 2);

A pointer can be assigned nullptr, whereas a reference must be bound to an existing object. If you try hard enough, you can bind a reference to nullptr, but this is undefined and will not behave consistently.

/* the code below is undefined; your compiler may optimise it
 * differently, emit warnings, or outright refuse to compile it */

int &r = *static_cast<int *>(nullptr);

// prints "null" under GCC 10
std::cout
    << (&r != nullptr
        ? "not null" : "null")
    << std::endl;

bool f(int &r) { return &r != nullptr; }

// prints "not null" under GCC 10
std::cout
    << (f(*static_cast<int *>(nullptr))
        ? "not null" : "null")
    << std::endl;

You can, however, have a reference to a pointer whose value is nullptr.

Pointers can iterate over an array; you can use ++ to go to the next item that a pointer is pointing to, and + 4 to go to the 5th element. This is no matter what size the object is that the pointer points to.
A pointer needs to be dereferenced with * to access the memory location it points to, whereas a reference can be used directly. A pointer to a class/struct uses -> to access its members whereas a reference uses a ..
References cannot be put into an array, whereas pointers can be (Mentioned by user @litb)
Const references can be bound to temporaries. Pointers cannot (not without some indirection):
```
const int &x = int(12); // legal C++
int *y = &int(12); // illegal to take the address of a temporary.
```
This makes const & more convenient to use in argument lists and so forth.

C++ – the difference between new/delete and malloc/free

`new` / `delete`

Allocate / release memory
1. Memory allocated from 'Free Store'.
2. Returns a fully typed pointer.
3. new (standard version) never returns a NULL (will throw on failure).
4. Are called with Type-ID (compiler calculates the size).
5. Has a version explicitly to handle arrays.
6. Reallocating (to get more space) not handled intuitively (because of copy constructor).
7. Whether they call malloc / free is implementation defined.
8. Can add a new memory allocator to deal with low memory (std::set_new_handler).
9. operator new / operator delete can be overridden legally.
10. Constructor / destructor used to initialize / destroy the object.

`malloc` / `free`

Allocate / release memory
1. Memory allocated from 'Heap'.
2. Returns a void*.
3. Returns NULL on failure.
4. Must specify the size required in bytes.
5. Allocating array requires manual calculation of space.
6. Reallocating larger chunk of memory simple (no copy constructor to worry about).
7. They will NOT call new / delete.
8. No way to splice user code into the allocation sequence to help with low memory.
9. malloc / free can NOT be overridden legally.

Table comparison of the features:

Feature	`new` / `delete`	`malloc` / `free`
Memory allocated from	'Free Store'	'Heap'
Returns	Fully typed pointer	`void*`
On failure	Throws (never returns `NULL`)	Returns `NULL`
Required size	Calculated by compiler	Must be specified in bytes
Handling arrays	Has an explicit version	Requires manual calculations
Reallocating	Not handled intuitively	Simple (no copy constructor)
Call of reverse	Implementation defined	No
Low memory cases	Can add a new memory allocator	Not handled by user code
Overridable	Yes	No
Use of constructor / destructor	Yes	No

Technically, memory allocated by new comes from the 'Free Store' while memory allocated by malloc comes from the 'Heap'. Whether these two areas are the same is an implementation detail, which is another reason that malloc and new cannot be mixed.