question on - delete [] ptr

[subramanian100in]

The following discussion is for learning purpose only.

1)
Suppose for a type T, I have

T *ptr = new T[100];

To free ptr, suppose I use ( I deliberately omit [] in delete.)

delete ptr;

Learner's Question:
Will this always free the first element in the allocated array and
remaining allocated memory is leaked ? Or does it invoke undefined
behaviour ?

2)
Suppose I have
size_t size = get_size();

Suppose get_size() returns zero. That is size = 0.

T *ptr = new T[size]; // zero only - this is allowed

But the question is: is it necessary to free ptr and if so what is the
correct syntax to free it ?

Is it : delete [] ptr; or just: delete ptr; ?

Kindly explain.

Thanks
V.Subramanian

[Pete Becker]

On 2007-11-22 21:58:03 -0500, "su**************@yahoo.com, India"
<su**************@yahoo.comsaid:

The following discussion is for learning purpose only.

1)
Suppose for a type T, I have

T *ptr = new T[100];

To free ptr, suppose I use ( I deliberately omit [] in delete.)

delete ptr;

Learner's Question:
Will this always free the first element in the allocated array and
remaining allocated memory is leaked ? Or does it invoke undefined
behaviour ?

The behavior is undefined. Further, when you allocate an array, there's
no way to free the first element. It's all or nothing.

>
2)
Suppose I have
size_t size = get_size();

Suppose get_size() returns zero. That is size = 0.

T *ptr = new T[size]; // zero only - this is allowed

But the question is: is it necessary to free ptr and if so what is the
correct syntax to free it ?

Is it : delete [] ptr; or just: delete ptr; ?

Whenever you use new T[whatever] you use delete[].

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[=?iso-8859-1?b?VG9t4XMg0yBoyWlsaWRoZQ==?=]

su**************@yahoo.com, India:

Suppose for a type T, I have

T *ptr = new T[100];

To free ptr, suppose I use ( I deliberately omit [] in delete.)

delete ptr;

Learner's Question:
Will this always free the first element in the allocated array and
remaining allocated memory is leaked ? Or does it invoke undefined
behaviour ?

The C++ Standard doesn't define the behaviour of what the code does
(...or doesn't do). That is to say, if the computer were to catch fire,
the Standards Committee would just shrug their shoulders and say they
made no guarantees on what would or would not happen.

Speaking of real-world-ness though, I suspect that "delete" and
"delete []" would have identical functionality on a lot of systems, i.e.
they probably just invoke "free" on a pointer they got from "malloc".

2)
Suppose I have
size_t size = get_size();

Suppose get_size() returns zero. That is size = 0.

T *ptr = new T[size]; // zero only - this is allowed

But the question is: is it necessary to free ptr and if so what is the
correct syntax to free it ?

Is it : delete [] ptr; or just: delete ptr; ?

I don't know if you "have" to free it (realistically speaking, do you
_have_ to free anything?), but you definitely always use the [] versions
together, even if you just have:

int &i = *new int[1];

delete [] &i;

I've actually had to use this before for default-initialising objects
when I don't know their type (e.g. in template programming):

Type &obj = *new Type[1]();

delete [] &obj;

--
Tomás Ó hÉilidhe

[yurec]

On Nov 27, 12:11 am, Tomás Ó hÉilidhe <[e-mail]:

[e-mail], India:

2)

Suppose I have
size_t size = get_size();

Suppose get_size() returns zero. That is size = 0.

T *ptr = new T[size]; // zero only - this is allowed

But the question is: is it necessary to free ptr and if so what is the
correct syntax to free it ?

Is it : delete [] ptr; or just: delete ptr; ?

I don't know if you "have" to free it (realistically speaking, do you
_have_ to free anything?), but you definitely always use the [] versions
together, even if you just have:

int &i = *new int[1];

delete [] &i;

I've actually had to use this before for default-initialising objects
when I don't know their type (e.g. in template programming):

Type &obj = *new Type[1]();

delete [] &obj;

--
Tomás Ó hÉilidhe

Could you explain why do you prefer such syntax?

[Richard Herring]

In message <xw*******************@news.indigo.ie>, Tomás Ó hÉilidhe
<to*@lavabit.comwrites

>su**************@yahoo.com, India:

>Suppose for a type T, I have

T *ptr = new T[100];

To free ptr, suppose I use ( I deliberately omit [] in delete.)

delete ptr;

Learner's Question:
Will this always free the first element in the allocated array and
remaining allocated memory is leaked ? Or does it invoke undefined
behaviour ?

The C++ Standard doesn't define the behaviour of what the code does
(...or doesn't do). That is to say, if the computer were to catch fire,
the Standards Committee would just shrug their shoulders and say they
made no guarantees on what would or would not happen.

Speaking of real-world-ness though, I suspect that "delete" and
"delete []" would have identical functionality on a lot of systems, i.e.
they probably just invoke "free" on a pointer they got from "malloc".

Ahem. delete[] also has to determine how many times to call ~T().

--
Richard Herring

[=?iso-8859-1?b?VG9t4XMg0yBoyWlsaWRoZQ==?=]

Could you explain why do you prefer such syntax?

I presume you're referring to my use of:

int &i = *new...

instead of:

int *pi = new...

Well, I find objects more natural to work with than pointers to objects.
I only use pointers when I'll be playing with pointer arithmetic (and a
handful other of reasons).

--
Tomás Ó hÉilidhe

[=?iso-8859-1?b?VG9t4XMg0yBoyWlsaWRoZQ==?=]

Richard Herring:

> Speaking of real-world-ness though, I suspect that "delete" and
"delete []" would have identical functionality on a lot of systems, i.e.
they probably just invoke "free" on a pointer they got from "malloc".

Ahem. delete[] also has to determine how many times to call ~T().

Wups a daisy, you're quite right.
--
Tomás Ó hÉilidhe

[James Kanze]

On Nov 26, 11:11 pm, Tomás Ó hÉilidhe <[e-mail]:

[e-mail], India:

Suppose for a type T, I have

T *ptr = new T[100];

To free ptr, suppose I use ( I deliberately omit [] in delete.)

delete ptr;

Learner's Question:
Will this always free the first element in the allocated array and
remaining allocated memory is leaked ? Or does it invoke undefined
behaviour ?

The C++ Standard doesn't define the behaviour of what the code does
(...or doesn't do). That is to say, if the computer were to catch fire,
the Standards Committee would just shrug their shoulders and say they
made no guarantees on what would or would not happen.

Speaking of real-world-ness though, I suspect that "delete" and
"delete []" would have identical functionality on a lot of systems, i.e.
they probably just invoke "free" on a pointer they got from "malloc".

Speaking of real world systems, I don't know of any where delete
ptr and delete [] ptr are identical. On most systems I use,
using the wrong one will result in problems (sometimes only for
types with non-trivial destructors).

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]