Course: Programming in C++ - Part 1: Getting started with C++

Since its inception about three and a half decades ago, the C++ language has constantly reinvented itself and kept pace with changing times. This constant reinvention has kept C++ relevant for many use cases today. Explore the history of C++ and the difference between classic C++ and modern C++. Discover the compilation process of C++ and the role of the pre-processor, the compiler, and the linker. Look at the variety of compilers available for C++ and the C++ standard library. Finally, learn how to install C++ and write, compile, and run simple C++ programs. You will work with the MSYS2 collection of utilities and familiarize yourself with the VSCode integrated development environment (IDE). By the end of this course, you will have a solid foundation of the basics of C++ and a good sense of why C++ language features evolved the way they did.

Variables and datatypes are basic building blocks of any programming language. This is especially true for C++, which has a very complex type system. In this course, we will be reintroducing constructs from C and emphasize the differences between variables and datatypes in C++ relative to those in C. Start by considering the difference between the initialization and declaration of a variable. Explore arithmetic, relational, and logical operators and make use of the C++ boolean type. Finally, explore strings in C++ and utilize many of the powerful methods provided by the String class, which are available for use on all string objects. Upon completion, you'll be able to distinguish between variable declaration and initialization, initialize variables using functional, assignment, and braced syntax, and leverage the C++ boolean type and the std::string class.

C++ supports many different programming paradigms including object-oriented programming, functional programming, and template programming. As a result, the C++ type system is quite complex and it can get quite complicated to figure out the correct type for a variable Learn how to use the auto keyword to request that the compiler infer the type of a variable from its context. Discover how to use the typeid() function to get a type info object for every variable and to verify that the auto keyword has worked as intended. Next, explore enums and identify the differences between C-style and C++-style enums. Learn about input and output streams, in particular the cin and cout streams used in C++. Finally, discover how to use I/O manipulators to control the appearance of objects on these streams. After comleting this coures, you'll be able to utilize the auto keyword to infer the type of a variable and deploy IO manipulators to correctly format data on input and output streams.

Control structures in C++ are syntactically very similar to those in C, but with some important differences. This course will help you learn to use control structures in C++ and better understand how they differ from those in C. You will start this course by going over the control structures available in C++. You will then move on to working with vectors and iterators over vectors, which are important parts of the standard template library. Finally, you will work with switch statements and learn some tips and tricks related to working with cases based on strings. Upon completion, you'll be able to use variables in the condition of an if-block to restrict its scope, and use switch statements with hash functions and the STL map object to switch based on the values of a string.

One of the many differences between modern C++ and classic C++ is the presence of range-based for loops. These were added to the standard in C++11 and allow for loops to iterate easily over a container and reduce the risk of off-by-one errors. They also eliminate the need for an integer index variable to index into a container. Start this course by reviewing how for loops work to iterate over arrays. Create arrays with different numbers of dimensions and iterate over the dimensions using nested for loops. Discover how to use containers from the standard template library to experiment with maps and vectors. Explore the use of the cbegin(), cend(), rbegin(), rend(), crbegin(), and crend() functions. Finally, use range-based for loops and explore the use of the debugger in this context. You will also note the important differences between value type loop variables in for loops and reference type variables.

As a superset of C, C++ also has support for pointer variable types that point to specific memory locations. While the pointer types function similarly, the terms related to pointer variables have evolved from C to C++ and modern C++, as you will see in this course. Begin this course by creating pointers to values and arrays. You will then move to the use of the nullptr keyword, and see how it differs from the NULL value used in C. Finally, you will create pointers to vectors and maps. After completion of this course, you'll have a solid foundation of using pointers to stack memory locations in C++ and create pointers to vectors and maps.

C++, like C, has powerful support for memory allocation and deallocation. In the world of C, these operations are performed using malloc() and free(), which are not to be used in the C++ world. In classic C++, memory allocation and deallocation are performed using the new and delete operators. You will begin this course by understanding the new and delete keywords, and note how these lead to the invocation of the underlying constructors and destructors on whatever objects are being worked with. In contrast, the C versions, that is, malloc() and free(), do not invoke constructors or destructors. You will then move on to the use of array new and array delete, which is how the new and delete followed by square brackets are referred to. Finally, you will look at the differences between const pointers and pointers to consts.

Dynamic memory allocation and deallocation in C are performed using malloc() and free(). In classic C++, dynamic memory allocation and deallocation are performed using new and delete, and array new and array delete. In modern C++, it's smart pointers that take over. Begin this course by examining the idea behind smart pointers. You will then explore the different types of smart pointers, including unique pointers, shared pointers, and weak pointers. Discover why weak pointers are required in some cases to avoid circular references that can cause memory leaks. After completing this course, you'll be able to use smart pointer objects, leverage RAII to use shared, unique, and weak pointers, and avoid circular references using weak pointers.

C++ supports a variable type known as the reference. You can think of references as being easier-to-use, lighter-weight versions of pointers. Begin by getting familiar with the syntax and semantics of references in C++, including the use of the & symbol to denote a reference type. Note some important differences between references and pointers, how references need to be assigned when they are created, how they cannot be reassigned or set to NULL, and how multiple references to the same underlying value are all effectively aliases for that value. Move on to declaring and using variables of reference type. Finally, learn about const references and experiment with different configurations of loops, where the loop variables are references, value types, and const references. Upon course completion, you'll be able to define and initialize variables of reference types, contrast pointers and references, and correctly use const references.

Functions remain an important construct for code modularization and reuse in C++, even though C++ is an object-oriented language. Learn how to use functions in C++, focusing on free functions, and examine the distinction between declaring a function, where you specify the function's signature, return type, and name; defining a function, where you create the body of a function; and invoking the function. Then, explore the semantics of passing parameters by value to C++ functions. Finally, compare pass-by-reference semantics to pass-by-value semantics and investigate the differences. Upon completion of this course, you will be able to use pass-by-value and pass-by-reference semantics in the context of function invocation in C++.

C++ allows you as the developer to specify default values for the input arguments into your functions, and supports function overloading. Both of these are powerful techniques for code reuse. Explore how to use default argument values for C++ functions, including important rules that govern such default values. Examine the semantics of return values from functions and learn how to avoid the dangling pointer problem. Discover function overloading, learn how to split the declaration and implementation of a function across header and implementation files, and learn the correct way of importing these header files into code to invoke that function. Upon completion, you'll be able to specify default values for function arguments, overload functions based on input arguments and const, and split functions across .h and .cpp files.

In the Getting Started with C++ lab, you will use C++ to modify strings, manage inputs, create switch statements, implement arrays and allocate memory on Heap.

Final Exam: Getting Started in C++ will test your knowledge and application of the topics presented throughout the Getting Started in C++ track of the Skillsoft Aspire Programming in C++ Journey.