CareerCup

Apart from that ,
it even has to incremented in the copy constructor.

use static!

I guess it can be done in the constructor.

Have to use a static int counter incremented in constructor and decremented in destructor

Define a static int to keep track of the number of objects. Increment it in each of the constructors (be sure to define the default constructor and the copy constructor). Decrement it in the destructor. Also, define a method that returns the static value.

Using static may not be working in multiple threads situation. Can you come up a better way?

Use of static is a good idea. In multiple thread situation, you can write a thread-safe code to update the value of static variable.

An approach that's both easy to implement and that gives the right answer is to create a static counter in Widget, increment the counter each time a Widget constructor is called, and decrement it whenever the Widget destructor is called. You also need a static member function how many to report how many Widgets currently exist. If Widget did nothing but track how many of its type exist, it would look more or less like this:


class Widget {
public:
Widget() { ++count; }
Widget(const Widget&) { ++count; }
~Widget() { --count; }

static size_t howMany()
{ return count; }

private:
static size_t count;
};

// obligatory definition of count. This
// goes in an implementation file
size_t Widget::count = 0;