throws different exceptions

[datastrc]

Hello

When compiling the following example

[CODE=cpp]#include <cstdlib> //declarations of malloc and free
#include <new>
#include <iostream>
using namespace std;

class C {
public:
C();
void* operator new (size_t size); //implicitly declared as a static member function
void operator delete (void *p); //implicitly declared as a static member function
};

void* C::operator new (size_t size) throw (const char *){
void * p = malloc(size);
if (p == 0) throw "allocation failure"; //instead of std::bad_alloc
return p;
}

void C::operator delete (void *p){
C* pc = static_cast<C*> (p);
free(p);
}

int main() {
C *p = new C; // calls C::new
delete p; // calls C::delete
}[/CODE]

 g++ -Wall example.cpp -o example
example.cpp:14: error: declaration of 'static void* C::operator new(size_t) throw (const char*)' throws different exceptions
example.cpp:9: error: from previous declaration 'static void* C::operator new(size_t)'
example.cpp: In static member function 'static void C::operator delete(void*)':
example.cpp:21: warning: unused variable 'pc'

It something wrong with new operator overloading ?
What's this mean
... operator new(size_t) throw (const char*)' throws different exceptions

[arnaudk]

For one thing,
throw ("allocation failure")
instead of:
throw "allocation failure"
and please enclose your code between [CODE=cpp] ... [/CODE] to make it much easier to read for the rest of us.

[Ganon11]

Why, why, why are you using malloc and free in a C++ environment, especially with classes? That's what new and delete are for. Using malloc only gets you a chunk of memory, but new calls the constructor of the object. What possible purpose could you have for using these C functions in C++?

Also: Please don't double post your question. Having two threads doesn't help you - it just confuses the people trying to help you.

[datastrc]

I am interrested to understand new/delete operators overloading and actually this code is taken from a tutorial. I am still learning :) ...

I have a question:
new operator can be used to allocate a void * pointer ?
Something like that
[code=cpp]
void *v;
v=new (1024);//v=malloc(1024) works fine
[/code]
won't be compilled.

For one thing,
throw ("allocation failure")
instead of:
throw "allocation failure"
and please enclose your code between [CODE=cpp] ... [/CODE] to make it much easier to read for the rest of us.

Nothing changed even if instead of
[CODE=cpp]
throw "allocation failure"
[/CODE]
is used
[CODE=cpp]
throw ("allocation failure")
[/CODE]

[CODE=cpp]
#include <cstdlib> //declarations of malloc and free
#include <new>
#include <iostream>
using namespace std;

class C {
public:
C();
void* operator new (size_t size) throw (const char *); //implicitly declared as a static member function
void operator delete (void *p); //implicitly declared as a static member function
};

void* C::operator new (size_t size) throw (const char *)
{
void * p = malloc(size);
if (p == 0)
throw ("allocation failure") ; //instead of std::bad_alloc
return p;
}

void C::operator delete (void *p){
C* pc = static_cast<C*> (p);
free(p);
}

int main() {
C *p = new C; // calls C::new
delete p; // calls C::delete
}
[/CODE]

$g++ -g3 -Wall example.cpp -o example

example.cpp: In static member function 'static void C::operator delete(void*)':
example.cpp:22: warning: unused variable 'pc'
/tmp/cc9LdSLe.o: In function `main':
example.cpp:27: undefined reference to `C::C()'
collect2: ld returned 1 exit status

But, oops ! Constructor body is missing.

[CODE=cpp]
#include <cstdlib> //declarations of malloc and free
#include <new>
#include <iostream>
using namespace std;

class C {
public:
C(){};
void* operator new (size_t size) throw (const char *); //implicitly declared as a static member function
void operator delete (void *p); //implicitly declared as a static member function
};

void* C::operator new (size_t size) throw (const char *)
{
void * p = malloc(size);
if (p == 0)
throw "allocation failure" ; //instead of std::bad_alloc
return p;
}

void C::operator delete (void *p){
C* pc = static_cast<C*> (p);
free(p);
}

int main() {
C *p = new C; // calls C::new
delete p; // calls C::delete
}
[/CODE]

Now everything is compiled OK, without errors.

[weaknessforcats]

This is a rotten example. You reallty need a better tutorial. One that has no malloc() and no type casts.