Re: using a new_handler

From:

desktop <fff@sss.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 21 May 2007 13:49:09 +0200

Message-ID:

<f2s0vk$ain$1@news.net.uni-c.dk>

James Kanze wrote:

On May 20, 7:21 pm, desktop <f...@sss.com> wrote:

I have made the following new_handler that I set in main:

Two comments:

/* ================== new_handler ================== */
void no_mem() {
std::cerr << "out of memory\n";

Id this is the first use of std::cerr, there's a certain
probability that it will try to allocate memory. Which may lead
to endless recursion.

The usual technique when you want to do something like this is
to pre-allocate a hopefully big enough block, and free it in the
handler, immediately before using cerr.

throw std::bad_alloc();
std::exit(1);

And of course, since you've thrown an exception in the preceding
line, this line will never be reached. (From experience, the
"usual" new handler is something like:

    void
    no_mem()
    {
        delete [] preallocated ;
        std::cerr << "Out of memory" << std::endl ;
        abort() ;
    }

}

void init(int length, int* data) {

        try {
                data = new int [length];
        }
        catch(std::bad_alloc){
                std::cerr<< "out of memory\n";
        }
}

int main() {
        // Initialize the new_handler.
        std::set_new_handler(&no_mem);

        int* data;
        int i = 4;
        init(i,data);
        return 0;

}

But is it necessary to catch the exception in "init" or will it also be
caught by the new_handler?

In your case, the new handler is throwing the exception, not
catching it. The new handler is called before the exception is
thrown, and will normally not see it.

--
James Kanze (Gabi Software) email: james.kanze@gmail.com
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34

Ok the example I made was more or less based on Bjarne Stroustrup's
example on page 129 i the C++ Programming Language. His new_handler
looks like this:

void out_of_store() {
    cerr << "operator new failed: out of store\n";
    throw bad_alloc();
}

He also show a function that uses new:

void f() {
    try{
        for(;;) new char[10000];
    }
    catch(bad_alloc) {
        cerr << "Memory exhausted!\n";
    }
}

But I don't see why the out_of_store() function is needed if all
functions that uses new just makes sure to catch bad_alloc.

Would it not make more sense to make a new_handler that catches
bad_alloc and then omit the try/catch in all functions using new, since
the new_handler takes care of the catch for all new calls?