Building classes and class construct Conclusion

class MyClass {
public:
  void myFunction();
};

// Definition outside the class using the scope resolution operator
void MyClass::myFunction() {
  // Function implementation
}

class OuterClass {
public:
  class InnerClass {
	  // Inner class definition
  };
};

OuterClass::InnerClass obj; // Using scope resolution to access InnerClass

• Clarifies Scope:** Helps the compiler understand which class a member belongs to, especially when multiple classes have members with the same name.
• Namespace Management:** Also used to specify the namespace in which a class or function resides.

1. Declare the Function Inside the Class:**

      class MyClass {
      public:
          void myFunction(); // Declaration
      };
      

   void MyClass::myFunction() {
       // Implementation code
   }
   

• Separation of Interface and Implementation:** Keeps the class declaration clean and focused on the interface.
• Improved Readability:** Easier to navigate through code when implementation details are separate.

class Calculator {
public:
    int add(int a, int b); // Declaration
};

int Calculator::add(int a, int b) { // Definition
    return a + b;
}

• Different Signatures:** Overloaded functions must differ in the type and/or number of parameters.
• Compile-Time Resolution:** The compiler determines which function to call based on the arguments provided.
• Cannot Overload by Return Type Alone:** Changing only the return type is insufficient for overloading.

class Printer {
public:
    void print(int i);
    void print(double f);
    void print(const std::string& s);
};

void Printer::print(int i) {
    std::cout << "Printing int: " << i << std::endl;
}

void Printer::print(double f) {
    std::cout << "Printing double: " << f << std::endl;
}

void Printer::print(const std::string& s) {
    std::cout << "Printing string: " << s << std::endl;
}

Printer p;
p.print(5);             // Calls print(int)
p.print(3.14);          // Calls print(double)
p.print("Hello World"); // Calls print(const std::string&)

• Access to Enclosing Class Members:** By default, the nested class does not have access to the members of the enclosing class.
• Access Control:** The nested class can be declared under `public`, `protected`, or `private` sections to control its accessibility.
• Scope Specification:** To use the nested class outside the enclosing class, you need to specify the full scope.

class EnclosingClass {
public:
    int outerData;

    class NestedClass {
    public:
        void display(EnclosingClass& obj) {
            // Accessing outer class's public member via object reference
            std::cout << "Outer Data: " << obj.outerData << std::endl;
        }
    };
};

int main() {
    EnclosingClass outer;
    outer.outerData = 10;

    EnclosingClass::NestedClass nested;
    nested.display(outer);

    return 0;
}

Outer Data: 10

• Instantiation:** You can create an object of the nested class using the scope of the enclosing class.
• Encapsulation:** Nested classes can help encapsulate helper classes that are only relevant to the enclosing class.

class Counter {
public:
    static int count;
    Counter() {
        count++;
    }
};

int Counter::count = 0; // Definition and initialization

int main() {
    Counter c1;
    Counter c2;
    std::cout << "Count: " << Counter::count << std::endl; // Output: Count: 2
    return 0;
}

class Immutable {
public:
    const int id;
    Immutable(int i) : id(i) {} // Initialization in constructor
};

int main() {
    Immutable obj(10);
    // obj.id = 20; // Error: assignment of read-only member
    std::cout << "ID: " << obj.id << std::endl; // Output: ID: 10
    return 0;
}

class Data {
public:
    int value;
    Data(int v) : value(v) {}
    int getValue() const {
        return value;
    }
    void setValue(int v) {
        value = v;
    }
};

int main() {
    const Data obj(5);
    std::cout << obj.getValue() << std::endl; // Allowed
    // obj.setValue(10); // Error: cannot call non-const function on const object
    return 0;
}

• Accessing Members:** Useful when parameter names hide member variables.
• Method Chaining:** Allows functions to return the object's reference.
• Passing the Object:** Can pass the current object to other functions or methods.

class Sample {
private:
    int value;
public:
    void setValue(int value) {
        this->value = value; // 'this->value' refers to the member variable
    }
};

class Number {
private:
    int value;
public:
    Number(int v) : value(v) {}
    Number& increment() {
        value++;
        return *this;
    }
    void display() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    Number num(5);
    num.increment().increment().display(); // Chaining method calls
    // Output: Value: 7
    return 0;
}