C++ Learning Path: From Basics to Advanced Projects

Delve into C++ from basics to advanced topics, covering enumerations, enum classes, structs, dynamic memory allocation, for each loops, vectors, arrays, stack and heap, and classes, inheritance, and polymorphism.

Learn how to define and use enums in C++, including enum syntax, enumerators, trailing comma rules, naming conventions, and printing or input via switch and static_cast.

Continue the c++ enumeration chapter by examining allocations and forward declarations, and show how header-defined enums replace magic numbers with descriptive file result values for readability.

Learn how enum classes in C++11 enforce strong typing and scope, preventing cross-enum comparisons, and explore accessing, comparing, and casting their underlying values.

Explore typedef and type aliases to create readable names for existing data types. See how to declare aliases, adopt the t-suffix convention, and switch underlying types with minimal changes.

Learn how to define and use structs in C++, group related variables into a ship struct, access members with the dot operator, and initialize with initializer lists or uniform initialization.

Explore how to pass and return structs in C++, including by value, nested structs like employee and company, and vectors; understand size, padding, and cross-file declarations.

explore how the auto keyword enables type inference in modern c++11, replacing explicit types for initialized variables and guiding return type deduction, while noting limits for function parameters.

Explore dynamic memory allocation in C++, using the heap with new and delete, manage pointers, avoid memory leaks and dangling pointers, and use null pointers safely.

Learn how pointers and references interact with structs using a weapon struct with rate of fire and max ammo, and access members via dot, reference, or arrow operator.

The lecture introduces the for each loop, a range-based loop in C++11, showing safe iteration of arrays and vectors with auto, references, and const, compared to traditional for loops.

Master std::vector, a dynamic array with automatic memory management that removes manual allocation. Initialize, query size, resize, and iterate, including boolean vectors, and compare with built-in arrays.

Explore std::array in C++11, learn how it fixes fixed arrays, prevents decay to pointers, and provides size(), at(), begin(), end(), and safe bounds checking compared to raw arrays.

Explore how C++ functions return values by value, by address, and by reference; learn safety, performance, and when to use struct, tuple, or structured bindings for multiple values.

Explore how the stack and heap memory segments organize a program, how the call stack tracks active functions, how heap allocation via new works, and how stack overflow can occur.

Explore recursive functions through a practical countdown timer, termination conditions, and call stack behavior. Analyze push and pop order, base cases, and how sums and factorials illustrate recursion.

Learn object oriented programming in C++, covering classes, constructors, variable initialization, and the scope operator, with public private protected access and struct and union concepts.

Learn about c++ constructors, initialize class members with default and overloaded constructors, and calculate rectangle area. Compare functional, assignment, and uniform initialization and use member initialization lists.

Explore pointers to classes with new and delete, memory management, and dot and arrow operators, using a rectangle example that calculates area, default access rules for class, struct, and union.

Master overloading operators for C++ classes, including arithmetic and insertion operators, and apply the this keyword. Explore static members, const member functions, and the basics of class templates.

Explore const member functions and const objects in C++, learn how to declare and use const functions, and master class templates, including a value pair template and template specialization.

Explore special member functions in C++, including default, copy, and move constructors and assignments, plus destructors, with focus on deep vs shallow copying and memory cleanup.

Explore copy and move semantics in C++, implement deep copy in copy assignment, understand move constructors, rvalue references, unnamed temporaries, and the role of default and delete.

Explore how friend functions and friend classes grant access to private and protected members, using examples with rectangle and square, including forward declaration and a convert and duplicate workflow.

Explore how C++ inheritance works with a polygon base class and rectangle and triangle derived classes, including public protected private inheritance, access to width and height, and area calculations.

Explore multiple inheritance in C++ by combining polygon with an output class to create rectangle and triangle, sharing width, height, and area calculations while printing results.

Explore polymorphism in c++ by using base and derived classes, virtual functions, and base-class pointers to compute areas for rectangle and triangle.

Explore polymorphism in C++, focusing on abstract base classes and pure virtual functions, and learn how to use pointers and dynamic memory to resolve virtual calls.

Explore using the C++ graphics library to create on-screen scenery, focusing on coordinate placement, color, and GUI basics for beginners, including plotting objects and understanding function parameters.

A beginner-friendly project using the C++ graphics library to build a scenery with a rising sun, mountains, a house, and a tree, with options to evolve into dynamic GUI scenes.

Set up the graphics driver and graphics mode in a C++ project by including graphics.h and initializing gd and gm with initgraph, providing the PGI folder path.

Initialize the graphics library, set brown color, and draw mountains by plotting successive line segments to form a triangular range while keeping fills within boundaries.

Learn to draw mountains in c++ by using a for loop to plot alternating lines, then color each triangle with flood fill and add a sun via an arc.

Plot sun rays around an arc by iteratively adjusting line coordinates with the line function, tuning center coordinates, radius, and start and end values to shape each ray.

Plot the sun and house using rectangle and line functions, adjust coordinates through trial and error, and add a roof, windows, and a door.

Plot the house features by calculating midpoints and coordinates. Draw the door and windows with line and rectangle functions, using the graphics library to position elements precisely.

Plot two trees with a brown trunk using a rectangle and green triangular foliage. Adjust coordinates and duplicate the same functions to add a second tree and a pond.

Draw the pond with the ellipse function, specifying center coordinates, start and end angles, width and height, then use the line function to draw green grass around it.

Continue plotting the grass on both sides of the pond, adjusting the coordinates along the x and y axes, and bordering the scenery while preparing to add color.

Plot pandemic statistics for ten countries with a C++ graphics bar graph, 50 calibrations for axis scaling, and continuous input loops.

Explains how to set up a C++ graphics project in turbo c, including headers iostream.h, conio.h, graphics.h, and initializing graphics with detect and initgraph via the PGI path.

Configure a graphics-based C++ program to set font, viewport, and clipping, then collect ten country names and populations using 2D and 1D arrays with a for loop.

Accept country names and populations into an array, print each country with its population, determine the maximum for calibrating the y axis, and plot using max x and max y.

Plot the x and y axes using the line function from graphics.h, calculating dynamic start coordinates and labeling axes with out text x y to reserve space for country names.

Plot country names on the x axis by calibrating axes and printing labels at coordinates. Use a fixed 60-pixel gap and a text function to display ten country labels.

Discover how to partition the y axis in a C++ graph by deriving partition size from the maximum population, mapping calibrations, and displaying labels with sprintf.

Map each country's population to a bar graph by iterating with a for loop, mapping via partitions and calibrations, and rendering rectangles to the screen.

Plot and render bars as rectangles by calculating x and y coordinates, bar thickness, and gaps, using a do-while loop to continue with input from stdio.h's get function.

Test your C++ code by compiling and running with real country population data, accepting country names, and plotting population graphs interactively.

Learn to draw bar, pie, and line charts in C++ using graphics commands and a Cartesian coordinate system for sales management dashboards.

Draw a bar chart in c++ by entering yearly sales data using printf and scanf, including header files and simple i/o in turbo c++.

Learn to draw a bar chart in c++ graphics by initializing graphics mode, computing pixel coordinates, scaling data to bar heights, and drawing axes using line commands and colored bars.

Learn to draw a bar chart in graphics mode using the bar command, calculating bar heights from data, setting red fill color, and annotating bars with text via integer-to-string conversion.

Explore building a multi-year bar chart in graphics mode, converting integers to text and printing year labels while applying color coding for 1996–1999 sales data.

Run the program to compile and link the C graphics bar chart, then enter data values like 60, 80, 100, and 120 to display the 1996–1999 bars.

Learn to draw a pie chart in C++ using graphics mode, building on bar chart groundwork and including graphics initialization, sales data input, and pie slice geometry.

Draw a pie chart in C++ graphics by converting four years of data (1996–1999) into start and end angles that sum to 360, then render colored slices counterclockwise.

Draw organograms on the screen using C++ graphics commands. Explore the four organogram types: flat, divisional, functional, and matrix, and understand their structures.

Learn how inheritance in C++ lets derived classes inherit properties from a base class, using public, protected, and private modes; this reduces duplication and increases reusability.

Open the C++ IDE, include stdio, conio.h, iostream, graphics.h, and initialize graphics mode. Define a base class for drawing an organogram that outputs lines, squares, circles, and text at coordinates.

Define a base class Organology with a constructor and output function, then derive a subclass to adjust line pixels and manage screen text rendering.

Develop derived classes from the base Organology class using public inheritance, implementing draw and output to render squares, rectangles, lines, and circles in a graphics mode and restore CRT mode.

Define horizontal and vertical line classes derived from a base organogram class, implement draw functions for lines, square, and circle, and render text in a graphics-based organogram program.

Call the circle draw function and render a divisional organogram with the manager at the top, then display SUV and sedan design, production, and sales branches.

Run the program in the C++ IDE to compile and verify the organogram, detailing a divisional structure with two products and product-wise departments.

Draw a typical organogram in C++, using circles, rectangles, and lines, positioning roles like CEO, production manager, and sales manager with pixel coordinates.

Define a diamond class derived from the organogram base class and implement drawing routines to render a flowchart with an isosceles triangle and a diamond shape on screen.

Develop a practice program to draw a line and a flowchart on screen using derived line classes with a draw function.

Run the program to draw a flowchart and organogram types from a base Organology class to derived shapes. Explore how flowchart visuals of rectangles, diamonds, and T junctions support development.