Question

In c++ we can calls method of a class without instantiating it. Such as;

MyClass mc;
mc.method();

what are the advantages & disadvantages of using methods of class without instantiating it? When should we use this type?

Answer 1

Just because you haven’t explicitly invoked a constructor, doesn’t mean you haven’t instantiated it. The form you’ve used invokes the default constructor. This may or may not setup the class correctly, but that’s a matter for the class’s author to sort out, not the code that uses it.

EDIT: It occurs to me that the advice I gave might confuse more than it helps, so I’ll provide a couple of examples:

The following class has a trivial default constructor that doesn’t initialise its members:

class Point {
    int x, y;
    Point() { }
    Point(int x, int y) : x(x), y(y) { }
};

You can use this class with or without an explicit constructor:

Point p;
Point r(2, 3);

In both forms above, the class is instantiated and the instance is ready for use without causing any crashes or invoking undefined behaviour. In the case of p, however, the member variables x and y haven’t been initialised, and will thus have values that are, for all intents and purposes, random. Typically, you would populate such an object by setting its member variables explicitly…

Point a;
a.x = f();
a.y = g();

…or passing the object to another function to populate…

void f(Point& p) { p = something(); }
⋮
Point b;
h(b);

In other cases, the default constructor must initialise the object in a non-trivial way:

template <typename T>
class MyArray {
public:
    MyArray() : len_(0), capacity_(0), arr_(0) { }
    void add(const T& t) {
        if (len_ == capacity_) grow();
        arr_[len_++] = t;
    }
    ⋮
private:
    size_t len_, capacity_;
    T* arr_;

    void grow() { … }
};

The purpose of the constructor is to convert raw memory into a usable object. In the case of Point, no action is required for an instance to be usable. In the case of MyArray, len_ and capacity_ must be set to zero at construction time so that member functions like add() behave correctly (I also set arr_ to the null pointer for good measure).

The key message in all of this is that the object may or may not be initialised, but it is instantiated.