Things I Learned This Week :-
Break and Continue Statements
I learned how to control the flow of loops usingbreakto exit early andcontinueto skip to the next iteration. Refer to my keynotes for more details.C++ Pointers
I explored pointers, which store memory addresses, allowing direct access to variables and dynamic memory. Check my keynotes for more insights.Arrays & Pointers Arithmetic
I experimented with arrays and pointer arithmetic to access array elements efficiently. My keynotes have examples on this topic.Structures, Unions & Enums
I understood how structures and unions group data, and how enums simplify working with constants. More on this in my keynotes.Functions & Function Prototypes
I learned about functions to modularize code, and function prototypes to declare functions before use. Keynotes link for more details.Call By Value & Call By Reference
I practiced how to pass arguments to functions either by value (copying data) or by reference (direct access). See my keynotes for more.Inline Functions, Default Arguments & Constant Arguments
I discovered how inline functions can optimize performance, and how default and constant arguments work in functions. For details, check my keynotes.Recursions & Recursive Functions
I understood the power of recursion to solve problems by having a function call itself. My keynotes explain this in detail with examples.Function Overloading with Examples
I learned how function overloading allows multiple functions with the same name but different parameters. Check my keynotes for some practical examples.Object-Oriented Programming (OOP)
I took my first steps in OOP, learning about concepts like classes, objects, and encapsulation. More on OOP in my keynotes.Classes, Public and Private Access Modifiers
I explored how classes organize code and how access modifiers control the visibility of class members. More details in my keynotes.Nesting of Member Functions
I learned how to nest functions within classes to improve readability and maintain code organization. Check my keynotes for practical examples.Objects Memory Allocation & Arrays in Classes
I understood memory allocation for objects and how arrays work inside classes. For further details, refer to my keynotes.
Steps That I Did:
Explored Break and Continue Statements:
I practiced usingbreakandcontinueinside loops to control program flow. These statements allowed me to exit loops early or skip iterations based on specific conditions.Worked with C++ Pointers:
I experimented with pointers by learning how to declare and dereference them. This gave me deeper control over memory management and access to variable values directly.Dived into Arrays & Pointer Arithmetic:
I practiced using pointers with arrays, understanding how pointer arithmetic helps in accessing and manipulating array elements effectively.Studied Structures, Unions & Enums:
I created custom data types using structures and unions. I also explored enums to handle sets of constants easily in my programs.Used Functions & Function Prototypes:
I modularized my code by using functions and prototypes. This made my programs more organized and reusable by defining the structure of functions before their use.Explored Call By Value & Call By Reference:
I learned the difference between passing values by copying data and passing them by reference to modify the original values directly inside functions.Tried Inline Functions, Default Arguments & Constant Arguments:
I experimented with inline functions for optimization, and learned how to use default and constant arguments to make functions more flexible and error-free.Implemented Recursions & Recursive Functions:
I solved problems using recursion, where functions call themselves, making tasks like factorial calculation and tree traversal simpler.Practiced Function Overloading with Examples:
I used function overloading to define multiple functions with the same name but different argument types or numbers, enhancing the flexibility of my code.Dived into Object-Oriented Programming (OOP):
I explored the OOP paradigm, learning how to structure my programs using classes and objects, with concepts like inheritance and polymorphism.Studied Classes, Public, and Private Access Modifiers:
I understood how access modifiers in classes control the visibility of class members, protecting data using private members while exposing functionality with public members.Worked on Nesting of Member Functions:
I explored how member functions in a class can call each other, improving the organization and readability of the code.Explored Objects Memory Allocation & Arrays in Classes:
I learned how memory is dynamically allocated for objects and how arrays can be used inside classes to store multiple objects or values.
Challenge I Faced & How I Overcame Them :-
C++ Pointers :-
Pointers seemed tricky at first—understanding how to declare them and use them correctly was overwhelming. I was also confused about memory addresses and dereferencing.How I Overcame It :-
I started with simple examples of pointer declarations and worked with dereferencing in small steps. I also referred to examples in my keynotes to get a better grasp of how pointers link to memory.Tip:
Start with simple examples, like accessing array elements using pointers, before diving into complex concepts like dynamic memory allocation.Arrays & Pointer Arithmetic :-
When I first worked with arrays and pointers, I struggled to understand how pointer arithmetic could be used to access array elements.How I Overcame It :-
I practiced by combining arrays with pointers, writing code to access and modify array elements using pointer arithmetic. This helped me gain a clearer understanding.Tip:
Visualize how pointers and arrays are related in memory. This makes pointer arithmetic much easier to understand.Structures, Unions & Enums :-
Understanding when to use a structure, union, or enum was confusing. The difference between them wasn’t clear to me in terms of memory allocation and usage.How I Overcame It :-
I wrote programs using all three data structures to see how each works in different scenarios. I paid close attention to how memory is used and how enums simplify constant management.Tip:
Work through real-world examples to see how and when each data structure is most useful. This helps you remember their differences more easily.Functions & Function Prototypes :-
I struggled with organizing my code into functions and using function prototypes correctly. At first, I wasn’t sure when to declare a function prototype.How I Overcame It :-
I wrote multiple functions and declared them at the beginning of my code. After doing this, I understood how prototypes help the compiler recognize functions before they are used.Tip:
Make a habit of writing function prototypes for better code organization and clarity, especially in larger programs.Recursions & Recursive Functions :-
At first, recursion seemed complicated, especially understanding how a function can call itself and how the base case works.How I Overcame It :-
I practiced with simple examples like calculating the factorial of a number. This helped me understand how recursion works and why a base case is essential.Tip:
Start with simple problems like factorial or Fibonacci series to get comfortable with recursion.Function Overloading with Examples :-
I didn’t understand how function overloading works—how the compiler distinguishes between different functions with the same name but different arguments.How I Overcame It :-
I practiced overloading functions with varying numbers and types of parameters. Writing code and testing different overloads clarified how it helps make functions more flexible.Tip:
Play with different parameter types and numbers to observe how function overloading works and what rules apply.Nesting of Member Functions :-
I initially didn’t see the need for nesting functions within classes and struggled to understand its purpose.How I Overcame It :-
I created a few classes with nested functions and saw how nesting can make the code cleaner and more organized. This clarified its usefulness in larger programs.Tip:
Use nesting of member functions when you need to logically group operations that belong together within the same class.Objects Memory Allocation & Arrays in Classes :-
I wasn’t sure how memory is allocated for objects, especially when arrays were used inside classes.How I Overcame It :-
I explored dynamic memory allocation for objects and learned how arrays can be managed within classes. I also reviewed examples in my keynotes to understand memory allocation better.Tip:
Always pay attention to memory allocation in C++ when working with classes and arrays to avoid memory leaks.
Resources I Used :-
Documentation :- cppreference.com
Conclusion :-
As I wrap up Week 2 of my C++ learning journey, I can truly appreciate how much progress I’ve made. This week was full of exploration—whether it was understanding advanced concepts like pointers, recursion, and object-oriented programming, or mastering the finer details of C++ syntax and memory management. Although I faced challenges along the way, they were all opportunities for growth. Each obstacle taught me something new, and each breakthrough brought me closer to becoming more proficient in C++.
I’m excited to keep pushing myself in the weeks ahead, applying what I’ve learned, and sharing my journey with the community. Every concept, no matter how complex, becomes more manageable when you approach it with curiosity and persistence. I hope my experiences inspire others to dive into C++ and embrace the learning process.
For all the source codes, click here :- https://github.com/CodingDhairya-7/Learning-In-Public/tree/BasicToAdvanced-C%2B%2B