C/C++ 3000: GNU For Advanced Students

Practice setting up a C++ file logger by creating era.hpp and era.cpp with include guards, define file class in a namespace, and include standard C library, string, time, and streams.

Wrap the era one namespace with a wrapper namespace, define a file type enum for text or binary, and implement constructors, a virtual destructor, and open for read and write.

Implement a C++ file class within a namespace, wiring headers, use get current directory with string streams, and expose open, read, write, append, close, and remove operations.

Create a C++ test driver by defining member functions and a main, use a namespace, print with cout, compile, fix errors, and expand test cases for code coverage.

Create and refine makefiles to compile C++ programs, link object files, produce executables, and define targets like all and clean with header include paths and macro-driven options.

Trace the evolution of C++ standards from 98/03 through 11 and beyond, preserving backward compatibility. Explore object oriented design, encapsulation, and the standard template library.

Demonstrate deprecation by marking a member function as deprecated and compiling to observe the deprecation error, following the training pattern for common test cases.

Learn to manage deprecated features in C++ with the -W deprecated warning, generate notes, and mark functions or classes as deprecated, while exploring locale and IO manipulators for currency formatting.

Explore modern C++ internationalization by recreating a locale-specific exercise using stream modifiers for currency, numbers, and dates. Build a complete header-driven project with a makefile to experiment with locales.

Explore the no return attribute in C++, how an unexpected return yields undefined behavior, and why compiler warnings prevent runtime errors.

Demonstrate managing runtime type information by modifying the makefile to build RTTI on and off, compare executable sizes, and note tradeoffs for dynamic_cast, typeid, and polymorphism in embedded contexts.

Explore how namespaces organize classes and enable multiple name spaces. Understand constructors, destructors, and the this pointer in object creation and destruction.

Extend an existing namespace to 0 1 and 0 2, update gatekeeper macros via the preprocessor, and duplicate header files to provide parallel implementations without inheritance.

Extend the header to track file changes with seedtime and stc time, initialize staff with memset, and use :: to call global file functions, then create file 0 2.

Update the makefile to define targets and dependencies for new files, ensure they are linked into the final executable, and modify the run rule to include the second namespace.

Update the test driver to include two namespaces with fully qualified files, enabling simultaneous use of both definitions and guiding the main driver to reference each namespace correctly.

Combine fully qualified names and preprocessor switches to select the correct namespaced object version for the main test driver, illustrating modern c++ namespace and type-definition techniques.

Explore instance management in c++ by tracing constructors and destructors, public and private members, and base-derived inheritance, highlighting creation–destruction order and safe cleanup.

Explore how polymorphism enables framework-driven design in C++ by using virtual functions and virtual destructors to call derived behavior through base pointers, while comparing state machines and function pointers.

explore slicing and virtual in c++ to enable polymorphism for frameworks using base pointers and directed construction to avoid diamond inheritance; implement big three and a float object with operators.

Examine cloning in C++, compare returning a pointer or reference, and copying the input value to conserve memory and reduce leaks.

Explore casting and inheritance in C++ with static_cast and dynamic_cast, focusing on RTTI, type identification, and safe downcasting within a model-view-controller framework.

Explains memory leaks in C++ caused by missing delete after new and by shared ownership during downcasting, slicing, or lacking deep copies, and highlights virtual destructors for safe cleanup.

Explore abstract classes and the clone pattern in C++ context, reviewing pure virtual functions, virtual destructors, and header versus implementation decisions.

examine makefiles and common targets, and explore runtime type information, dynamic_cast, and polymorphism in C++ projects, including null pointer handling and header include strategies.

Discover how default parameters and the receiving type cause slicing in factories; use a static factory with matching receiving type, private constructors, and avoid default parameters, even with virtual functions.

Discover the trade-offs of static factories and virtual factories in C/C++, exploring pointers, referents versus contents, and how is-a and has-a relationships shape class diagrams.

Apply C++ practices by building a shopping cart using standard templates, vectors, and headers, while learning makefiles, an abstract cart, and a versioned user data model.

Apply agile software design with abstract classes to manage sprints and iterative development. Model a web shopping cart featuring shopper and employee roles using top-down and bottom-up approaches.

Explore abstraction and project design by building an abstract clock class in C++, implementing a reusable show contract, and driving polymorphic clocks with a practical makefile.

Explore encapsulation in C++ by using an abstract base class with a protected constructor to model a shopping cart, online shopping scenarios, and versioned design with headers and the signature.

Extend the abstract clock by implementing get_time and a client show function, with a virtual destructor, and format time using struct tm for am/pm and military time.

Develop an abstract shopping cart with polymorphic pointers, apply sequence diagrams for orchestration, and drive test-first headers to build iterative lab solutions using model view controller concepts.

Extend a shopping cart with operator overloading to add integers and product identifiers using plus-equals and minus-equals, while managing arrays, enumerations, and versioned carts with makefiles.

Explore exhaustive test case design for a shopping cart, emphasizing CRUD (create, read, update, delete) tests, assertions, and automated builds to ensure robust, error-free code.

Explore shopping cart design with an abstract user card, employee discounts, and inline header definitions, then implement add and delete item operations in a protected, test-driven C++ workflow.

Explore template containership and overloading to create type-agnostic data containers and interoperable collections. Learn how templates define signatures and contracts, enabling vector-like structures and boost-style patterns across containers.

Examine how vectors operate with iterators and standard algorithms, using push back, find, erase, and size within metaclass defined contracts for sequence containers.

Explore parameterized types to store a vector of products in a shopping cart, replacing integers with a product struct, and building reusable libraries with makefiles.

Explore static versus dynamic libraries, linking with makefiles, and building a reusable library pattern that integrates a products database and shopping cart across projects.

Convert the shopping cart implementation from a static array to a vector of products, implement get balance and is available, and test with edge cases to ensure accurate pricing.

Explore concurrency concepts in C++ through thread safety, locking, and iterators, and learn how containers, typedefs, and const correctness support safe, efficient multithreaded code.

Compare list and vector metaclasses; list offers non-contiguous memory and fast middle insertions for long-running and embedded apps, while vector is faster and thread-safe, with different growth rules.

Explore testing frameworks by modeling contracts and signatures, using adapters and dynamic casting to test reusable containers and crud operations within a flexible framework.

Explore polymorphic product modeling in C++ by implementing an abstract product base, concrete company and affiliate products, and a cart and order relationship with a virtual destructor and name mangling.

Explore move semantics in modern c++ by detailing the big five or six operations: move and copy constructors, move and copy assignments, destructor, default and value constructors; test with vectors.

Implement the company cart and test the single order system, exploring UML diagrams as non-prescriptive guidelines, using inheritance and CRUD testing in main to verify behavior.

Master advanced template operations within a polymorphic framework using containers and emplace, insert, clear, and swap. Build and test a product list with string streams and make_product, focusing on crud.

Explore practical searching and sorting in C++ using iterators, begin and end concepts, and algorithms like find_if and binary search, with emphasis on auto, distance, and runtime type information.

Explore lambda operations in C++, focusing on anonymous function pointers, operator overloading, and sorting within template-based collections to support goal-seeking patterns and flexible data workflows.

Learn how to write and run tests for c++ collections using a makefile and cron jobs, explore set semantics for unique items, deep vs shallow copies, and prepare custom exceptions.

Explore creating a custom exception class in C++ using try, throw, and catch, leveraging the standard exception hierarchy, runtime type identification, and regression testing to signal test failures.

Learn to enforce consistent C/C++ code style with a makefile that generates another makefile, applying silang format with chromium style in place, and testing targets across C++98 and C++11.

Master the diamond inheritance dilemma in C++ by using virtual inheritance to ensure a single base initialization, prevent duplicate base objects, and implement directed object construction.

Master advanced bitwise techniques in C/C++ by shifting, masking, complementing, and dumping bit patterns to encode integers and visualize bytes for I/O ports.

Review cross-platform logging, CRUD workflows, and search capabilities, examining posix and windows path handling, current working directory access, and a custom file class.