THINGS I LEARNED THIS WEEK :-
Static Data Members & Methods
Understood how static members are shared among all objects of a class. Practiced using static methods that can access only static members. (Refer to keynotes for examples.)Array of Objects & Passing Objects as Function Arguments
Explored how to create arrays of objects and how objects can be passed to functions to share or modify data. (Check my keynotes for details!)Friend Functions
Learned about friend functions that can access private members of a class. They provide a way to break encapsulation when necessary. (Keynotes have useful insights.)Friend Classes & Member Friend Functions
Discovered how friend classes and member friend functions allow classes to share data. This is useful for tightly-coupled designs. (Examples in my keynotes!)Constructors & Types of Constructors
Studied different types of constructors, like default and parameterized ones, which help initialize objects efficiently. (Keynotes explain this with examples.)Constructor Overloading
Practiced defining multiple constructors with different parameters to handle various object initialization scenarios. (Check out my keynotes!)Constructors with Default Arguments
Explored constructors with default arguments to simplify object creation when some parameters are optional. (Refer to keynotes for syntax and examples.)Dynamic Initialization of Objects Using Constructors
Learned how constructors can dynamically allocate memory or initialize data based on runtime input. (Keynotes cover this in detail!)Destructors
Studied destructors, which are called automatically to clean up resources when an object goes out of scope. (Examples in my keynotes!)Inheritance & Its Different Types
Explored single, multilevel, hierarchical, and multiple inheritance to understand how classes can derive from each other. (Refer to my keynotes!)Protected Access Modifier
Learned how protected members are accessible in derived classes but not outside the class hierarchy. (Details in keynotes.)Inheritance Syntax & Visibility Mode
Studied the syntax for defining inheritance with public, private, and protected visibility modes. (Check my keynotes for clear examples!)Ambiguity Resolution in Inheritance
Faced challenges with ambiguity in multiple inheritance and learned how to resolve them using scope resolution. (Examples in my keynotes!)Constructors in Derived Class
Understood how constructors in base and derived classes work together during object creation. (Refer to my keynotes for examples!)
STEPS THAT I DID :-
Explored Static Data Members & Methods
I studied how static data members are shared across all objects of a class and how static methods can access only static members. Practiced implementing them in a few examples.Worked with Array of Objects & Function Arguments
I experimented with arrays of objects and learned how to pass objects as arguments to functions to modify their data efficiently.Explored C++ Friend Functions
I looked into friend functions and learned how they allow access to private members of a class, providing controlled access to the internals of a class.Practiced Friend Classes & Member Friend Functions
I researched how friend classes and member functions work together to grant classes more flexible access to each other's private data.Studied Constructors & Their Types
I dived into the different types of constructors (default, parameterized), understanding how to use them for initializing objects.Learned Constructor Overloading
I worked on overloading constructors, enabling the creation of objects with different sets of arguments, making my code more flexible.Explored Constructors with Default Arguments
I explored how default arguments in constructors simplify the initialization process when certain values can be omitted during object creation.Tried Dynamic Initialization of Objects
I experimented with dynamically initializing objects using constructors, which helped me handle situations where initialization depends on runtime input.Studied C++ Destructors
I studied destructors and their importance in cleaning up resources, ensuring proper memory management by releasing resources when an object goes out of scope.Dived into Inheritance & Its Types
I worked on understanding inheritance, including its types—single, multiple, multilevel, and hierarchical—and how it allows code reuse.Explored the Protected Access Modifier
I researched the protected access modifier and practiced using it to allow derived classes to access base class members while keeping them hidden from other parts of the program.Worked on Inheritance Syntax & Visibility Mode
I worked on understanding the different inheritance visibility modes (public, private, protected) and how they affect access to base class members.Handled Ambiguity in Inheritance
I learned how to resolve ambiguity when using multiple inheritance by using scope resolution and virtual base class.Studied Constructors in Derived Classes
I explored how constructors in derived classes work in conjunction with base class constructors, ensuring that the object is initialized properly during inheritance.
CHALLENGES I FACED & HOW I OVERCAME THEM :-
Array of Objects & Passing Objects as Function Arguments
Challenge:
I struggled with understanding how objects are passed to functions—whether they are passed by value or reference—and how arrays of objects work. This caused confusion around memory management.
How I Overcame It:
By writing small programs that passed arrays and objects to functions, I could visually understand how memory is allocated and how passing by reference affects objects.
Tip:
When dealing with objects in functions, always consider whether you need to modify the original object (use reference) or just need a copy (use value).Constructors with Default Arguments
Challenge:
I was unsure when to use default arguments in constructors. The syntax and behavior weren’t very intuitive to me at first.
How I Overcame It:
By experimenting with different constructors, some with and some without default arguments, I understood that they can provide flexibility in creating objects.
Tip:
Use default arguments to simplify constructor calls, but avoid overcomplicating the logic with too many default values.Dynamic Initialization of Objects
Challenge:
Memory management was a big hurdle when learning dynamic initialization. I didn’t fully understand how to dynamically allocate memory and how it affects object creation.
How I Overcame It:
I read more about pointers and dynamic memory allocation. Then I Inheritance & Its Types
Challenge:
Inheritance in C++ was confusing at first, especially understanding the differences between single, multiple, and multilevel inheritance.
How I Overcame It:
I wrote programs that demonstrated each type of inheritance. By experimenting with real-world examples, I understood the different use cases for each inheritance type.
Tip:
Use inheritance to reuse code effectively, but avoid too deep inheritance hierarchies, which can make your design harder to maintain.wrote code that dynamically initialized objects and usednewanddeletefor memory management.
Tip:
Always ensure that everynewhas a correspondingdeleteto prevent memory leaks.Ambiguity Resolution in Inheritance
Challenge:
When dealing with multiple inheritance, resolving ambiguity was confusing. It wasn’t clear how to refer to base class methods when they were inherited multiple times.
How I Overcame It:
I studied examples where the ambiguity resolution operator (::) was used. By writing code with multiple inheritance, I was able to see how to resolve ambiguity properly.
Tip:
Be cautious with multiple inheritance. When in doubt, use the scope resolution operator to clarify which method or member you are referring to.Constructors in Derived Class
Challenge:
I found it challenging to understand how constructors work in derived classes and the importance of calling the base class constructor first.
How I Overcame It:
By experimenting with both base and derived class constructors, I learned the importance of constructor chaining, which ensures proper initialization.
Tip:
Always initialize base class constructors first to ensure that the base part of your object is properly set up before derived class initialization begins.
RESOURCES I USED :-
Videos :- C++ Tutorials In Hindi By CodeWithHarry
Documentation :- cppreference.com
CONCLUSION :-
Week 3 of my C++ learning journey has been a deep dive into object-oriented programming (OOP) concepts, and I'm thrilled with the progress I've made! From understanding static members and constructors to diving into inheritance and resolving ambiguities in complex class structures, every concept has added more clarity to my programming foundation. I tackled challenges but with patience and practice, I overcame them one step at a time.
This week has reinforced how important it is to not only write code but to understand the why behind every line, every function, and every class. The lessons I’ve learned have solidified my OOP skills and prepared me for more advanced topics in the coming weeks. I’m excited to continue this journey and see where it takes me.
As I reflect on the progress I've made, I can only recommend that fellow learners stay curious, embrace challenges, and always seek to understand the deeper concepts behind their code. Keep coding, keep exploring, and most importantly, keep learning!
This concludes my Week 3 blog. Feel free to check out my previous blogs to follow my C++ journey. I'm looking forward to sharing Week 4 with you soon! 😊