How to test memory allocation with new ?

[jjleto]

Hello,

How do I handle the following :

------>
#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char(n);
if ( pp != NULL ) {
pp[0] = 0;
pp[n-1] = 0;
cout << "OK" << endl;
} else {
cout << "FAILED" << endl;
}
}
------>
It compiles OK, but when I run it, I get a segmentation fault. I thought
that testing a NULL value was enough for testing memory allocation (or
perhaps it is a bug ? I use gcc (GCC) 3.3.4)

Regards,
jjleto

[Sharad Kala]

"jjleto" <jj****@laposte.net> wrote in message

Hello,

How do I handle the following :

------>
#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char(n);
This does not do what you are thinking. It allocates memory for one char and
tries to initialize it with 0x7FFFFFFF. To allocate an array use -
char *pp = new char[...];
if ( pp != NULL ) {
This is a big misconception that new returns NULL on failure. The fact is
that it throws std::bad_alloc exception on failure (unless you specify
nothrow)
pp[0] = 0;
pp[n-1] = 0;
This is the cause of your segmentation fault. You are trying to write to an
illegal memory location.
cout << "OK" << endl;
} else {
cout << "FAILED" << endl;
}
}

Sharad

[jjleto]

> char *pp = new char[...];

Thanks, the segmentation fault was actually for the reason you gave.

Nevertheless, I still have an error when running this program ("give up"
but not a segfault)

#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char[n];
if ( pp != NULL ) {
pp[0] = 0;
pp[n-1] = 0;
cout << "OK" << endl;
} else {
cout << "FAILED" << endl;
}
}

How do I test memory allocation with new ?

[Sharad Kala]

"jjleto" <jj****@laposte.net> wrote in message

char *pp = new char[...];

Thanks, the segmentation fault was actually for the reason you gave.

Nevertheless, I still have an error when running this program ("give up"
but not a segfault)

How do I test memory allocation with new ?

I told you in my earlier reply too that new throws std::bad_alloc on
exception. You need to wrap the new in a try-catch block (catching
std::bad_alloc).

Sharad

[Sharad Kala]

"Sharad Kala" <no*****************@yahoo.com> wrote in message

"jjleto" <jj****@laposte.net> wrote in message

char *pp = new char[...];

Thanks, the segmentation fault was actually for the reason you gave.

Nevertheless, I still have an error when running this program ("give up"
but not a segfault)

How do I test memory allocation with new ?

I told you in my earlier reply too that new throws std::bad_alloc on
exception. You need to wrap the new in a try-catch block (catching
std::bad_alloc).

Something like -
try{
char *pp = new char[n];
//...
}
catch(std::bad_alloc)
{
cout << "New failed";
}

Sharad

[Shailesh Humbad]

Sharad Kala wrote:

"Sharad Kala" <no*****************@yahoo.com> wrote in message

"jjleto" <jj****@laposte.net> wrote in message

char *pp = new char[...];

Thanks, the segmentation fault was actually for the reason you gave.

Nevertheless, I still have an error when running this program ("give up"
but not a segfault)

How do I test memory allocation with new ?

I told you in my earlier reply too that new throws std::bad_alloc on
exception. You need to wrap the new in a try-catch block (catching
std::bad_alloc).

Something like -
try{
char *pp = new char[n];
//...
}
catch(std::bad_alloc)
{
cout << "New failed";
}

Sharad

Note for those using MS VC++ (5.0 or higher), it has a bug in the
implementation of new where it doesn't throw the std::bad_alloc
exception on failure. I just found this out when I tried your example.

http://support.microsoft.com/?kbid=167733

[Sharad Kala]

"Shailesh Humbad" <no*****@nowhere.com> wrote in message

Something like -
try{
char *pp = new char[n];
//...
}
catch(std::bad_alloc)
{
cout << "New failed";
}

Sharad

Note for those using MS VC++ (5.0 or higher), it has a bug in the
implementation of new where it doesn't throw the std::bad_alloc
exception on failure. I just found this out when I tried your example.

Well there was no Standard formally in place in the time of MS VC 6.0
(that's 1997) and its ancestors. So one can't actually blame the compilers
for being non-conformant.

Sharad

[Cosmin Calinescu]

If you have less then 2G of memory you're scrued. I don't think you do
what you intend to do.

jjleto wrote:

Hello,

How do I handle the following :

------>
#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char(n);
if ( pp != NULL ) {
pp[0] = 0;
pp[n-1] = 0;
cout << "OK" << endl;
} else {
cout << "FAILED" << endl;
}
}
------>
It compiles OK, but when I run it, I get a segmentation fault. I thought
that testing a NULL value was enough for testing memory allocation (or
perhaps it is a bug ? I use gcc (GCC) 3.3.4)

Regards,
jjleto

[Ulrich Lauther]

In gnu.g++.help Sharad Kala <no*****************@yahoo.com> wrote:

: > I told you in my earlier reply too that new throws std::bad_alloc on
: > exception. You need to wrap the new in a try-catch block (catching
: > std::bad_alloc).

: Something like -
: try{
: char *pp = new char[n];
: //...
: }
: catch(std::bad_alloc)
: {
: cout << "New failed";
: }

: Sharad
or else:

char* pp = new(nothrow) char[n];
if (! pp) { // new failed
// do something
}

--
-lauther

[nosave]
----------------------------------------------------------------------------
Ulrich Lauther ph: [phone] fx: ... 636 42284
Siemens CT SE 6 Internet: Ul************@siemens.com

[Larry I Smith]

jjleto wrote:

Hello,

How do I handle the following :

------>
#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char(n);
if ( pp != NULL ) {
pp[0] = 0;
pp[n-1] = 0;
cout << "OK" << endl;
} else {
cout << "FAILED" << endl;
}
}
------>
It compiles OK, but when I run it, I get a segmentation fault. I thought
that testing a NULL value was enough for testing memory allocation (or
perhaps it is a bug ? I use gcc (GCC) 3.3.4)

Regards,
jjleto

#include <iostream>
using namespace std;

int main()
{
char * pp;

// given this value, 'new' will fail if less than 2GB of free RAM
// is available
int n = 0x7FFFFFFF;

try
{
cout << "Allocate an array of " << n << " bytes in RAM" << endl;
pp = new char[n];
}
catch (bad_alloc)
{
cout << "Allocation Attempt Failed" << endl;
return 1;
}

pp[0] = 0;
pp[n - 1] = 0;
cout << "OK" << endl;

delete[] pp; // free the allocated array

return 0;
}

Regards,
Larry

--
Anti-spam address, change each 'X' to '.' to reply directly.

[David Lindauer]

what is the syntax for specifying nothrow?

Thanks,

David

Sharad Kala wrote:

"jjleto" <jj****@laposte.net> wrote in message

Hello,

How do I handle the following :

------>
#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char(n);

This does not do what you are thinking. It allocates memory for one char and
tries to initialize it with 0x7FFFFFFF. To allocate an array use -
char *pp = new char[...];

if ( pp != NULL ) {

This is a big misconception that new returns NULL on failure. The fact is
that it throws std::bad_alloc exception on failure (unless you specify
nothrow)

pp[0] = 0;
pp[n-1] = 0;

This is the cause of your segmentation fault. You are trying to write to an
illegal memory location.

cout << "OK" << endl;
} else {
cout << "FAILED" << endl;
}
}

Sharad

[Old Wolf]

Cosmin Calinescu <co*****@nortelnetworks.com> wrote:

If you have less then 2G of memory you're scrued. I don't think you do
what you intend to do.

int n = 0x7FFFFFFF;
char *pp = new char[n];

Many operating systems have "lazy allocation", they will honour
this request but then swap maniacally or kill the application
when it tries to actually use that memory.

[Method Man]

"Sharad Kala" <no*****************@yahoo.com> wrote in message
news:2u*************@uni-berlin.de...

"jjleto" <jj****@laposte.net> wrote in message

Hello,

How do I handle the following :

------>
#include <iostream>
using namespace std;

int main()
{
int n = 0x7FFFFFFF;
char *pp = new char(n);
This does not do what you are thinking. It allocates memory for one char

and tries to initialize it with 0x7FFFFFFF. To allocate an array use -
char *pp = new char[...];

if ( pp != NULL ) {
This is a big misconception that new returns NULL on failure. The fact is
that it throws std::bad_alloc exception on failure (unless you specify
nothrow)

pp[0] = 0;
pp[n-1] = 0;

This is the cause of your segmentation fault. You are trying to write to

an illegal memory location.

Do you mean both statements are problematic? Shouldn't 'pp[0] = 0' be OK
since it is equivalent to *pp = 0 (assigning the allocated char the null
value)?

[Sharad Kala]

"Method Man" <a@b.c> wrote in message

Do you mean both statements are problematic? Shouldn't 'pp[0] = 0' be OK
since it is equivalent to *pp = 0 (assigning the allocated char the null
value)?

No, only pp[1] is problematic. This gets evaluated to *(pp + 1), pp [0] as
you point out is same as *pp.

Sharad