forcing new to fail (or throw an exception)

[H.S.]

Hello,

Here is a little question. I was reading up on the FAQ on pointers:
http://www.parashift.com/c++-faq-lit....html#faq-16.6

and wanted to see what g++ (ver. 4.1.3) does if it cannot allocate
enough memory by trying to allocating huge amount. Here is what I am trying:
int main(){
double *ldP;
ldP = new double [2048*2048*2048];

delete ldP;
return 0;
}

It compiles okay. It runs okay too.

What am I missing here? How can I try to allocate memory huge enough
that new throws an exception?

thanks,
->HS

[Victor Bazarov]

H.S. wrote:

Hello,

Here is a little question. I was reading up on the FAQ on pointers:
http://www.parashift.com/c++-faq-lit....html#faq-16.6

and wanted to see what g++ (ver. 4.1.3) does if it cannot allocate
enough memory by trying to allocating huge amount. Here is what I am
trying: int main(){
double *ldP;
ldP = new double [2048*2048*2048];

Try

size_t s = 2048*2048*2048;
std::cout << "About to allocate " << s << " doubles" << std::endl;
double ldP = new double[s];

>
delete ldP;

Should be

delete[] ldP;

return 0;
}

It compiles okay. It runs okay too.

What am I missing here? How can I try to allocate memory huge enough
that new throws an exception?

Hard to say. Your program (due to wrong 'delete') had undefined
behaviour. Try fixing it.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[H.S.]

Victor Bazarov wrote:

H.S. wrote:

>Hello,

Here is a little question. I was reading up on the FAQ on pointers:
http://www.parashift.com/c++-faq-lit....html#faq-16.6

and wanted to see what g++ (ver. 4.1.3) does if it cannot allocate
enough memory by trying to allocating huge amount. Here is what I am
trying: int main(){
double *ldP;
ldP = new double [2048*2048*2048];

Try

size_t s = 2048*2048*2048;

which generates:
$g++ -o testmem testmem.cc
testmem.cc: In function ‘int main()’:
testmem.cc:5: warning: overflow in implicit constant conversion
$./testmem
About to allocate 0 doubles

std::cout << "About to allocate " << s << " doubles" << std::endl;
double ldP = new double[s];

> delete ldP;

Should be

delete[] ldP;

Thanks for the correction.

> return 0;
}

It compiles okay. It runs okay too.

What am I missing here? How can I try to allocate memory huge enough
that new throws an exception?

Hard to say. Your program (due to wrong 'delete') had undefined
behaviour. Try fixing it.

So after removing my mistakes, and correcting the one in your code (sort
of), here is what throws the exception (this is on a Debian Testing
kernel, 2.6.21, since max memory allocation depends on the kernel
options(?)):

#include <iostream>
int main(){
double *ldP;
size_t s = 2048*2048*58;
std::cout << "About to allocate " << s << " doubles" << std::endl;
ldP = new double [s];

delete [] ldP;
return 0;
}

$g++ -o testmem testmem.cc
$./testmem
About to allocate 243269632 doubles
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted

thanks,
->HS

[BobR]

H.S. <hs**************@gmail.comwrote in message...

>
#include <iostream>
int main(){

// double *ldP;

size_t s = 2048*2048*58;
std::cout << "About to allocate " << s << " doubles" << std::endl;

// ldP = new double [s];
double *ldP( new double[ s ] );

delete [] ldP;
return 0;
}

$g++ -o testmem testmem.cc
$./testmem
About to allocate 243269632 doubles
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Aborted

thanks,
->HS

FYI: When you want a BIG number, try this:

// std::size_t big(-1); // compiler 'warning', but usually works (a)
int bigint(-1);
std::size_t big( bigint );
// #include <limits>
std::size_t big2( std::numeric_limits<std::size_t>::max() );

std::cout<<"size_t big()="<<big<<std::endl;
std::cout<<"size_t big2()="<<big2<<std::endl;

// out: size_t big()=4294967295
// out: size_t big2()=4294967295

Of course the '-1' trick (a) only works on 'unsigned' types
(, and may be UB on some systems (?)).
Use the 'numeric_limits<>' version.

--
Bob R
POVrookie

[Robert Bauck Hamar]

BobR wrote:

FYI: When you want a BIG number, try this:

// std::size_t big(-1); // compiler 'warning', but usually works (a)
int bigint(-1);
std::size_t big( bigint );
// #include <limits>
std::size_t big2( std::numeric_limits<std::size_t>::max() );

std::cout<<"size_t big()="<<big<<std::endl;
std::cout<<"size_t big2()="<<big2<<std::endl;

// out: size_t big()=4294967295
// out: size_t big2()=4294967295

Of course the '-1' trick (a) only works on 'unsigned' types
(, and may be UB on some systems (?)).

No, it's well defined. The result should be the least unsigned integer
congruent to -1 modulo 2**N (where ** means power, and N is the number of
bits in std::size_t), and that would be 2**N - 1.

Use the 'numeric_limits<>' version.

The numeric_limits<version also works on signed integers. And it doesn't
confuse readers who doesn't know that std::size_t is unsigned, or haven't
studied the technicalities of integral conversions.

And: std::size_t is defined in <cstddef(and some of the other C headers).
It should be included to use std::size_t

--
rbh

[BobR]

Robert Bauck Hamar <ro**********@ifi.uio.nowrote in message...

BobR wrote:

// std::size_t big(-1); // compiler 'warning', but usually works (a)

[snip]

Of course the '-1' trick (a) only works on 'unsigned' types
(, and may be UB on some systems (?)).

No, it's well defined. The result should be the least unsigned integer
congruent to -1 modulo 2**N (where ** means power, and N is the number of
bits in std::size_t), and that would be 2**N - 1.

Thanks.

--
Bob R
POVrookie