Constructors — default, parameterized, copy, delegating

5.2.6 · Coding › C++ Programming

1. Default constructor

Worked example Likhna

class Point {
    int x, y;
public:
    Point() : x(0), y(0) {}   // member-initializer list
};
Point p;   // x=0, y=0

: x(0), y(0) part kyun? Members ko initializer list mein initialize kiya jaata hai — body run hone se pehle. {} ke andar x = 0; likhna assignment after default-init hai, jo class members ke liye wasteful hai aur const/reference members ke liye toh bilkul impossible.

2. Parameterized constructor

Worked example

class Point {
    int x, y;
public:
    Point(int a, int b) : x(a), y(b) {}
};
Point p(3, 4);   // x=3, y=4

Initializer list phir se kyun? x ko a se ek hi step mein direct-initialize karta hai — koi temporary default value nahi.

Common mistake

explicit vs implicit conversion

class Meter { public: Meter(int m){} };
Meter m = 5;   // compiles! 5 silently becomes Meter(5)

Kyun harmless lagta hai: assignment jaisa dikhta hai. Problem: unexpected hidden conversions. Fix: single-arg constructors ko explicit Meter(int m); mark karo — phir Meter m = 5; reject ho jaayega lekin Meter m(5); kaam karega.

3. Copy constructor

Worked example WHY aapko likhna HI PADEGA (deep copy)

class Buf {
    int* data; int n;
public:
    Buf(int n) : data(new int[n]), n(n) {}
    Buf(const Buf& o) : data(new int[o.n]), n(o.n) {   // deep copy
        for (int i=0;i<n;i++) data[i]=o.data[i];
    }
    ~Buf(){ delete[] data; }
};

Yeh step (new int[o.n]) kyun? Compiler ka default copy constructor shallow copy karta hai — sirf pointer value copy karta hai. Phir do objects same memory ke owner ban jaate hain, aur dono destructors use delete[] karte hain → double free / crash. Deep copy se har object ka apna buffer hota hai.

4. Delegating constructor (C++11)

Worked example

class Point {
    int x, y;
public:
    Point(int a, int b) : x(a), y(b) {}     // target (master)
    Point() : Point(0, 0) {}                // delegates
    Point(int a) : Point(a, a) {}           // delegates
};

: Point(0,0) kyun? Delegate ki initializer list mein sirf woh call hota hai — aap wahan members bhi init nahi kar sakte. Target pehle poori tarah run karta hai, phir delegating constructor ka body run hota hai.

Common mistake Delegation cycle

A() : A(0) {}      // WRONG if...
A(int){ /* ... */ : A() {} }   // ...this loops back

Kyun okay lagta hai: dono reuse jaisa dikhta hai. Problem: A()→A(int)→A() ek cycle hai → undefined behaviour / infinite loop. Fix: ensure karo ki delegation ek tree banaye jo kisi real "target" constructor pe khatam ho.

Figure — Constructors — default, parameterized, copy, delegating

Operations ka order (HOW)

Flashcards

Constructor ko define karne wali teen properties kya hain?

Class ke same naam ka, koi return type nahi, object creation par implicitly call hota hai.

Compiler kab aapke liye default constructor banana band kar deta hai?

Jaise hi aap koi bhi doosra constructor declare karo; use = default se wapas laao.

Copy constructor apna parameter reference se kyun leta hai?

By value lena khud copy constructor ko invoke karta → infinite recursion.

ClassName(const ClassName&) mein const kyun?

Aap sirf source read karte ho, aur yeh const objects aur temporaries se copy karne deta hai.

Shallow vs deep copy problem?

Default copy pointers copy karta hai, toh do objects memory share karte hain → destructors mein double free; deep copy alag buffer allocate karta hai.

Rule of Three batao.

Agar aap destructor, copy constructor, ya copy assignment define karo, toh probably teeno chahiye.

Delegating constructor kya hai aur uski ek restriction?

Ek constructor jo init list mein same class ke doosre constructor ko call kare; woh call list mein SIRF wahi cheez ho sakti hai (koi extra member init nahi).

Members kis order mein initialize hote hain?

Jis order mein class mein DECLARE kiye gaye hain, initializer list ke order mein nahi.

explicit single-arg constructor par kya rokta hai?

Implicit conversions jaise Meter m = 5;.

Teen situations jo copy constructor fire karti hain?

Copy-initialization (T b=a), pass-by-value, return-by-value.

Recall Feynman: 12-saal ke bachche ko samjhao

Ek toy factory imagine karo. Jab bhi koi naya toy line se nikalata hai, ek worker use set up karta hai taaki woh khelne ke liye ready ho. Woh worker hi constructor hai.

Default: seedha sada toy banata hai standard parts se jab aap kuch special nahi bolte.
Parameterized: aap worker ko colour aur size dete ho, aur woh wahi toy banata hai.
Copy: aap kisi bane hue toy ki taraf point karte ho aur bolte ho "mujhe exactly aisa ek aur banao." Agar toy ka apna toy-dog hai, toh ek lazy copy dono toys ko ek hi dog deta hai (woh uss par ladte hain!). Deep copy naye toy ko uska apna dog deta hai.
Delegating: har worker ko poori setup sikhane ke bajaye, ek master worker jaanta hai, aur baaki bolte hain "hey master, tum karo."

Connections

Destructors and RAII — constructors ke saath pair karta hai resource lifetime manage karne ke liye.
Copy Assignment Operator — copy constructor ka = wala sibling.
Move Semantics — move constructor — C++11 ka "copy ki jagah steal karo" wala cousin.
Member Initializer Lists — efficient construction ka engine.
Rule of Three Five Zero — special members kab likhen/chhodein.
explicit keyword and implicit conversions