Forem: Adhyan Jain

🚀 Week 5 & 6 Update: JavaScript, DOM, jQuery & Backend

Adhyan Jain — Wed, 04 Jun 2025 18:47:30 +0000

Over the past two weeks, I’ve made solid progress in Angela Yu’s Full Stack Web Development Bootcamp. From diving deeper into JavaScript to stepping into backend concepts with Node.js and Express, I’m really enjoying how everything is coming together.

Here’s a breakdown of everything I covered during Week 5 and 6:

🔷 Introduction to JavaScript ES6

◾ JavaScript Variables + Naming Conventions
◾ String Manipulation (Concatenation, Slicing, Casing)
◾ Functions: Parameters, Return Values
◾ BMI Calculator + Life in Weeks Challenge

🔷 Intermediate JavaScript

◾ Random Number Generation
◾ Quizzes and practical challenges

🔷 The Document Object Model (DOM)

◾ Selecting and manipulating elements
◾ Event listeners
◾ Changing styles dynamically

🔷 The Dicee Game

◾ Built a dice game using DOM manipulation
◾ Used random numbers and event handling

🔷 Advanced JavaScript and DOM Manipulation

◾ Higher-order functions
◾ Understanding this keyword
◾ Event delegation
◾ ClassList and style control

🔷 jQuery

◾ Selecting and manipulating elements
◾ Event handling with jQuery
◾ jQuery effects and animations

🔷 The Simon Game

◾ Built a memory-based game
◾ Applied jQuery and sound logic

🔷 The Unix Command Line

◾ Basic terminal commands
◾ File system navigation
◾ Working with directories

🔷 Backend Web Development

◾ Introduction to backend concepts
◾ Server-side architecture overview

🔷 Node.js

◾ Core modules and creating a server
◾ Basics of Node runtime

🔷 Express.js with Node.js

◾ Setting up Express server
◾ Routing and handling requests
◾ Serving static files

🔷 EJS

◾ Embedding JavaScript in HTML
◾ Creating reusable templates
◾ Passing data to views

🔷 Blog Web Application

◾ Made a blog app using EJS and Express

🔷 Git, GitHub and Version Control

◾ Git basics and initializing repos
◾ Committing and pushing changes
◾ Connecting to GitHub

It’s been a productive two weeks and I’m really looking forward to building even more complex projects as I continue. If you're also on a similar journey or want to share insights, feel free to connect!

Week 4 of Website Development

Adhyan Jain — Wed, 21 May 2025 17:08:14 +0000

🚀 Week 4 of My Web Development Journey

I’ve just wrapped up Week 4 of my web development journey, and it was packed with some seriously powerful CSS concepts. From layout mastery to a full personal portfolio — here’s everything I learned and practiced this week:

📚 Topics I Covered:

🔹 CSS Positioning
Learned how to use static, relative, absolute, and fixed positioning. Finally understood how to layer and control layout elements precisely.

🔹 CSS Flag Project – The Flag of Laos
Applied all my positioning knowledge to build a mini CSS flag project. It was a fun challenge that helped solidify my understanding!

🔹 Advanced CSS
This was a deep dive into some core CSS skills that make modern web design possible:

-> CSS Display: Learned and practiced how elements behave: block, inline, inline-block, and none.

-> CSS Float: Got a look into how float was used for layouts before Flexbox became standard.

-> Responsiveness: Learned how to design websites that adapt gracefully to different screens.

-> Media Queries: Practiced using conditional CSS to target mobile, tablet, and desktop views.

-> Mini Project – Web Design Agency: Built a small responsive agency website to apply everything.

🔹 Flexbox
Flexbox is a layout superpower!
I practiced building responsive layouts using: justify-content, align-items, flex-direction.
So much control with such little code. 🔥

🔹 CSS Grid
Explored Grid with properties like: grid-template-columns, grid-area, gap
Grid + Flexbox = Layout mastery! 💪

🔹 Bootstrap
Learned and practiced how to create fast, responsive UIs using Bootstrap: Utility classes, Grid system, Components like navbar, cards, and buttons.

It’s like CSS on steroids — great for rapid prototyping.

🔹 Capstone Project – Personal Portfolio
To wrap up the week, I built a personal portfolio using only HTML and CSS. It showcases everything I’ve learned so far and marks a huge milestone in my journey!

🧠 Key Takeaways:
Positioning and layout are essential for responsive design.
Flexbox and Grid solve so many alignment headaches.
Bootstrap speeds up workflow massively — especially for quick designs.

⚡ Challenges I Faced:
Understanding how Flexbox and Grid interact took a few trial-and-error rounds.

Bootstrap’s class naming took a bit of practice to get used to, but it’s clicking now!

📌 Projects & Code:
You can check out all my projects and code here:
🔗 GitHub Repo: github.com/AdhyanJain2512

💬 Let’s Connect!
Which layout method do you prefer — Flexbox or Grid?
Drop your thoughts in the comments or share your layout wins and fails! Let’s learn together. 😄

Week 3 of Web Dev

Adhyan Jain — Thu, 15 May 2025 17:09:32 +0000

Hey devs! 👋
I'm back with another weekly update on my coding journey through The Complete Full-Stack Web Development Bootcamp by Angela Yu.

Despite my final exams, I’ve stayed on track with consistent small wins every day — and the progress feels amazing! 💪

📚 What I Learned This Week
🔹 Day 15: CSS Colors
Learned how to use HEX, RGB, and HSL color formats. Practiced applying them effectively for better design aesthetics.

🔹 Day 16: Fonts in CSS
Discovered how to change and import fonts using font-family and @import. Google Fonts is a game-changer!

🔹 Day 17: Font Properties
Explored font weight, size, style, and line height. Learned how small changes in typography improve readability.

🔹 Day 18: CSS Box Model
Finally understood how elements are spaced using margin, border, padding, and content — the core of CSS layout.

🔹 Day 19: Motivation Meme Project
Applied my knowledge in a mini-project — built a motivational meme web page using CSS styling and layout skills.

🔹 Day 20: Margin & Padding
Practiced using margin and padding to space and align content neatly. It’s all about visual clarity and balance.

🔹 Day 21: Combining Selectors
Learned how to combine tag, class, and descendant selectors. My CSS code is now way cleaner and more efficient!

🧠 Key Takeaways
The box model is crucial for mastering CSS layouts.

Consistent styling with fonts and spacing improves user experience.

Mini-projects reinforce learning by bringing concepts together.

⚡ Challenges I Faced
Still wrapping my head around margin collapsing and box sizing. It took a few experiments, but it’s finally making sense.

💬 Question for You
What was the most confusing part of CSS when you started?
Let’s share our stories and learn from each other — I’d love to hear your experience! 🚀

🚀 Week 2 of My Web Development Journey

Adhyan Jain — Thu, 08 May 2025 10:09:24 +0000

Hey devs! 👋
I’m back with another weekly update on my coding journey, where I’m working through The Complete Full-Stack Web Development Bootcamp by Angela Yu.
Even though my final exams are ongoing, I’ve been keeping up with small daily wins — and they’re really stacking up! 💪

📚 What I Learned This Week

🔹 Day 8: Image Elements

Learned how to use the <img> tag to embed images.
Understood the importance of alt attributes for accessibility and SEO.

🔹 Day 9: Birthday Invite Project

Built a fun web-based birthday invitation.
Practiced layout, file structure, and embedding media in a clean, presentable way.

🔹 Day 10: File Paths

Explored absolute vs. relative file paths.
Practiced organizing folders and linking assets like images and stylesheets.

🔹 Day 11: HTML Portfolio Project

Created a basic portfolio using only HTML.
Focused on proper semantic structure and content organization.

🔹 Day 12: Adding CSS

Applied external CSS for the first time!
Learned how to style elements using selectors and began exploring visual hierarchy.

🔹 Day 13: CSS Selectors

Practiced using tag, class, and ID selectors effectively.
Gained confidence in applying precise styles to structure my pages better.

🔹 Day 14: Color Vocabulary

Dived into HEX, RGB, and HSL color systems.
Improved page aesthetics using consistent and readable color schemes.

🧠 Key Takeaways

Organizing files and folders properly makes scaling projects much easier.
Semantic HTML isn’t just about structure — it boosts SEO and accessibility.
Consistency matters. Even 30 minutes a day pays off when done regularly.

⚡ Challenges I Faced

So far, things are going smoothly! But:

Understanding file paths and organizing folder structures took a few trial runs to get right.

🔗 Check Out My Work

All code and projects are open-source and available here:
📁 GitHub: GitHub Repo
📇 LinkedIn: Adhyan Jain

💬 Question for You

What was the first full project you built using just HTML?
I’d love to hear your stories — let’s grow together and learn from one another! 🚀

🚀 Week 1 of My Web Development Journey

Adhyan Jain — Sun, 27 Apr 2025 20:24:45 +0000

Hey everyone! 👋

This week marks the beginning of my Web Development journey, as I started learning through "The Complete Full-Stack Web Development Bootcamp" by Angela Yu on Udemy.

Currently, my progress will be slower since my final exams are going on, but I’m committed to consistently building my foundation step by step! 📚✨

📚 Topics I Learned:

🔹 Day 1: Heading Element

Learned about the six levels of headings (<h1> to <h6>).
Understood the importance of using headings for structure and SEO.

🔹 Day 2: Paragraph Element

Explored how <p> tags format text into readable blocks.
Focused on writing clean paragraphs instead of using <br> for spacing.

🔹 Day 3: Void Elements

Studied self-closing tags like <br>, <img>, <input>.
These elements simplify code and are essential for creating clean layouts.

🔹 Day 4: Movie Ranking Project

Built my first mini-project! 🎬
Ranked my favorite movies using headings and paragraphs.
Practiced proper folder structure and semantic HTML.

🔹 Day 5: List Elements

Worked with ordered (<ol>) and unordered (<ul>) lists.
Learned how lists improve organization and readability.

🔹 Day 6: Nesting and Indentation

Practiced proper nesting of elements.
Built the habit of clean indentation for better readability and collaboration.

🔹 Day 7: Anchor Elements

Created clickable hyperlinks with <a> tags.
Learned about linking internal pages vs external sites and opening links in new tabs.

🔑 Key Takeaways:

Clean indentation and proper nesting are essential good habits.
Understanding links and paths (relative vs absolute) is foundational for bigger projects.

⚡ Challenges I Faced:

No major challenges faced this week! The basic concepts were very easy and enjoyable to learn. 🎯

📂 Proof of Work:

All exercises and mini-projects are uploaded here:

🔗 GitHub: CodeVault Repository

Also check out my Linkedin profile here:

🔗 Linkedin Profile: @adhyanjain

🎯 What's Next?

Moving on to more of HTML next week!

Super excited to learn more and build something amazing!

❓ Question for You:

When you started your web development journey, which HTML concept confused you the most?

Would love to hear your stories and tips! 🚀

🚀 Week 11: Mastering Operator Overloading, Templates & STL in C++

Adhyan Jain — Fri, 25 Apr 2025 11:16:38 +0000

Apologies for the delay in posting this—exams kept me busy. Finally catching up!

This will be the last post of my C++ learning progress. Stay tuned for the next topic I'll pick!

This week, I delved deep into operator overloading, inheritance, virtual functions, templates, and STL containers in C++. Here's a quick recap of what I worked on during Days 104–110.

🔹 Day 71 – Operator Overloading

Time Incrementer – Overloaded ++ to adjust departure time
Matrix Math – Multiplication and transpose operations
Matrix Negator – Unary - to invert matrix elements

🔹 Day 72 – Inheritance & Virtual Functions

Population Growth Calculator – Virtual calcRate()
Time Format Converter – Conversion between hours, minutes, and seconds
Reservation Discount System – Age-based pricing

🔹 Day 73 – Abstract Classes & Use Cases

Meal Price Estimator – Polymorphism with calculatePrice()
Shop Inventory Manager – Item management using virtual functions
Experiment Analyzer – Analyzing experimental data with polymorphism

🔹 Day 74 – Practical Polymorphism

Item Cost Calculator – Discounts based on item type
Banking System – Inheritance for different account types
Vehicle Cost Tracker – Calculate travel time/cost across modes

🔹 Day 75 – Templates

Stack Handler – Operations for int and float types
URL Tracker – Indexing URLs with function templates
Laptop Model Manager – Track models using function templates

🔹 Day 76 – Smart Array Operations

Composite Number Filter – Remove primes from list
Array Max Finder – Find largest/second-largest elements
Odd Index Printer – Print elements at odd indices

🔹 Day 77 – STL & Template Utility Apps

Construction Inventory System – Update/display material info
STL List Handler – Sort/remove duplicates from std::list
Table Generator – Print multiplication table for an array element

🏁 Key Takeaways

✔️ Focused on operator overloading, templates, and polymorphism

✔️ Built real-world applications with inheritance and STL

✔️ Gained hands-on experience in generic programming using templates

Week 10: Mastering Polymorphism, Templates, and Advanced OOP in C++

Adhyan Jain — Wed, 16 Apr 2025 07:30:08 +0000

In Week 10, I wrapped up the 100 Days of Code milestone with advanced Object-Oriented Programming concepts in C++. This week was all about operator overloading, function templates, virtual functions, and even class templates—all applied in real-world use cases like billing systems, calculators, and booking apps.

🔹 Day 64 – Operator Overloading with Real-Life Classes

Fraction Adder – Adds two fractions using overloaded + operator
Velocity Calculator – Overloads * to compute final velocity using v = u + at
Weight Tracker – Increments student weight with ++ using friend function

🔹 Day 65 – Inheritance & Virtual Functions in Practice

Item Billing System – Calculates total with discounts using base & derived classes
Sleep Tracker – Compares weekday vs weekend sleep duration
Student Grade System – UG and PG grade evaluation with polymorphism

🔹 Day 66 – More Virtual Function Use-Cases

Power Evaluator – Calculates a^b and b^a using pure virtual functions
Hotel Room Billing – Calculates cost for single/double rooms with rules
Transport Time Calculator – Computes time based on travel modes and locations

🔹 Day 67 – Applying Inheritance in Utility Tools

Arithmetic Operator Class – Virtual functions for add, subtract, multiply, divide
Electricity Bill by Appliance – Calculates energy usage across devices
Alphabet Game Scorer – Adds/subtracts score for upper/lowercase letters

🔹 Day 68 – C++ Templates in Action

Value Swapper – Swaps float and double using class templates
Bank Interest Calculator – Template class for computing yearly interest
Derived Class Template Swap – Uses derived class to swap values with formatting

🔹 Day 69 – STL-Based Challenges

Inventory Merger – Merges and sorts two batches of item IDs
List Cleaner – Removes all instances of a target number
Unique Sum Calculator – Computes sum of unique integers with size constraint

🔹 Day 70 – Structs, Templates & Booking Systems

Compatibility Checker – Compares age, height, and education using structs
Booking Revenue Calculator – Uses function templates to calculate revenue
Audi Test Drive Slot System – Checks and books available test drive dates

🏁 Key Highlights

✅ Explored operator overloading for intuitive operations

✅ Applied class and function templates for generic coding

✅ Used inheritance and virtual functions in over 20+ practical projects

✅ Hit the 100 Days of Code milestone with consistent learning and building

🔍 Looking Ahead

Moving forward, I’ll focus on building structured C++ projects that combine all the concepts learned—templates, inheritance, polymorphism, and file handling. Excited to begin architecting mini real-world systems!

📌 Catch the full journey and codebase on GitHub

💬 What’s your favorite way to apply templates in real-world projects?

Week 9 : 20+ Real-Life Projects Using Inheritance & Overloading in C++

Adhyan Jain — Wed, 09 Apr 2025 20:24:37 +0000

In Week 9, I dived deep into Object-Oriented Programming in C++ with a special focus on inheritance and overloading. This week was all about implementing concepts like multiple, multi-level, hierarchical, and hybrid inheritance, alongside constructor and function overloading to build real-life simulations and utility-based mini apps.

🔹 Day 57 – Virtual Functions & Eligibility Checks

Calories Burned Calculator – Polymorphism with virtual functions
Rent Eligibility Checker – Calculates rent based on income percentage
Library Fine System – Computes fines using inheritance and date logic

🔹 Day 58 – Multiple Inheritance in Action

Electricity Bill Calculator – Based on unit usage and connection type
GDP per Capita – Divides GDP by population
Health Assessment – Combines BMI and blood pressure metrics

🔹 Day 59 – Multi-level Inheritance Utilities

Car Parameter Calculator – Calculates range, payload, and weight
Fuel vs Electric Comparison – Estimates range of different car types
Travel Budget Planner – Solo trip expense planner

🔹 Day 60 – Hierarchical & Simple Applications

Simple Banking System – Deposit, withdrawal, and interest
Plant Discount System – Ratings and discount logic
Language Stats – English and Spanish speaker majority calculation

🔹 Day 61 – Hybrid Inheritance Systems

Student Record System – UG/PG grading & evaluation
Weather Monitor – Checks weather from temp & humidity
Vehicle Rental Calculator – Costs based on mileage and type

🔹 Day 62 – Constructor Overloading in Practice

Odd/Even Sum Calculator – Constructor logic based on user input
Distance Converter – Miles ↔ Km with validation
Speed Calculator – Overloaded constructor for time format flexibility

🔹 Day 63 – Function Overloading for Flexibility

Minimum Finder – Overloaded function for int/double
Millimetre Converter – Converts mm → cm/km based on input
Shopping Cart Total – Calculates total with/without discount

🏁 Key Highlights

Implemented every major inheritance type in practical projects
Applied constructor & function overloading for reusability and abstraction
Built 20+ projects simulating real-world scenarios using OOP

🔍 Looking Ahead

As I move into Week 10, the focus will shift toward integrating OOP concepts into more structured systems and starting small project-based builds. The goal is to get closer to real-world app architecture.

📌 Stay tuned and follow my journey on GitHub for all code updates!

💬 What’s your favorite way to apply inheritance in your own projects?

Week 8 : Mastering OOP Inheritance

Adhyan Jain — Wed, 02 Apr 2025 18:28:26 +0000

I dedicated Days 50-56 to mastering inheritance in object-oriented programming. Here's a summary of my journey through different inheritance patterns and what I learned along the way.

Day 50: Basic Inheritance

I started with the fundamental parent-child class relationship:

• Electronics Store: Created a Device base class with Television & Refrigerator subclasses
• Sales Assistant: Implemented inheritance for displaying product details & calculating metrics
• Product Cost Calculator: Used hierarchical inheritance for electronic & mechanical device pricing

These projects demonstrated how inheritance promotes code reuse and specialization while maintaining a clear hierarchy.

Day 51: Multiple Inheritance

Multiple inheritance allows a class to inherit from more than one base class:

• Loan Calculator: Designed Principal & InterestRate classes with Loan inheriting from both
• Ticket Booking System: Built a system handling both concert & movie tickets
• Academic Performance Tracker: Created a Student class inheriting from GPA & CreditHours classes

The challenge here was understanding potential ambiguity issues when classes inherit from multiple sources.

Day 52: Multi-level Inheritance

Next, I explored multi-level inheritance, which creates chains of inheritance:

• Financial Calculator: Built Investment → FixedDeposit → SimpleInterest inheritance chain
• Order Cost Calculator: Implemented Order → FinalOrder → DiscountedOrder structure
• Social Media System: Designed User → Blogger → Influencer class hierarchy

This pattern helped me understand how behavior accumulates through inheritance levels.

Day 53: Protected Members

Day 53 focused on access modifiers, particularly protected members:

• Cylinder Volume Calculator: Created Circle base class with protected radius
• Electrical Power Calculator: Implemented base class P with voltage & current attributes
• Vehicle Rental System: Built Vehicle base class with Car & Motorcycle subclasses

These projects demonstrated how protected members strike a balance between encapsulation and inheritance.

Day 54: Hybrid Inheritance

Hybrid inheritance combines multiple inheritance types:

• Dual Role Manager: Created a TeachingAssistant class inheriting from both Student & Employee
• Multi-operation Calculator: Built child classes with inherited operations
• Online Store System: Implemented hybrid inheritance for electronics & clothing products

This complex pattern taught me how to model sophisticated real-world relationships.

Day 55: Constructor Overloading

While not strictly an inheritance concept, constructor overloading pairs naturally with inheritance:

• Goods Cost Calculator: Implemented default & parameterized constructors
• Simple Interest Calculator: Created multiple constructors for different initialization scenarios
• Forest Rainfall Calculator: Used constructor overloading for square & rectangular areas

This reinforced how constructors work across inheritance hierarchies.

Day 56: Function Overloading

I concluded with function overloading:

• Minimum Value Finder: Created overloaded functions for different data types
• Unit Converter: Implemented overloaded conversion functions
• Shopping Cart: Designed overloaded price calculation functions for various scenarios

This exercise demonstrated how polymorphism complements inheritance to create flexible interfaces.

Key Takeaways

After a week of intensive practice, I gained several valuable insights:

Inheritance is powerful but requires planning - Poor hierarchies lead to rigid code
Access modifiers matter - Protected members are crucial for proper inheritance
Real-world modeling - The best inheritance hierarchies mirror natural relationships

Has anyone else tackled similar inheritance challenges? Which inheritance pattern do you find most useful in production code?

Week 7 : Advanced OOP Practice in C++

Adhyan Jain — Tue, 25 Mar 2025 17:52:15 +0000

With exams ongoing, I focused on advanced OOP problems in C++. Each day tackled unique challenges, strengthening my grasp of key concepts.

Day 43 – OOP Basics

Temperature Converter – Convert between Fahrenheit & Celsius.
Arithmetic Operations – Perform basic operations on two integers.
Toy House Surface Area – Compute surface area (excluding the roof).
Weather Analysis – Compare historical & current weather conditions.

Day 44 – Constructors & Math Operations

Palindrome Checker – Verify palindromes using constructors & destructors.
Matrix Determinant – Compute determinant of a square matrix.
Power & Root Calculator – Calculate squares, cubes & their roots.
Rectangle Area – Compute area using coordinate-based input.

Day 45 – Static Members

Event Management – Track participant count using static members.
Rectangle Count – Maintain count & compute areas of multiple rectangles.
Bank Interest Calculator – Update & apply shared interest rates.
Circle Tracker – Track circle count & compute area/circumference.

Day 46 – Inline Functions

Area Calculator – Compute areas using inline functions.
Armstrong Number – Verify & print factors using inline methods.
GCD Calculation – Compute GCD using Euclid’s algorithm.
Arithmetic Operations – Implement basic operations using inline functions.

Day 47 – Call by Reference & String Analysis

Swap Numbers – Implement swapping using call-by-reference.
Salary Update – Calculate updated salary post-hike.
Message Analysis – Count letters, digits & special characters.
Fibonacci Last Digit – Compute last digit of nth Fibonacci number.

Day 48 – Default Arguments & Real-World Apps

Perfect Number Check – Validate perfect numbers with flexible input.
Library Book Counter – Track book counts across categories.
Hotel Booking System – Compute total stay cost based on preferences.
Calorie Calculator – Estimate calories burned based on workout type & intensity.

Day 49 – Friend Functions & Advanced OOP

Matrix Transposition – Use friend functions for transposition.
Ticket Reservation System – Manage ticket reservations/cancellations.
Fraction Addition – Add mixed fractions & return reduced form.
Distance Calculation – Compute travel distance using friend functions.

Key Takeaways:

Strengthened OOP concepts—constructors, destructors, static members, inline functions & friend functions.
Improved debugging & real-world problem-solving.

Challenges:

Optimizing recursive determinant calculation.
Managing shared/static data effectively.

This practice pushed my OOP proficiency to a new level!

What’s the most challenging OOP problem you’ve solved? Let’s discuss!

Week 6 : OOP Practice in C++

Adhyan Jain — Wed, 19 Mar 2025 13:58:39 +0000

This week, since my exams are going on, I focused on reinforcing my understanding of Object-Oriented Programming (OOP) in C++ through small but consistent practice sessions.

✅ Topics Practiced:

Class Objects – Built multiple object-based programs to strengthen my understanding of object creation and manipulation in different scenarios.
Constructors and Destructors – Practiced managing object lifecycle using constructors and destructors to improve memory handling.
Static Data Members and Functions – Created examples to understand where and when to use static data and functions to simplify object management.
Inline Functions – Worked on writing more efficient code by reducing function call overhead with inline functions.
Call by Reference – Practiced modifying function parameters directly using reference-based functions.
Functions with Default Arguments – Streamlined function calls by using default parameter values to handle different cases efficiently.
Friend Functions and Friend Classes – Developed programs to explore how friend functions and classes can access private data securely.

🏆 Key Takeaways:

✔️ Gained deeper insights into memory handling and object behavior.

✔️ Improved code efficiency with better use of constructors and inline functions.

✔️ Enhanced problem-solving speed by applying OOP concepts to real-world problems.

🚀 Challenges Faced:

➡️ Creating complex programs with friend functions and inline functions was tricky at first, but repetition and consistent practice made it easier!

🎯 This week was all about refining my OOP skills and improving coding efficiency. Despite the ongoing exams, I managed to make consistent progress!

👉 Have you struggled with friend functions or static data members? Let me know in the comments!

👉 Check out my GitHub for the code: https://github.com/adhyan-jain/CodeVault.git

CPlusPlus #OOP #Programming #Learning #Coding

Week 5 of C++ : Inheritance and Git

Adhyan Jain — Tue, 11 Mar 2025 17:34:09 +0000

This week focused on strengthening core C++ concepts, especially inheritance and version control with Git. Here’s a quick recap of what I worked on:

🔗 Git Basics (Day 29)

Started the week by setting up Git and exploring essential commands:

Initializing a repository and staging changes
Committing with meaningful messages
Resolving merge conflicts and understanding branching

Git is essential for tracking changes and collaborating on projects efficiently.

🔄 Single and Multilevel Inheritance (Day 30–31)

Explored how inheritance works in C++ and how constructors and destructors are handled:

Single Inheritance – Understanding base and derived classes
Multilevel Inheritance – Creating a hierarchy of inheritance

Understanding the constructor order and how inheritance affects object creation is key to building scalable applications.

📦 Multiple Inheritance and Ambiguity Resolution (Day 32–34)

Delved into complex inheritance structures and handling ambiguity:

Scope resolution operator for resolving conflicts
Virtual inheritance to avoid the diamond problem

Mastering these techniques is crucial for working with complex class hierarchies without ambiguity.

🎯 Virtual Base Classes (Day 35)

Explored virtual base classes to manage ambiguity in multiple inheritance:

Prevents multiple copies of the same base class
Ensures a single instance in complex inheritance hierarchies

Virtual inheritance simplifies the inheritance tree and avoids redundancy.

🔥 Key Takeaways

✅ Git helps track changes and collaborate effectively.

✅ Understanding constructor order in inheritance improves debugging.

✅ Virtual base classes are essential for resolving inheritance conflicts.

Next week, I’ll be focusing on polymorphism and operator overloading!

📌 GitHub: https://lnkd.in/ejDiCnej

📌 Blog: https://lnkd.in/euqENEc5

What are your thoughts on handling inheritance conflicts? Let me know in the comments!