Question

While reading Bruce Eckel i came across the following example:

#include <cstdio>
#include <cstdlib>
using namespace std;
void* operator new(size_t sz) 
{
  printf("operator new: %d Bytes\n", sz);
  void* m = malloc(sz);
  if(!m) puts("out of memory");
   return m;
}

void operator delete(void* m) 
{
 puts("operator delete");
 free(m);
}
 class S {
 int i[100];
 public:
 S() { puts("S::S()"); }
 ~S() { puts("S::~S()"); }
 };

int main() {
puts("creating & destroying an int");
int* p = new int(47);
delete p;
puts("creating & destroying an s");
S* s = new S;
delete s;
puts("creating & destroying S[3]");
S* sa = new S[3];
delete []sa;
} 

I am having doubt with following statement:

1. Notice that printf( ) and puts( ) are used rather than iostreams. This is because when an iostream object is created (like the global cin, cout, and cerr), it calls operator new to allocate memory. With printf( ), you don’t get into a deadlock because it doesn’t call new to initialize itself.
   However, when i am running the program after replacing put with cout i am getting no such deadlock. Can anyone explain that?

2. operator new returns a void pointer, but finally we are getting pointer to a dynamically allocated object. So is it a constructor that returns a pointer to the object (this, though the constructor doesn’t have a return type) or its the compiler that does i internally?

Answer 1

1. Use of printf() to avoid a recursive call into operator new() is a safety measure – just to be sure it works. How do you know use of iostream never ever causes a call to operator new() function?

2. You’re confusing new expression (a language construct) with operator new() function. new expression indeed returns a typed pointer, but the a call to operator new() function is done “under the hood” and operator new() function returns void*. The compiler generates all necessary code for that.