C/C++ 2000: GNU For Intermediate Students

An intermediate C and C++ training overview that blends legacy concepts with modern C++, covering data types, structures, classes, encapsulation, polymorphism, and practical tooling for robotics-focused projects.

Explore the paradigm shift of object-oriented programming, from spaghetti code to self-documenting objects that model a problem domain, and learn refactoring, naming conventions, and C/C++ standards.

Explore the evolution of C++ from 98 through 11 and 14 toward future standards, emphasize recompilation, template and library changes, and the role of UML diagrams in requirements elicitation.

Set up the GNU C/C++ study environment on Windows with cygwin, download and extract study 1000, and explore generations of C++ using stdio.h, C standard IO, and iostream with namespaces.

Review the GNU toolchain from the command line through preprocessor, compiler, and linker stages, and learn how symbols and debugging with gdb fit into building portable C/C++ code.

Explore environment variables and PATH influence header search and make files behavior across Windows and POSIX. Recognize portability risks, include path nuances, and importance of readme notes documenting environment dependencies.

Explore the GNU c/c++ toolchain and code creation, from ascii editors and internationalization issues to main signatures, code and data segments, and return value optimization.

Explore the C++ toolchain from ascii editor to preprocessor, compiler, linker, and executable, then learn to build projects with makefiles, lab solutions, and open source code on GitHub.

Use g++ -g to include symbols, then debug by disassembling main and inspecting stack parameters and printf calls, while exploring name mangling and demangling.

Learn forward declarations and how headers versus implementations organize code in C++. Use headers as a calling card to enable encapsulation, data hiding, and namespace separation.

Create a common header named unify to centralize system header inclusions, enforce a consistent include order, and prevent bugs from multiple inclusions. Use a unique gatekeeper macro for single-point updates across files.

Update your solution quickly in about five minutes by retrieving what you need from the provided file and the tool, then simply update it.

Explore exception management in C++ using try, catch, and throw to handle errors, prevent crashes, and take corrective actions when operations fail.

Explore preprocessor concepts in C/C++, including macros, undefining, and conditional compilation, plus diagnostics with __FILE__, __LINE__, __DATE__, and __TIME__ to aid debugging across devices and applications.

Explore macros and inline functions in c/c++: use define and preprocessor tricks, compare inline expansion to function calls, and understand when copying code is more efficient than parameterized calls.

Explore how references act as syntactic sugar that converts to pointers, ensuring valid targets and enabling safe passing, overloading, and polymorphism through name mangling.

Learn how default parameters let functions be called with fewer arguments, test their behavior, and use overloading and name mangling to select among multiple parameter signatures.

Revisit overloading in C++ by examining stack versus heap allocation and the role of new. Explore return value optimization, references, and printf formatting.

Namespaces prevent collisions and ambiguity by qualifying names like namespace::log, support multiple versions, and use using or typedef to map to the standard namespace and macros.

Explore how state machines and function pointers enable a programmable calculator, using typedefs to define interchangeable types and switch behaviors on the fly.

Explore how to implement finite state machines with function pointers and arrays in C++, using shared signatures, enums, and simple structures to manage states and transitions.

Review primitive data types and register sizes. Explain how strings are null-terminated character arrays and explore memory representation, plus a dumper program that prints values with format specifiers.

Explore cross-platform data types and character sizes, comparing signed and unsigned chars, wchar_t sizes, and how bit patterns affect value interpretation across compilers and platforms.

Review logical data types in C/C++ and bool keyword, noting obsolescence of all-uppercase macros. Explain shortcut operator behavior and its effect on function calls and boolean to integer promotion.

Explore integer data type sizes across architectures, and learn about l value and r value, modulus and other operators in C and C++.

Review arrays and strings in C and C++, examine null-terminated strings and various termination conventions, and learn how pointers, array sizes, and argv influence memory and command-line limits.

Explore string and array activity: how name mangling forces const char* in puts, why non-const pointers trigger warnings or compile errors, and how C++98/03 differ from C++11/14 in legacy code.

Trace the shift from C strings to the modern C++ standard library, covering IO streams, the Boost effort, and the string class, and examine buffer handling and safety concerns.

Learn to manage uninitialized buffers in C and C++ using memset, zero-filled buffers, and string classes, while embracing locale-aware I/O and evolving C++ standards and headers.

Explore the migration from c standard input and standard output to c++ streams, using cin, cout, and getline with string, and learn about operator overloading and its potential pitfalls.

Explore C++ stream-based I/O with encapsulated operations, including ofstream and ifstream, text and binary modes, and operator<< overloading, to read, write, seek, and flush data efficiently.

Learn to view streams as a framework that reads, writes, and formats bytes across devices, and design signature-based classes with typedefs to support multiple string implementations and operator overloads.

Examine how a C++ struct mirrors a class, with default public visibility, and how a function pointer inside a struct can yield a class while wrapping legacy C types.

Explore C++ classes and structs, understand public, private, and protected access, and distinguish mutators and accessors within a practical API wrapper that enforces a stable public contract.

Design frameworks and object relationships in C++ with public, protected, private, and friend access, while implementing a shopping cart total data class through mutators, accessors, and overloaded getters.

Explore how the this pointer operates with dynamic memory, highlighting pointers, namespaces, and encapsulation, and how to manage multiple mains with a makefile for C/C++ projects.

This lecture explains how C++ standard versions affect code, showing non-static data member initializers and the role of constructors in initializing objects across standards.

Explore static initialization with inside or outside the class constants, uppercase naming, and preprocessor options for backward-compatible C++11/14 code, typically using the constructor.

Explore object factories and polymorphism in C++, using user data, web shopper, and employee. Override balance with virtual functions to adapt price across roles.

Explore inheritance strategies by examining base classes, parent classes, protected access, and how default parameters and a multiplier flow through derived classes using static_cast and dynamic_cast.

Explore object factories in C++, using a factory to create polymorphic objects via pointers, dynamic_cast and static_cast, and manage lifetimes with new and delete, avoiding memory leaks with smart pointers.

Explore C++ memory management, including dynamic allocation and proper pairing of new and delete. Learn to use delete[] for arrays to prevent memory leaks.

Learn polymorphic factories in c++, creating a web shopper with a factory pointer that returns a web shop pointer, sets multipliers, retrieves balance, and handles memory with delete and casts.

Explore the object lifecycle in C++ as you learn how constructors initialize objects, copy constructors and destructors manage lifetimes, and operator= with inheritance and stack allocation.

Explore scope and visibility in c++ by tailoring public, protected, and private access, using dynamic_cast, a factory, and constructors, and updating tests with copy and value constructors and accessors.

Learn how to modernize legacy C++ code by blending old and new techniques with fstream, getline, and standard algorithms, while counting lines and using io streams.

Learn to implement robust file logging in C and C++ by opening or creating log files, appending data, flushing to disk, and handling time values and locales.

Learn to implement a safe api wrapper around POSIX time structures, using global namespace access, const correctness, and defensive coding to shield users from implementation details.

Explore implementing an easy log using Julian days, string stream, and local time, showcasing auto type conversion, copy constructors, RVO, and test-driven development.

Build and run the lab solution in C++ with a makefile, targeting the act_easy_log program. Use the compiler flag to include headers from the headers directory.