1 Introduction ^

This course is intended to give the students a good understanding of computing, solid programming skills in C and C++, experience with debugging, optimization, algorithm design, and numerical calculations, and the ability to produce high-quality and well-organized scientific software, both on their own and in collaboration with others. Please see the table of contents of the lecture notes for a detailed outline of the course.

This is an advanced graduate-level course, and is not intended to be a first introduction to programming. Therefore, students must possess basic prior knowledge of some programming language (any language will do) in order to take this course.

1.1 A short overview of programming languages

1.1.1 Machine code and assembly language

There are hundreds of programming languages, and they can be categorized according to their level, which roughly indicates how close the language is to the way the computer actually operates at the hardware level. The lowest-level language is machine code, the binary instructions that are executed directly by the CPU.

However, machine code is intended for CPUs, not for humans, and programmers never write machine code directly, which would be an extremely tedious task. Instead, code is generally written in higher-level languages, and this code is then automatically translated to machine code so that it can actually run on the CPU.

A slightly higher-level language is assembly language, which is basically a way to write machine code directly in a language that humans can understand. Assembly language first appeared in 1949, years ago! Assembly code still tells the CPU exactly what to do and how to do it - but with human-readable characters instead of binary codes.

Theoretically, you could write your programs in assembly, but that would be almost as tedious as writing machine code. Furthermore, both assembly language and machine code differ from one CPU type to another; if you write code that will run on a particular CPU, and you want to run it on a different CPU, you will need to rewrite it.

1.1.2 C and C++ ^

The next higher level after assembly is that of C and similar languages. C is one of the oldest programming languages in common use today, created in 1972, years ago. This language adds a level of abstraction on top of assembly language; instead of telling the CPU directly what to do, you can define abstract entities such as variables and functions, and use them in human-readable statements that resemble spoken language.

A program called the compiler then translates these abstract statements to machine code. This has the great advantage that you can write one C program and then use different compilers to compile the exact same program to machine code for a variety of different CPUs. You can think of C as "portable assembly".

C is essentially the lowest-level language humans can efficiently write code in, and it provides the programmer with direct, low-level access to the computer's hardware. For this reason, it is often used to write the operating systems on which other programs run, the device drivers which provide an interface between software and hardware, and the compilers and interpreters which translate other programming languages (including all the ones listed below!) to machine code.

Embedded systems in a variety of devices, from digital watches to electric cars, also use C almost exclusively due to their very limited resources, as higher-level programming languages generally require more resources to operate.

A slightly higher level is that of C++ and similar languages. C++ is basically an extension of C which adds object-oriented programming, and it was created in 1985, years ago. C++ adds an additional level of abstraction over C by allowing the programmer to define abstract entities called classes. We will see exactly what this means when we learn C++ later in the course. C++ is generally preferable to C for large-scale applications which can benefit from the increased abstraction.

C and C++ are sometimes called "mid-level languages" because they are located in the middle between assembly language and higher-level languages. While higher-level programming languages offer more abstraction, which often simplifies the language and shortens development time, they are also slower and less flexible.

Programs written in C and C++ generally run much faster than programs written in higher-level programming languages, and therefore they are especially suitable for applications where performance is of the utmost importance, including, of course, scientific computing.

1.1.3 Higher-level languages ^

At the next higher level we have Java, C# (pronounced "C sharp"), and similar languages. These languages are newer (Java appeared in 1995 and C# in 2000), and they don't allow the programmer as much freedom or flexibility as C and C++ do. For example, instead of allowing direct access to the computer's memory, Java and C# manage the memory themselves; this is also called garbage collection. Although this can prevent problems such as accessing the wrong memory address, it also incurs a performance penalty.

Finally, at the highest level we have interpreted languages such as Python and JavaScript. The languages we discussed up until now are compiled languages, which means the entire code is first translated to machine code using a compiler, and only then can be executed. In contrast, interpreted languages run using an interpreter, which reads the source code and executes it line-by-line.

This has the advantage of being able to instantly run the same source code on any platform using a suitable interpreter, whereas compiled languages require compiling the source code separately for each type of CPU and operating system.

The programming languages we mentioned here - C, C++, Java, C#, Python, and JavaScript - are considered to be the most popular programming languages right now. However, there are hundreds of other languages, including some that are specifically intended for scientific computing, such as Mathematica. In this course, we will focus on C and C++, since they are the fastest and thus most suitable for scientific programming.

1.2 Installing the IDE and compiler ^

1.2.1 Installing Visual Studio Code

Throughout this course, we will be using the Visual Studio Code IDE (Integrated Development Environment). It provides a convenient GUI (Graphical User Interface) for writing programs in a variety of programming languages, as well as incredibly useful tools such as syntax highlighting, code completion, automatic code formatting, debugging, version control, and much more.

Visual Studio Code is one of the most popular IDEs, used by millions of developers, and has a huge selection of extensions that provide additional functionality. It is also cross-platform, so you can use it on either Windows, Linux, or Mac. To install the IDE, visit the website, click on the "Download" button, and run the downloaded file. The 64-bit version, which is the one you should be using, will download by default.

During installation, in the "Select Additional Tasks" page, make sure to select the following options:

• Add an "Open with Code" action to file and directory context menus.
• Register Code as an editor for supported file types.
• Add to PATH.

After you finish installing the app, launch it and click on View > Extensions in the menu bar. You can also use the keyboard shortcut Ctrl+Shift+X (note that the keyboard shortcuts I will be using here are for Windows and Linux, but on Mac you usually just need to replace "Ctrl" with "Command"). Yet another option is to click on the Extensions icon, which looks like four squares and should be the bottom one in the bar to the left.

In the Extensions side bar, type "C++" and you should find the C/C++ extension by Microsoft. Simply click on the "Install" button to install the extension, which will allow you to use the IDE to write, compile, and debug C/C++ code. Alternatively, you can use this link to install the extension directly from your browser.

This is the only extension you need if you plan to use the GCC or MSVC compilers. However, if you wish to use the Clang compiler, which is the one I recommend for this course, you will also need to install the extension CodeLLDB.

One last thing: press Ctrl+, to open the Settings page (or choose File > Preferences > Settings in the menu), then search for the setting C_Cpp.codeAnalysis.clangTidy.enabled and enable it. This will turn on clang-tidy, a very useful linter (code analysis tool) which will help you detect and avoid many common errors.

1.2.2 Installing a compiler ^

The next step is to install a C/C++ compiler. There are plenty of compilers out there, but the most popular ones are:

• For Windows: Clang (which is part of the LLVM project), GCC (the GNU Compiler Collection), or MSVC (Microsoft Visual C++).
• For Linux: Clang or GCC.
• For macOS: Only Clang.

Since students using macOS are restricted to using Clang only, all students are encouraged to use Clang, so that everyone in the class uses the same compiler. However, students using Windows and Linux are also free to use GCC, which is highly compatible with Clang. (It is technically possible to install GCC on macOS, but it's unnecessarily complicated, so I recommend not bothering with it at this point.)

I do not recommend using MSVC in this course; it's a perfectly good compiler, but it is unique to Windows, and has a different command line syntax than the other two compilers, so any compiler commands used in these lecture notes (e.g. to enable warnings) will not work on MSVC. However, when you write your own C++ projects, I do recommend to always test them on Windows using all 3 compilers, to ensure maximum compatibility.

Installing Clang on Windows

To install Clang on Windows, go the the LLVM download page. The latest version will be at the top of the page, and there will be a link to download it on the GitHub release page. Click on that, and then download one of the following files (where X.Y.Z is the version number):

• LLVM-X.Y.Z-win64.exe if you have an Intel or AMD CPU. This is the option relevant for most people.
• LLVM-X.Y.Z-woa64.exe if you have an ARM-based CPU, such as Qualcomm Snapdragon.

Run the downloaded file, and when prompted, choose the option "Add LLVM to the system PATH" - either for all users or for the current user.

Next, go to this page, scroll down to "Tools for Visual Studio", then click "Download" next to "Build Tools for Visual Studio". Run the downloaded file, then choose the option "desktop development with C++". To the right, if you wish, you can uncheck all the optional components, except for two: MSVC and the Windows SDK (which should be the first two on the list). Then finish the installation and you're good to go!

If you prefer to use GCC, you can follow these instructions.

Installing Clang on Linux

To install Clang on Linux, an easy one-line installation script is provided on the LLVM website. Simply open the terminal and run the following command:

sudo bash -c "$(wget -O - https://apt.llvm.org/llvm.sh)"

This should install the latest version. Type clang -v to verify that it works. If it doesn't, you may have to link the clang command to the specific version that was installed. You can do that by typing CLANG_VER=X in the terminal, where X is the first number in the version number X.Y.Z of the latest release, and then running the following command:

sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-$CLANG_VER 100 --slave /usr/bin/clang++ clang++ /usr/bin/clang++-$CLANG_VER

Installing Clang on macOS

On macOS, Apple Clang will be installed automatically if you type clang in the terminal. However, Apple Clang is not the same as Clang, and does not support more advanced features such as C++20 modules. Therefore, macOS users should install the latest version of Clang using Homebrew. First, install Homebrew by running the following command in the terminal:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Then install Clang by typing the following command:

brew install llvm

To make Clang the default compiler instead of Apple Clang, make sure you run these commands in the terminal:

echo 'export PATH="/usr/local/opt/llvm/bin:$PATH"' >> ~/.zshrc
echo 'export LDFLAGS="-L/usr/local/opt/llvm/lib"' >> ~/.zshrc
echo 'export CPPFLAGS="-I/usr/local/opt/llvm/include"' >> ~/.zshrc

Alternatively, you can also edit the file .zshrc in your home directory and add the export commands manually. Note: You may need to modify these commands if LLVM was installed in a different folder. When you install the package, it will let you know where it was installed and exactly what commands you need to run.

Now, restart the terminal, and type clang -v to check that you have the latest version and that it says "Homebrew clang" instead of "Apple clang".

If it still says "Apple clang", please consult the Internet for a solution; otherwise, you may have to use Clang from the Homebrew installation folder directly. Usually, this folder is /usr/local/opt/llvm/bin/, so the C compiler will be /usr/local/opt/llvm/bin/clang and the C++ compiler will be /usr/local/opt/llvm/bin/clang++.

Note: To run and debug your compiled programs, you may have to execute the command sudo DevToolsSecurity -enable in the terminal.

1.2.3 Creating and configuring your first program ^

After installing the compiler, first create a new empty folder in which to save your code, e.g. a folder named CSE701 in your home directory. Now open Visual Studio Code, click on File > Open Folder... or press Ctrl+K Ctrl+O, and open the folder you created (you can also create the folder directly from the "Open Folder" window). Alternatively, if you enabled the option to add an "Open with Code" action to the context menu during installation, you should be able to simply right-click the folder and choose "Open with Code".

If you get a window that asks "do you trust the authors of the files in this folder", select "yes" (unless you don't trust yourself). You should now see the folder in the Explorer side bar, which is accessible by clicking the top button on the left, or choosing View > Explorer in the menu, or pressing Ctrl+Shift+E. However, it does not have any files yet.

Next, right-click in an empty space of the Explorer side bar and select "New File". Name your file hello.c. The file will be automatically opened in the editor (if not, just double-click on it). Copy and paste the following code into the file:

#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");
}

Click File > Save or Ctrl+S to save the file. This is the source code for the program, but we still need to tell VS Code how to compile it.

Go to View > Command Palette... or press F1 or Ctrl+Shift+P. This will open the Command Palette. Start writing "config" and choose the option C/C++: Edit Configurations (UI) when it appears. Under "Compiler path", choose the path to the clang binary (it will be clang.exe on Windows), and under "IntelliSense mode", choose <your OS>-clang-<your architecture>, where the architecture should be x64 for Intel or AMD CPUs or arm64 for ARM-based CPUs such as Qualcomm Snapdragon or Apple Silicon. For C standard choose c23, and for C++ standard choose c++23 (although that won't be relevant right now).

You will notice that a folder named .vscode has been created in your workspace folder, with a file named c_cpp_properties.json inside it. If you double-click on that file in the Explorer side bar, you will see that the contents correspond to the configuration you chose.

Now, with hello.c open in the active editor, click on Terminal > Configure Default Build Task, or open the Command Palette by pressing F1 and look up "build" to find that command. Then choose the option with clang from the drop-down menu. A file named tasks.json will be created in the .vscode folder, and opened automatically in the editor. This file contains information about how to compile your code.

By default, the args field in tasks.json should look something like this (here I am showing how it looks on Windows):

"args": [
    "-g",
    "${file}",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe"
],

Let us add some more compiler arguments (also called flags). First, the arguments -Wall, -Wextra, -Wconversion, -Wsign-conversion, and -Wshadow will instruct the compiler to warn us about many different types of common mistakes. VS Code will then display these warnings right in the editor. This is an incredibly useful feature, which will automatically detect and help prevent potential bugs in our code.

In addition, -Wpedantic and -std=c23 will instruct Clang to comply with the ISO C23 standard (the most recent standard, published in 2024), which will ensure that our program is maximally portable and can be compiled on other standards-complying compilers without too much hassle.

The end result (on Windows) should look similar to this:

"args": [
    "-g",
    "${file}",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe",
    "-Wall",
    "-Wextra",
    "-Wconversion",
    "-Wsign-conversion",
    "-Wshadow",
    "-Wpedantic",
    "-std=c23"
],

I highlighted the new text. Make sure that each argument, both the old ones that were already there and the new ones that you added, is inside quotes, on a line of its own, and with a comma at the end of the line, except for the last one. Then save tasks.json.

Note that the first few lines will look different if you're using a different OS, but what's important is that you add the new arguments at the end as shown in the highlighted text. Also, VS Code may have added the arguments -fcolor-diagnostics and -fansi-escape-codes when it created the build task, and if so, you should keep them there.

With the hello.c tab open in the editor, click on the "Run and Debug" on the left (it looks like a "play" button with a little bug next to it), or press Ctrl+Shift+D. This will open the Run view, used for debugging. Click on "create a launch.json file", and choose "LLDB" from the drop-down menu. (Note: The option should just be "LLDB", not "C++ (GDB/LLDB)".) If you don't see the "LLDB" option, make sure you installed the CodeLLDB extension as instructed above.

This file is not usable yet, because (at least at the time of writing these instructions) the CodeLLDB extension doesn't provide usable default settings. To fix that, go back to tasks.json and find the compiler argument containing the name of the executable file to be created, which is the one following the "-o" argument. On Windows, it will be "${fileDirname}\\${fileBasenameNoExtension}.exe", and on other platforms it will be similar but with forward slashes and without the .exe extension, i.e. "${fileDirname}/${fileBasenameNoExtension}". Copy that file name, go back to launch.json, and paste it after "program":, instead of the default value. Make sure to keep the quotes and the comma at the end of the line.

Finally, in launch.json, go to the last line in the "configurations" section, which is the line before the curly brackets, which should say "cwd": "${workspaceFolder}". Add a comma at the end of this line and press Enter. Then write a quotes character ". VS Code will automatically show a list of options; choose the option preLaunchTask, and then choose the name of the build task you created, which should be "C/C++: clang.exe build active file" (without the .exe on Linux or macOS). This should add the following line:

"preLaunchTask": "C/C++: clang.exe build active file"

1.2.4 The JSON configuration files ^

For your convenience, here are examples for how the three JSON files in the .vscode folder should look like. These examples will work on Windows, as long as the compiler has been added to the PATH environment variable as explained in the previous section. Later in the course we will learn more about how to customize these files. (Comments following // characters were added by me.)

c_cpp_properties.json:

{
    "configurations": [
        {
            "name": "Win32", // Will be a different name for Linux/macOS
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "compilerPath": "C:/Program Files/LLVM/bin/clang.exe", // Will be /usr/bin/clang or similar for Linux/macOS
            "cStandard": "c23",
            "cppStandard": "c++23",
            "intelliSenseMode": "windows-clang-x64" // OS and architecture will be different for Linux/macOS and/or for ARM CPUs
        }
    ],
    "version": 4
}

tasks.json:

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: clang.exe build active file",
            "command": "C:/Program Files/LLVM/bin/clang.exe", // Will be /usr/bin/clang or similar for Linux/macOS
            "args": [
                "-fcolor-diagnostics",
                "-fansi-escape-codes",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}\\${fileBasenameNoExtension}.exe", // Will be ${fileDirname}/${fileBasenameNoExtension} for Linux/macOS
                "-Wall",
                "-Wextra",
                "-Wconversion",
                "-Wsign-conversion",
                "-Wshadow",
                "-Wpedantic",
                "-std=c23"
            ],
            "options": {
                "cwd": "C:/Program Files/LLVM/bin"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "compiler: C:/Program Files/LLVM/bin/clang.exe" // Will be /usr/bin/clang or similar for Linux/macOS
        }
    ]
}

launch.json:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "lldb",
            "request": "launch",
            "name": "Debug",
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe", // Will be ${fileDirname}/${fileBasenameNoExtension} for Linux/macOS
            "args": [],
            "cwd": "${workspaceFolder}",
            "preLaunchTask": "C/C++: clang.exe build active file"
        }
    ]
}

Now it is finally time to run our Hello World program! With hello.c open in the active editor, press F5 or choose Run > Start Debugging in the menu. On the bottom of the page, select the Terminal panel; if you can't see it, click View > Terminal or Ctrl+`. You should see the message "Hello, World!" there.

Congratulations, you just compiled, ran, and (sort of) debugged your first C program! To run it again, simply press F5 again when you are in the editor tab for hello.c. You should also try changing the program a bit and see what happens when you run it.

1.2.5 Learning more about Visual Studio Code ^

To learn more about how to use the IDE, you can use the following resources:

• The documentation, also accessible within VS Code via Help > Documentation, contains a lot of information.
• The Tips and Tricks page (Help > Tips and Tricks) contains tips, tricks, and keyboard shortcuts which could save you a lot of time and effort.
• A basic tutorial is also provided within VS Code itself, under Help > Interactive Playground.
• Video tutorials are available under Help > Introductory Videos.
• Under Help > Keyboard Shortcuts Reference, you can find a printable PDF file with some important keyboard shortcuts.
• A full list of all available keyboard shortcuts can be viewed by going to View > Command Palette... (or pressing F1 or Ctrl+Shift+P) and choosing "Preferences: Open Keyboard Shortcuts". This list is also accessible via the shortcut Ctrl+K Ctrl+S.

2 Fundamentals of C programming ^

This chapter and the next one will serve two purposes: to teach you the basics of C, and to provide an easily-accessible reference for the rest of the course. I have decided to structure it in this way because I expect most students to already have some programming experience, if not in C then in some other programming language, and thus be familiar with concepts such as variables, selection and iteration statements, and so on.

Therefore, instead of giving just a short explanation of each concept, I present each concept in full detail, focusing on the precise syntax and common mistakes unique to C, as well as the underlying structure, such as how variables are stored in memory.

2.1 Basic C syntax and analysis of the "Hello, World!" program

2.1.1 Line-by-line analysis

Now that we have installed our IDE and compiler, and ran our first program, let us go over the lines in the program and explain what they do. The first line is:

#include <stdio.h>

This line instructs the C compiler to read the header file stdio.h, which contains definitions used in the C Standard Input and Output Library, and include those definitions in our program. We need to do this in order to print text to the terminal using the printf function, which is included in this library. Note that stdio.h does not contain the function printf itself, only its definition.

The second line is:

int main(void)

In C, functions are declared by first stating what kind of value the function returns as output (in this case: int), then the name of the function (in this case: main), and finally, in parentheses, any parameters that the function may take as input (in this case: void).

• The main function is a special function which must be included in all C programs, and it contains the code that is executed when the program starts - i.e., the main part of the program.
• int means integer, and therefore the main function - and thus, the program itself - returns an integer value as output, with 0 indicating that there were no errors. This is the standard way in which all C programs must be defined, and a value of 0 is automatically returned if the program finished executing successfully. Generally, you don't have to worry about the returned value unless you call your program from another program or script which needs to make use of this value.
• Inside the parentheses, void means that the function main - and thus, the program itself - does not take any values as input. Often, programs get their input from the command line; we will see later how to declare main in this case. Programs which employ a GUI (Graphical User Interface) can instead get their input using menus, buttons, and other interactive visual components.

The third line is just a curly bracket {. Curly brackets (or braces) indicate that a code block (or compound statement) is starting. Any code that is entered between the opening bracket { and the closing bracket } will belong to that code block - in this case, the code block defining the main function and thus the main part of the program.

The fourth line is:

    printf("Hello, World!\n");

Let us deconstruct this line carefully:

• printf is a function to print (f)ormatted text to the terminal. Here, we did not use the "formatted" part, we just printed a single string of text. Soon, we will see how to output other types of values with printf.
• The parentheses ( and ) contain the arguments of the function printf. In this case, there is just one argument: the string to be printed.
• The quotation marks " contain a string. A string is simply a sequence of characters enclosed within quotation marks. In this case, the string is "Hello, World!\n".
• The backslash \ denotes a special character, which we usually cannot enter as is in the code editor. The \ must always be followed by a letter indicating which special character should be used. In this case, \n means (n)ew line. This simply ensures that if we print other strings later, they will be printed in a new line in the terminal, instead of on the same line.
• The semicolon ; indicates that a command has ended.

Finally, the fifth line is simply the closing bracket }, indicating that the definition of the function main is done. When the execution of the program reaches this line, the program exits.

2.1.2 Comments and semicolons ^

Copy and paste this code to the IDE:

#include <stdio.h>

int main(void)
{
    printf("Hello, ");
    printf("World!\n") // This line is missing a semicolon!
}

First of all, notice that in the line before last, we have two slashes //. Any text that appears after two slashes (and until the end of the line) is not executed, and is used to provide comments on the code. In this case, I added the comment to let you know that this line is missing a semicolon. To write comments that span multiple lines, we can use /* to indicate the beginning of the comment and */ to indicate the end, for example:

/* This is a comment that
    spans multiple lines */

Now you can familiarize yourself with an indispensable feature of the IDE: static code analysis. A few seconds after you paste the new code, the IDE will already tell you that there is a problem with it, even though you have not tried to compile it yet. If this does not happen automatically, press Ctrl+S to save the file, which will trigger the analysis.

You will see the closing bracket } highlighted with a squiggly red underline (just like a spellchecker). If you hover on it with the mouse, you will see the error message expected a ';'. Note that this message is followed by the text "C/C++", indicating that it came from the C/C++ extension itself via static code analysis, rather than from the compiler.

Alternatively, on the bottom of the page, click on the Problems tab, and you will see the error there, along with the text "C/C++" again, as well as the pair of numbers [7, 1] which indicate the row and column number where the error was found. If you can't see the Problems tab, you can enable it by choosing View > Problems from the menu or pressing Ctrl+Shift+M.

If you press F5 to run the program without fixing the problem, it will not compile. You might expect that the string "Hello, " will be printed, because the problem is only with the next line; however, this is not the case, because C is a compiled language. The compiler doesn't run each line individually, it compiles the program as a whole, so if there are any errors anywhere in the code, the program simply won't compile.

After you press F5 and the code runs through the compiler, another error message will appear in the Problems tab: expected ';' before '}' token. This error will also appear as a squiggly line where the semicolon should have been. Note that this message is followed by the text "gcc", indicating that it came from the GCC compiler. So you now have two error messages, one from VS Code's C/C++ extension and one from the GCC compiler. The compiler can also find many other errors that VS Code cannot, since it is much more thorough.

If you add the missing ;, the problem labeled "C/C++" will disappear from the Problems tab after a few seconds, since VS Code will no longer detect an error. Now you can press F5 to compile the code again. The problem labeled "gcc" will then disappear as well, and the message "Hello, World!" will appear in the terminal, as expected.

It is worth noting that the message "Hello, World!" is printed in one line, even though we have two instances of printf. This is because the first one, printf("Hello, "), does not contain a newline character \n, and therefore any additional output will appear in the same line.

2.1.3 Indentation and code formatting ^

The C compiler mostly doesn't care about spaces or line breaks. For example, the "Hello, World!" program could also be written without any line breaks (except in the first line), as follows:

#include <stdio.h>
int main(void) { printf("Hello, "); printf("World!\n"); }

or with lots of spaces and line breaks, like so (please never format your code like this!):

#include <stdio.h>

int
    main(void)        {

            printf
                (    "Hello, "    );

            printf
                (    "World!\n"    );

                 }

The special command #include <stdio.h>, known as a preprocessor directive (we will talk about that later), has to be written in exactly one line, since it is not part of the actual code, but rather an instruction meant for the compiler. However, most other commands can be formatted as you wish. Generally, adding line breaks in some places - such as before and after the curly brackets, and after semicolons - significantly improves the clarity and readability of your program.

Every C developer has their own style preferences. For example, sometimes you will see the opening bracket on the same line as the function instead of in a new line, i.e. int main(void) {. This is a matter of personal taste; I personally feel that having the opening and closing bracket on the same column makes it easier to see where each code block begins and ends, but other people may have different opinions. (Note that by default, Visual Studio Code formats code with the { in a new line.)

Luckily, since we are using an IDE, we don't need to worry about formatting our code manually - the IDE will do it for us. Paste either of the two code snippets above into a Visual Studio Code C file, and then right-click anywhere in the editor and choose "Format Document" (or press Shift+Alt+F). The IDE will format your code, and it should look exactly like the code I wrote in the beginning of the previous section.

In fact, VS Code can format your code automatically for you on-the-fly, without having to tell it to do it. To enable this feature (which I highly recommend), go to File > Preferences > Settings (or simply press Ctrl+,) and then choose Text Editor > Formatting from the menu on the left. Enable the checkboxes for Format On Paste, Format On Save, and Format On Type. Now your code will be formatted for you automatically whenever you do any of these actions.

Next, choose Extensions > C/C++ from the menu on the left of the Settings tab, and make sure that C_Cpp.clang_format_fallbackStyle is set to "Visual Studio", since this is the style I will be using in this course (but feel free to try out other styles if you like).

2.2 Variables and integer data types ^

Now that we understand some basic facts about writing C programs, let us consider one of the most important entities in C (or any program language): variables. A variable has a value which can be changed (or varied), hence the name "variable". There are many types of data that can be stored inside variables. For now, we will only consider variables that have integer values.

In C, there are many different data types used for integer variables. The basic types are char and int, and these are further modified by one or more of the modifiers signed, unsigned, short, and long. Newer versions also added another useful type, bool. This variety of integer types is one of the most confusing parts of C for beginners. Let us discuss these data types now.

2.2.1 Integers and bit width

The data type int stands for integer, and it is used to store integers within various different ranges - depending how many bits are allocated for it in memory. An int can either be signed or unsigned. Let N be the number of bits used to store the integer. If it is unsigned, then the range of values is simply from 0 to 2^N-1. For example, for N=3 we have:

• 0 = 000,
• 1 = 001,
• 2 = 010,
• 3 = 011,
• 4 = 100,
• 5 = 101,
• 6 = 110,
• 7 = 111 = 2^N-1.

If the integer is signed, then it should allow for negative values as well. Unfortunately, the computer only knows how to store data as sequences of bits - 0s and 1s - and nothing else. It cannot store a plus or minus sign explicitly in memory. Therefore the sign, whether plus or minus, must also be encoded using bits.

In C, signed numbers are represented using a system called two's complement. Given a number in binary, its negative is represented by inverting all the bits and then adding one to the result. For example, for N=3 we have the positive numbers:

• 0 = 000,
• 1 = 001,
• 2 = 010,
• 3 = 011 = 2^N-1-1,

and the negative numbers:

• -1 (invert 001, get 110, then add 1) = 111,
• -2 (invert 010, get 101, then add 1) = 110,
• -3 (invert 011, get 100, then add 1) = 101.

Notice that we haven't used the bit sequence 100, so we might as well use it to store an additional number. (3 bits allow for 2³ = 8 combinations in total, and we only used 7.) Also notice that all the positive numbers have 0 as their leftmost bit, and all the negative numbers have 1 as their leftmost bit, so 100 should be a negative number. Therefore, it is natural to define:

• -4 = 100 = -2^N-1

In conclusion, we see that signed integers with N bits can take values from -2^N-1 to 2^N-1-1.

In C, unlike in some higher-level languages, each variable must have a fixed data type. If we declare a variable as an integer with 8 bits of storage, for example, then we cannot assign to it an integer that requires more than 8 bits of storage later on without losing data, and we definitely cannot assign to it a string or some other data type.

This is because, as I explained above, C provides direct, low-level access to the computer's hardware - including its memory. Therefore, sufficient space must be explicitly allocated in memory for each variable that you declare, and this means the compiler must know how much space the variable is going to take, which depends on what kind of data you intend to store in it.

In some higher-level languages like Python and Mathematica, an integer can have any value, without limit, and reallocate memory on-the-fly when the integer becomes larger and requires more storage space. This is called arbitrary-precision or infinite-precision arithmetic.

However, arbitrary-precision operations are significantly slower, since they cannot use the CPU's built-in integer operations, which are only available for integers with a fixed and bounded number of bits, as captured in C's integer data types. On the other hand, in C, if you are not careful, you might exceed the range that you allocated for your integers, causing bugs and loss of data; this is called integer overflow, and we will demonstrate it below.

2.2.2 The integer types ^

Modern 64-bit C compilers support integer sizes from 8 to 64 bits. The names of each size of integer vary between different compilers, which is a source of confusion. Copy and paste the following code to the IDE and run it to find out what the definitions mean on your system:

#include <limits.h>
#include <stdio.h>

int main(void)
{
    printf("%s contains %zu bits.\n", "A char", 8 * sizeof(char));
    printf("    %s takes values from %d to %d.\n", "A signed char", SCHAR_MIN, SCHAR_MAX);
    printf("    %s takes values from %u to %u.\n", "An unsigned char", 0, UCHAR_MAX);
    printf("\n");

    printf("%s contains %zu bits.\n", "A short", 8 * sizeof(short));
    printf("    %s takes values from %d to %d.\n", "A signed short", SHRT_MIN, SHRT_MAX);
    printf("    %s takes values from %u to %u.\n", "An unsigned short", 0, USHRT_MAX);
    printf("\n");

    printf("%s contains %zu bits.\n", "A long", 8 * sizeof(long));
    printf("    %s takes values from %ld to %ld.\n", "A signed long", LONG_MIN, LONG_MAX);
    printf("    %s takes values from %u to %lu.\n", "An unsigned long", 0, ULONG_MAX);
    printf("\n");

    printf("%s contains %zu bits.\n", "A long long", 8 * sizeof(long long));
    printf("    %s takes values from %lld to %lld.\n", "A signed long long", LLONG_MIN, LLONG_MAX);
    printf("    %s takes values from %u to %llu.\n", "An unsigned long long", 0, ULLONG_MAX);
    printf("\n");

    printf("%s contains %zu bits.\n", "An int", 8 * sizeof(int));
    printf("    %s takes values from %d to %d.\n", "A signed int", INT_MIN, INT_MAX);
    printf("    %s takes values from %u to %u.\n", "An unsigned int", 0, UINT_MAX);
    printf("\n");
}

We will first discuss the output, and then the new aspects of the code itself. On my computer, which is running Windows 11 with the 64-bit GCC compiler (Mingw-w64), the output is as follows:

A char contains 8 bits.
    A signed char takes values from -128 to 127.
    An unsigned char takes values from 0 to 255.

A short contains 16 bits.
    A signed short takes values from -32768 to 32767.
    An unsigned short takes values from 0 to 65535.

A long contains 32 bits.
    A signed long takes values from -2147483648 to 2147483647.
    An unsigned long takes values from 0 to 4294967295.

A long long contains 64 bits.
    A signed long long takes values from -9223372036854775808 to 9223372036854775807.
    An unsigned long long takes values from 0 to 18446744073709551615.

An int contains 32 bits.
    A signed int takes values from -2147483648 to 2147483647.
    An unsigned int takes values from 0 to 4294967295.

As a rule, a char always contains exactly 8 bits. In some old computers, a byte could contain a number of bits other than 8, in which case this number would be given by the constant CHAR_BIT, but this is irrelevant for modern computers.

On the other hand, the number of bits contained in an int depends on the platform you are using (Windows, Linux, etc.), and can range from 16 to 64, with short and long modifying that number, again on a platform-dependent basis. Note that int is the actual data type, while short, long, and long long are just shorthands for short int, long int, and long long int, but this distinction doesn't really matter.

We see that on 64-bit Windows, the sizes are:

• short has 16 bits.
• long and int have 32 bits.
• long long has 64 bits.

This data model is called LLP64, which is a mnemonic for "(only) long long and pointers are 64 bits". We will learn about pointers later in the course.

However, on 64-bit Linux-based operating systems (including macOS), the sizes are instead:

• short has 16 bits.
• int has 32 bits.
• long and long long have 64 bits.

This data model is called LP64, which is a mnemonic for "long and pointers are 64 bits" (and since long long cannot be smaller than long, it is implied that it's also 64 bits). Both standard have advantages and disadvantages, which we will not cover here.

The C standard itself does not enforce any specific sizes for the integer types; it merely requires that, regardless of which platform you are using, the following minimum sizes must be satisfied:

• short and int must have at least 16 bits.
• long must have at least 32 bits.
• long long must have at least 64 bits.

Unfortunately, this confusion regarding the number of bits in each integer type can result in programs that only work on one platform and not another. Luckily, this issue is solved using fixed-width integer types, which we will present below.

Finally, note that all integer data types are signed by default. So int actually means signed int, long means signed long, and so on. However, if you have a variable that you know will never be negative (e.g. the size of an array), then you should define it as an unsigned integer. There are two benefits to this:

1. unsigned integers can represent numbers twice as large. If you're not using the negative range, then you're just wasting 1 bit of memory.
2. More importantly, declaring a variable as unsigned indicates to the human reading your code that the variable is expected to always be non-negative, which adds to the readability of your code.

2.2.3 Line-by-line analysis and printf format placeholders ^

Now, as promised, let us go over the new aspects of the code we used above. The first line is:

#include <limits.h>

This simply instructs the C compiler to read the file limits.h, which contains the definitions of the limits of the various integer sizes, and include those definitions in our program - just like we do for stdio.h in the second line.

The main function consists of many printf statements. The first parameter for printf is a string, as in the "Hello, World!" program. However, here the strings contain various format placeholders, which take the form of a percent sign % followed by one or more letters.

When printf encounters a format placeholder, it takes the next parameter passed to the function and prints it out in the specified format. So the first % corresponds to the first parameter after the string (the second parameter overall), the second % corresponds to the second parameter after the string (the third parameter overall), and so on.

Some common format placeholders are as follows:

• %s corresponds to a string. Therefore, we used it in place of strings such as "A char", "A signed char", "An unsigned char" and so on.
• %d (or equivalently %i) corresponds to a signed int. Therefore, we used it in place of signed integers that we knew had at most the same number of bits as an int, namely char, short, and int.
  • Here, the d means "decimal". One can optionally use %x or %X to print the number as hexadecimal (base 16), with lowercase or uppercase letters respectively. For example, printf("%X", 255); will print "FF".
• %u corresponds to an unsigned int. Therefore, we used it in place of unsigned integers that we knew had at most the same number of bits as an int.
• Adding the letter l in front of d or u indicates that the placeholder corresponds to a long. Thus, %ld is a signed long and %lu is an unsigned long.
• Adding the letters ll in front of d or u indicates that the placeholder corresponds to a long long. Thus, %lld is a signed long long and %llu is an unsigned long long.
• The placeholder %zu is a special placeholder that gets replaced with the type of the return value of sizeof (see below). Usually on 64-bit systems this would be long long, but it might be different depending on the specific system. Since we don't know in advance what this type will be, we use %zu which is guaranteed to always be the correct type.

In the first line of the main function we have

    printf("%s contains %zu bits.\n", "A char", 8 * sizeof(char));

Here, the placeholder %s gets replaced with the string "A char", which is the second parameter passed to printf. The placeholder %zu gets replaced with the unsigned long long number 8 * sizeof(char), which is the third parameter passed to printf. But what is this number?

sizeof is an operator which returns the size in bytes of a data type or a variable. We then multiply the result by 8 using the multiplication operator * to get the number of bits. So sizeof(char) returns the value 1, which we multiply by 8 to get 8 bits. Note that on a 64-bit system this number will be an unsigned long long, hence %zu is equivalent to %llu. If you try replacing %zu with %d, for example, you will get a warning from the compiler.

In the second line of the main function we have

    printf("    %s takes values from %d to %d.\n", "A signed char", SCHAR_MIN, SCHAR_MAX);

Here, the placeholder %s gets replaced with the string "A signed char". The placeholder %d gets replaced with the integer SCHAR_MIN, which is defined in limits.h to be -128, the minimum value of a signed char. Finally, the last placeholder, which is also %d, gets replaced with the integer SCHAR_MAX, which is defined in limits.h to be 127, the maximum value of a signed char. The same principles apply to the rest of the printf statements in our program.

2.2.4 Width modifiers ^

printf allows you to specify that the integer will occupy a fixed width on the screen, by adding the desired number of characters after the %. This is used for more aesthetically pleasing output by aligning different numbers together - although if you really want your program's output to look nice, you should probably implement a GUI instead!

By default, the number is aligned to the right and padded with spaces on the left. If you add - after the %, the number will be aligned to the left instead, and if you add 0 after the %, the number will be padded with zeros instead. This is illustrated in the following program:

#include <stdio.h>

int main(void)
{
    int x = 123456;
    printf("| %d |\n", x);
    printf("| %10d |\n", x);
    printf("| %-10d |\n", x);
    printf("| %010d |\n", x);
}

The output is:

| 123456 |
|     123456 |
| 123456     |
| 0000123456 |

Note how the first line only prints out the 6 digits of the number without any padding, and is thus misaligned with the other lines, which we specified to have a width of 10 characters. Also note how the third line starts like the first line, but then pads spaces to the right in order to have a total of 10 characters.

2.2.5 Declaring and naming variables ^

We spent a long time discussing the possible types and ranges of integers in C and how to print them. Now it's time to do some actual programming with integers! As we stressed above, every variable in C must be properly declared so that the compiler knows how much memory to allocate for it. To declare a variable of a specific type, we write the type followed by the name of the variable.

For example, to declare an integer named x, we write:

int x;

Remember, this will be by default a signed 32-bit integer on most systems.

If we want to declare more than one variable of the same type, for example two integers x and y, we can do it in one line, separating the variable names by commas:

int x, y;

However, if we want to add comments explaining what each variable does, which would make our code clearer to the reader, then we should declare the variables separately, for example:

int x; // The horizontal axis
int y; // The vertical axis

Variable names in C can contain lowercase and uppercase English letters, digits, and underscores (_), but no other symbols. In addition, the name must start with a letter.

Furthermore, there are 34 reserved keywords that are used by the language and therefore cannot be used as variables: auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, inline, int, long, register, restrict, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, and while.

Some examples of valid variable names are var, Var, var1, and var_1. Some examples of invalid names are:

• 1var (begins with a digit),
• var-1 (contains the symbol - which is not a letter, digit, or underscore; will be interpreted as subtracting 1 from var),
• long (reserved keyword).

Also note that variable names in C are case-sensitive, so var and Var are not the same variable. Keywords are case-sensitive as well; for example, long is a data type, but Long is unused and could therefore technically be used as a variable name, although this is very strongly discouraged.

The so-called classic C naming convention uses lowercase words separated by underscore to name variables, e.g. my_variable_name, and uppercase words separated by underscore to name constants, e.g. MY_CONSTANT_NAME. This is the convention I will use here.

Sometimes you will also see camel case, where instead of separating words by an underscore, each word starts with an uppercase letter. This has two variations: either the first word (and only the first word) starts with a lowercase letter, e.g. myVariableName, or all words start with an uppercase letter, e.g. MyVariableName.

2.2.6 Initializing variables ^

A variable can be assigned a value either when it is declared:

int x = 0;

or later:

int x;
x = 0;

We can also assign values when we declare more than one variable:

int x = 0, y = 1;

What happens if we never assign a value? To answer that, let us run the following program:

#include <stdio.h>

int main(void)
{
    long long a, b;
    printf("%lld, %lld\n", a, b);
}

On my computer, the output is:

16, 12588272

(In fact, for some reason the value of a is always 16, but the value of b changes every time.) Where did these numbers come from?

When we declared the variables, unused space was automatically allocated in memory to store them - 64 bits of memory for each, since that is the number of bits in a long long. However, nothing was actually written to that space, as we did not explicitly give the variables any specific initial values, which is called initializing the variables. The numbers printed by the program are simply the numbers that happened to be stored in that particular space in memory before the program was executed.

This is another example of C not "holding your hand" by doing things automatically for you, unlike most higher-level languages. The C compiler doesn't automatically initialize any variables to some default value; instead, you must always initialize them by hand.

In most cases, initializing the variables as soon as they are declared does not affect performance, since they have to be initialized sometime, if not now then later. However, if the initial value of a variable is not known when we write the code - for example, if the value is taken from a file or from user input - then we could potentially save a bit of CPU time by declaring the variable uninitialized, and only assigning the initial value later, when we know what it should be.

Nevertheless, even in cases like this, it would still be safer to initialize the variable at declaration time - for example, to a default value that the variable should have in case the input operation fails. Initializing a variable only takes a small fraction of a second, so unless the operation is performed billions of times, there will not be any noticeable performance penalty.

If you added the -Wextra compiler argument, as I explained above, then after you press F5, the Problems tab (Ctrl+Shift+M) should show you a warning: 'a' is used uninitialized in this function. The program still runs, since unlike errors, warnings do not halt the compilation; therefore, paying attention to compiler warnings in the Problems tab is extremely important and can help you prevent potential bugs in your code.

To illustrate the warning, compare this (not properly organized) code:

#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");

    // do some stuff...

    short a = 5;
    printf("a = %d\n", a);

    // do some more stuff...

    unsigned long b;

    // do some more stuff...

    b = 7;
    printf("b = %lu\n", b);
}

With this (properly organized) code:

#include <stdio.h>

int main(void)
{
    short a = 5;
    unsigned long b = 7;

    printf("Hello, World!\n");

    // do some stuff...

    printf("a = %d\n", a);

    // do some more stuff...

    printf("b = %lu\n", b);
}

Both programs do the same thing, but in the second program it is immediately clear to the reader that two variables, a and b, will be used in the program, and that they are initialized to 5 and 7 respectively. In the first program, the reader must read the whole program to get the same information. Furthermore, there is also a risk that b will be used uninitialized - especially if someone made changes to the code that resulted in accidentally erasing the line containing the initialization b = 7.

2.2.7 Constant variables ^

Sometimes, we want to introduce a variable that will be used throughout the program, but its value will never change. In these cases, the variable can be declared as a constant using the keyword const. This has many subtle uses, that we won't get into here; however, its most basic and common use is to simply ensure that the programmer does not accidentally modify the variable later. Here is an example:

#include <stdio.h>

int main(void)
{
    const int answer = 42;
    answer = 41;
}

If you enter that code, before you even run it, the IDE will display the error expression must be a modifiable lvalue in the Problems tab on the bottom of the page. (If you can't see the Problems tab, you can enable it by choosing View > Problems from the menu, or pressing Ctrl+Shift+M.) Therefore, the variable answer is protected from accidental modification.

In these lecture notes, I will make sure to always define constant variables as const. This is good programming practice, as it guarantees that constant variables are never accidentally modified, and thus prevents bugs. I will also make sure to do the same for any function arguments that are not modified by the function (see below).

Of course, in the simple examples in these lecture notes, this isn't really necessary, but it's good to develop a habit of using const wherever possible. You should make sure to do the same when you write your own code!

2.2.8 Arithmetic operators on integers ^

Once we declare variables, we can operate on them and combine them together in various ways. The following program demonstrates the most common arithmetic operators:

#include <stdio.h>

int main(void)
{
    const int x = 5, y = 2;
    printf("Addition: %d + %d = %d\n", x, y, x + y);         // Addition: 5 + 2 = 7
    printf("Subtraction: %d - %d = %d\n", x, y, x - y);      // Subtraction: 5 - 2 = 3
    printf("Multiplication: %d * %d = %d\n", x, y, x * y);   // Multiplication: 5 * 2 = 10
    printf("Integer division: %d / %d = %d\n", x, y, x / y); // Integer division: 5 / 2 = 2
    printf("Modulo: %d %% %d = %d\n", x, y, x % y);          // Modulo: 5 % 2 = 1
}

Note that integer division rounds towards zero, so 5 / 2 = 2.5 is rounded to 2 and -5 / 2 = -2.5 is rounded to -2. The modulo (or remainder) is defined such that ((x / y) * y) + (x % y) is equal to x.

Also note that in the code above, to print out the character % in the last line, we had to enter it twice in the printf string. This is because a % indicates a format placeholder, so in order to print it as is, we use %%.

This program only printed the results, but did not reassign any value to x and y. Any variables can be reassigned a new value, simply by using the = operator, for example:

x = y + 1;

C also employs some useful shorthands for reassigning values, in cases where the new value depends on the old value:

• x += y is equivalent to x = x + y.
• x -= y is equivalent to x = x - y.
• x *= y is equivalent to x = x * y.
• x /= y is equivalent to x = x / y.
• x %= y is equivalent to x = x % y.

Finally, if we just want to increase or decrease the value of an integer by 1, we can use the following shorthands:

• x++ is equivalent to x = x + 1.
• x-- is equivalent to x = x - 1.

2.2.9 Integer overflows ^

To illustrate integer overflows, let's run the following program:

#include <stdio.h>

int main(void)
{
    unsigned char x = 255;
    x++;
    printf("255 + 1 = %d\n", x);
    unsigned char y = 0;
    y--;
    printf("0 - 1 = %d\n", y);
}

If you run the program, you will see the following output:

255 + 1 = 0
0 - 1 = 255

What happened? Recall that an unsigned char (8 bits) takes values from 0 to 255. In binary, we have

• 00000000 binary = 0 decimal,
• 11111111 binary = 255 decimal.

When we added 1 to 255, the result has 9 bits: 100000000. However, x, which is an unsigned char, can only store numbers with at most 8 bits. Therefore, the 9th bit gets truncated, and we are left with 00000000, which is just zero.

A similar thing happened when we subtracted 1 from 0. Remember that in the two's complement representation of negative numbers, the negative of a number is obtained by inverting all the bits and then adding one to the result. So the negative of 1, which is 00000001 in binary, is 11111111. However, since y is an unsigned char, the binary number 11111111 is interpreted as usual to be 255 in decimal.

More generally, when the result of an operation is stored in an integer with N bits, the result will be taken modulo 2^N. This is called integer overflow, and when you program in C (unlike in some higher-level languages like Python), you have to be very careful to avoid it, because otherwise your program will not work correctly, since it will think that, for example, 256 is actually 0.

It is possible to check if an overflow will occur before doing the calculation. Suppose we want to add two N-bit integers, x and y. An overflow will occur if x + y > 2^N-1, so we could first check if x > 2^N-1-y, and if so, issue an error to the user or deal with the problem in another way. Similarly, for subtraction, an overflow will occur if x - y < 0, so we could first check if x < y. However, as always, there is a tradeoff between speed and safety; if we perform a check every time we do an arithmetic operation, our code will take more time to run.

2.2.10 Fixed-width integer types ^

Confused by the variety of integer data types and the fact that they have different sizes on each platform? You're not alone. Because of this confusion, the C99 standard added fixed-width integer types, which guarantee that an integer will have precisely the number of bits that you want it to have, regardless of platform. The types are:

• int8_t, int16_t, int32_t, int64_t for signed integers with width of exactly 8, 16, 32 and 64 bits respectively.
• uint8_t, uint16_t, uint32_t, uint64_t for unsigned integers with width of exactly 8, 16, 32 and 64 bits respectively.

To access them, we must include the header file stdint.h. Furthermore, there are also corresponding format placeholders for printf:

• PRId8, PRId16, PRId32, PRId64 for signed integers with width of exactly 8, 16, 32 and 64 bits respectively.
• PRIu8, PRIu16, PRIu32, PRIu64 for unsigned integers with width of exactly 8, 16, 32 and 64 bits respectively.

These are defined in the header file inttypes.h. To use them, replace e.g. "%d\n" with "%"PRId32"\n".

The following code is similar to the one we used above, but this time, the output will be exactly the same on any platform:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    printf("  int8_t contains %2zu bits and takes values from %" PRId8 " to %" PRId8 ".\n", 8 * sizeof(int8_t), INT8_MIN, INT8_MAX);
    printf(" uint8_t contains %2zu bits and takes values from 0 to %" PRIu8 ".\n", 8 * sizeof(uint8_t), UINT8_MAX);

    printf(" int16_t contains %2zu bits and takes values from %" PRId16 " to %" PRId16 ".\n", 8 * sizeof(int16_t), INT16_MIN, INT16_MAX);
    printf("uint16_t contains %2zu bits and takes values from 0 to %" PRIu16 ".\n", 8 * sizeof(uint16_t), UINT16_MAX);

    printf(" int32_t contains %2zu bits and takes values from %" PRId32 " to %" PRId32 ".\n", 8 * sizeof(int32_t), INT32_MIN, INT32_MAX);
    printf("uint32_t contains %2zu bits and takes values from 0 to %" PRIu32 ".\n", 8 * sizeof(uint32_t), UINT32_MAX);

    printf(" int64_t contains %2zu bits and takes values from %" PRId64 " to %" PRId64 ".\n", 8 * sizeof(int64_t), INT64_MIN, INT64_MAX);
    printf("uint64_t contains %2zu bits and takes values from 0 to %" PRIu64 ".\n", 8 * sizeof(uint64_t), UINT64_MAX);
}

The output (on any platform) should be:

  int8_t contains  8 bits and takes values from -128 to 127.
 uint8_t contains  8 bits and takes values from 0 to 255.
 int16_t contains 16 bits and takes values from -32768 to 32767.
uint16_t contains 16 bits and takes values from 0 to 65535.
 int32_t contains 32 bits and takes values from -2147483648 to 2147483647.
uint32_t contains 32 bits and takes values from 0 to 4294967295.
 int64_t contains 64 bits and takes values from -9223372036854775808 to 9223372036854775807.
uint64_t contains 64 bits and takes values from 0 to 18446744073709551615.

Note that here we used the format placeholder %zu to print out the size of the integer types in bits. %zu is intended specifically to print out the result of the sizeof operator, which has the special type size_t. The purpose of size_t is to always be able to store the maximum theoretical size, in bytes, of any variable or array. Thus, on 64-bit systems, size_t is the same as uint64_t. Other than storing the result of sizeof, the type size_t can be used, for example, to count the elements of an array.

Nowadays there's no reason to write 32-bit programs (certainly not for scientific computing!), so there's never any reason to assume size_t will have only 32 bits. Thus, I usually prefer to use uint64_t explicitly instead of size_t, even if just for readability purposes, to let the human reader know that I expect this to be a 64-bit integer. I will take this approach in these notes as well.

From now on, I will always use these fixed-width integer types in these lecture notes, and avoid using any ambiguous integer types (with the exception of the main function itself, which must always return int). You should make sure to do the same in your course projects, and in any other programs you write in C and C++!

2.3 Selection statements ^

2.3.1 If statements and comparison operators

The if statement is used to execute a code based on some condition. The basic syntax is:

if (condition)
    statement;

This checks condition and, if it is satisfied, executes statement. It is not necessary to write statement on a separate line, although I think it looks clearer; you could also write if (condition) statement;. Furthermore, if you want to execute several different statements if the condition is satisfied, you can enclose them in curly brackets:

if (condition)
{
    statement1;
    statement2;
    // etc...
}

For example:

if (x > 0)
    x++;

This increases x by 1, but only if its value is positive. More generally, the following comparison operators are available:

• x == y: "x is equal to y".
• x != y: "x is not equal to y".
• x < y: "x is less than y".
• x > y: "x is greater than y".
• x <= y: "x is less than or equal to y".
• x >= y: "x is greater than or equal to y".

In addition, logical operators can be used to modify and combine conditions:

• !A: "not A". For example, instead of if (x <= y) we can equivalently write if (!(x > y)); if x is not greater than y, then it must be either less than or equal to y.
• A && B: "A and B", meaning that A and B must both be true. For example, (-1 <= x) && (x <= 1) checks if x is in the interval [-1,1], that is, between -1 and 1 inclusive; note that -1 <= x <= 1 is not possible in the C syntax.
• A || B: "A or B", meaning that at least one of A and B must be true. For example, (x < -1) || (1 < x) checks if x is outside the interval [-1,1].

Optionally, one may add an else statement, which will be executed if condition is not satisfied:

if (condition)
    statement;
else
    another_statement;

Or with brackets:

if (condition)
{
    statement1;
    statement2;
    // etc...
}
else
{
    another_statement1;
    another_statement2;
    // etc...
}

For example:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 2;
    if (x % 2 == 0)
        printf("x is even.\n");
    else
        printf("x is odd.\n");
}

else may also be followed by another if, for example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 7;
    if (x % 3 == 0)
        printf("%" PRId64 " is divisible by 3.\n", x);
    else if (x % 3 == 1)
        printf("%" PRId64 " divided by 3 has remainder 1.\n", x);
    else if (x % 3 == 2)
        printf("%" PRId64 " divided by 3 has remainder 2.\n", x);
}

(Recall that int64_t is a 64-bit integer and PRId64 is the format placeholder for it; see fixed-width integer types).

2.3.2 If subtleties and Boolean values ^

Consider the following code:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 0;
    if (x)
        printf("x is true.\n");
    else
        printf("x is false.\n");
}

If you run this code, you will get the output x is false. However, if you change x to any non-zero integer value, you will get the output x is true. In other words, the if statement considers the condition to be true if it evaluates to a non-zero integer. Indeed, let us run the following code:

#include <stdio.h>

int main(void)
{
    printf("%d\n", 1 == 1);
    printf("%d\n", 1 == 2);
}

From the output, we see that 1 == 1 evaluates to 1 (a non-zero integer, and thus true), and 1 == 2 evaluates to 0 (and thus false).

This convention in C can be very confusing, and it can cause errors if you are not careful. Here is one of the most common problems C programmers encounter. Before, I warned you that == is a comparison operator, while = is an assignment operator. Now, an assignment operator actually evaluates to the value that was assigned. So for example, x = 1 assigns 1 to x and also evaluates to 1. This can cause an error if we accidentally write = instead of ==. For example:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    int64_t x = 0;
    if (x = 1) // Notice that we (incorrectly) used = instead of == here!
        printf("x is 1.\n");
    else
        printf("x is not 1.\n");
}

The output of this program is x is 1. The reason is that x = 1 does not compare x to 1, it sets x to 1, and evaluates to 1, which if then interprets as "true"! If you configured GCC to provide extra warnings, as I explained above, then you will see the warning suggest parentheses around assignment used as truth value in the Problems tab. This warning will appear whenever the compiler thinks you used = when you should have used ==.

Another problem with interpreting 0 as "false" and any other integer as "true" is that both 1 and 2 mean "true", but they are not equal to each other, which means that false equals false, but true does not always equal true!

To avoid this and other confusions, C provides (since 1999) a Boolean data type called bool, which is accessible by including the header file stdbool.h. Once you include that file, you may declare variables using the bool type, and their values can be either true or false. These values can then be modified, e.g. using logic operators.

Here is an example:

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    const bool A = true;
    const bool B = false;
    if (A)
        printf("A is true.\n");
    if (B)
        printf("B is true.\n");
    if (!A)
        printf("A is not true.\n");
    if (!B)
        printf("B is not true.\n");
    if (A && B)
        printf("A and B are both true.\n");
    if (A || B)
        printf("At least one of A and B is true.\n");
}

The output is:

A is true.
B is not true.
At least one of A and B is true.

You can change the truth values of A and B and see what you get. Note that e.g. if (A) is equivalent to if (A == true).

2.3.3 The (ternary) conditional operator ^

A very convenient short form for the if-else statement is given by the conditional operator. The following if statement:

if (condition)
    statement;
else
    another_statement;

can alternatively be written using the conditional operator as follows:

condition ? statement : another_statement;

This is most often used not as a stand-alone expression, but rather as part of a larger expression. For example, recall the code we used above:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 2;
    if (x % 2 == 0)
        printf("x is even.\n");
    else
        printf("x is odd.\n");
}

Instead of having several different lines for the if and else statements, and two different printf statements, we can use the following more compact and (arguably) elegant version:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 2;
    printf("x is %s.\n", x % 2 ? "odd" : "even");
}

2.3.4 Switch statements ^

if statements only consider two cases: either condition is satisfied or not. switch allows you to consider several different cases. The syntax is:

switch (expression)
{
case 1:
    statement1;
    break;
case 2:
    statement2;
    break;
    // etc...
}

This will evaluate expression, which must return an integer. If expression is equal to 1, it will evaluate statement1; if expression is equal to 2, it will evaluate statement2; and so on.

To illustrate the warning, let us run the following code:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 2;
    switch (x)
    {
    case 1:
        printf("1\n");
        // no break
    case 2:
        printf("2\n");
        // no break
    case 3:
        printf("3\n");
        // no break
    }
}

The output will be:

2
3

Since we did not properly break after each statement, switch started evaluating at the label case 2:, and the evaluation then ran until the closing bracket }. The proper was to do this is:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 2;
    switch (x)
    {
    case 1:
        printf("1\n");
        break;
    case 2:
        printf("2\n");
        break;
    case 3:
        printf("3\n");
        break;
    }
}

Now the output will be 2, as expected. Finally, we can also add a default label, which will be evaluated if none of the other cases are satisfied:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 5;
    switch (x)
    {
    case 1:
        printf("1\n");
        break;
    case 2:
        printf("2\n");
        break;
    default:
        printf("default\n");
        break;
    }
}

If we run this code, the output will be default, since the case x = 5 is not accounted for in any of the other labels.

switch can be used to write the program we wrote above, which determines if x is divisible by 3, in a different way:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 7;
    switch (x % 3)
    {
    case 0:
        printf("%" PRId64 " is divisible by 3.\n", x);
        break;
    case 1:
        printf("%" PRId64 " divided by 3 has remainder 1.\n", x);
        break;
    case 2:
        printf("%" PRId64 " divided by 3 has remainder 2.\n", x);
        break;
    }
}

2.3.5 Enumerations ^

An enumeration defines a new data type which can take integer values, while assigning a label to each value, so that we don't need to remember what each number represents. This is done using the keyword enum. The syntax is:

enum name { LABEL, ANOTHER_LABEL, ... };

Here, name is the name of the new data type we are creating. The first label will be assigned the number 0, the second label will be assigned the number 1, and so on. It is conventional to use uppercase for the labels, in order to distinguish them from variables. Also, note that enumerations should usually be defined outside the main function, so that the have global scope and can be used by other functions as well (see variable scope and global variables below).

If we want to assign specific integers to the labels, we can do so as follows:

enum name { LABEL = value, ANOTHER_LABEL = another_value, ... };

This is useful in cases where the numbers are generated by some other program, and we want to assign them meaningful labels in our program.

Once we define an enumeration, the labels will be replaced with their corresponding numbers throughout the program. For example:

#include <stdio.h>

enum color
{
    RED,
    GREEN,
    BLUE
};

int main(void)
{
    printf("RED = %d, GREEN = %d, BLUE = %d\n", RED, GREEN, BLUE);
}

The output will be RED = 0, GREEN = 1, BLUE = 2. However, the most common use of enumerations is to define an actual variable that can take one of these values. We can then use switch to execute different statements based on the value of the variable:

#include <stdio.h>

enum color
{
    RED,
    GREEN,
    BLUE
};

int main(void)
{
    const enum color c = GREEN;
    switch (c)
    {
    case RED:
        printf("Color is red.\n");
        break;
    case GREEN:
        printf("Color is green.\n");
        break;
    case BLUE:
        printf("Color is blue.\n");
        break;
    }
}

Here we first declare a variable called c whose data type is enum color, which means it can be either RED, GREEN, or BLUE. We also initialize it to GREEN. Then we print a message based on the value. At no point did we need to use the actual integer values assigned to the different labels. Indeed, the whole point of enumerations is that we don't need to know the numerical values of the labels. Any program what uses enumerations must always use only the labels and not the numerical values, since the values might change, but the labels are fixed.

2.4 Iteration statements (loops) ^

2.4.1 While and do-while loops

The while statement allows us to define a loop which will run while a specific condition is satisfied. The loop will automatically stop when the condition is no longer satisfied. The syntax is:

while (condition)
    statement;

As usual, if the loop body contains more than one line (i.e. it is a compound statement), it must be enclosed in curly brackets:

while (condition)
{
    statement1;
    statement2;
    // etc...
}

For example, here is a program that prints the squares of the integers from 1 to 5:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint64_t i = 1;
    while (i <= 5)
    {
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
        i++;
    }
}

Notice that here I used uint64_t, that is, an unsigned 64-bit integer, as the data type for i, since I know for certain that it will never have any negative values. I therefore also used PRIu64, the format placeholder for an unsigned 64-bit integer, to print the value of i.

It is almost always a good idea to use unsigned integers in loops like this, where the integer is being used to count the number of times the loop has been executed, since a count is always positive, and using an unsigned integer type allows us to double the range of the counting variable.

The output is:

1^2 = 1
2^2 = 4
3^2 = 9
4^2 = 16
5^2 = 25

The do statement does the same thing, except it only checks that the condition is satisfied after the loop body has been evaluated:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint64_t i = 1;
    do
    {
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
        i++;
    } while (i <= 5);
}

This will have the same output. The main difference is that in a do-while loop, the loop body will be evaluated at least once before the condition is checked. For example, if we replace int i = 1 with int i = 7, this code will first output 7^2 = 49 and only then check if i <= 5. On the other hand, if we do the same with the while loop above, there will be no output.

2.4.2 Controlling loop evaluation ^

There are two ways to control the evaluation of a loop from within the loop body. break, which we already encountered above when we discussed switch statements, immediately ends the loop. For example, the following code will have the same output as the code above, except that instead of specifying a condition for the while loop, it checks manually if i >= 5 and if so, breaks:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint64_t i = 1;
    while (1)
    {
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
        if (i >= 5)
            break;
        i++;
    }
}

Note that while (1) will keep looping infinitely (since 1 is equivalent to true) unless you explicitly break the loop! This code was only written to illustrate how the break statement works, and by no means should be interpreted as an example of good programming. Loop conditions such as while (1) should generally be avoided at all costs.

Another option is to use continue, which will skip the rest of the loop body and continue immediately to the next iteration of the loop. For example, the following code skips the even numbers:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint64_t i = 0;
    while (i <= 5)
    {
        i++;
        if (i % 2 == 0)
            continue;
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
    }
}

Note that we changed the order of the statements i++ and printf so that continue will skip printf but not i++. Otherwise we would have had an infinite loop, since once i reached an even number, it would stop incrementing, and thus the condition i <= 5 will always be satisfied (try switching the order and see what happens).

2.4.3 For loops ^

The for statement provides a more compact way of defining loops. It has the following syntax:

for (initialization; condition; iteration)
    statement;

or with a compound statement:

for (initialization; condition; iteration)
{
    statement1;
    statement2;
    // etc...
}

initialization is evaluated once, before the loop starts. condition is evaluated before the loop body, and the loop terminates if it evaluates to false (that is, 0). iteration is evaluated after the loop body, and then condition is evaluated again, and so on.

In the first while example above, we initialized i = 1 before the start of the loop, then checked that the condition i <= 5 is satisfied before each iteration of the loop, and finally increased i by 1 at the end of each iteration of the loop. This can all be written using one compact for statement as follows:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    for (uint64_t i = 1; i <= 5; i++)
    {
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
    }
}

Generally, for loops should be used whenever the iteration is over a specific range of integers. Note that for loops may be controlled using break and continue, as before.

2.4.4 Nested loops ^

All loops can be nested, which means one loop is inside another loop (which can itself be inside a third loop, and so on). This is especially common with for loops, since we can then iterate over every possible combination of the values of two (or more) integers. For example, the following code prints out a multiplication table:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    for (uint64_t i = 1; i <= 5; i++)
    {
        for (uint64_t j = 1; j <= 5; j++)
        {
            printf("| %" PRIu64 " * %" PRIu64 " = %2" PRIu64 " ", i, j, i * j);
        }
        printf("|\n");
    }
}

The output is:

| 1 * 1 =  1 | 1 * 2 =  2 | 1 * 3 =  3 | 1 * 4 =  4 | 1 * 5 =  5 |
| 2 * 1 =  2 | 2 * 2 =  4 | 2 * 3 =  6 | 2 * 4 =  8 | 2 * 5 = 10 |
| 3 * 1 =  3 | 3 * 2 =  6 | 3 * 3 =  9 | 3 * 4 = 12 | 3 * 5 = 15 |
| 4 * 1 =  4 | 4 * 2 =  8 | 4 * 3 = 12 | 4 * 4 = 16 | 4 * 5 = 20 |
| 5 * 1 =  5 | 5 * 2 = 10 | 5 * 3 = 15 | 5 * 4 = 20 | 5 * 5 = 25 |

Note that we only printed a newline character \n after each iteration of i, so that all the iterations of j will appear in one line. We also printed the right border | of the table at the same time. Finally, we used %2 in the format placeholder for the product to ensure that it is always printed with exactly 2 characters, adding a space if necessary, since some numbers will have one digit and others will have two, so this guarantees the table will be correctly aligned.

2.4.5 Variable scope ^

In C, each variable has a scope within which it is accessible. Generally, whenever we are inside a code block indicated by a pair of curly brackets { and }, any variable declared within that block is considered a local variable, local to that block. When the block ends, the variable is no longer accessible, and the memory it used is freed up. Variables declared within the context of statements such as for, even if they are not inside the curly brackets, are nonetheless local to the code block associated with that statement.

For example, consider the following code:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    for (uint64_t i = 1; i <= 5; i++)
    {
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
    }
    printf("i = %" PRIu64 "\n", i); // This won't work; i was local to the for loop
}

Since we initialized uint64_t i = 1 within the scope of the for loop, the variable i is only defined within that scope. Once the loop finishes, i no longer exists. Therefore this code won't compile, and even before you try to compile it, the IDE will add the error identifier "i" is undefined to the Problems tab and highlight i in the last line with a squiggly red underline.

If we need to use the last value of i, we must declare it before the loop starts so that its scope is the entire main function:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint64_t i;
    for (i = 1; i <= 5; i++)
    {
        printf("%" PRIu64 "^2 = %" PRIu64 "\n", i, i * i);
    }
    printf("i = %" PRIu64 "\n", i);
}

This will print i = 6 after the for loop finishes, since the value of i was increased to 6 via the iteration statement i++, and then the condition i <= 5 was no longer satisfied, which is why the loop stopped.

When we declare a local variable, and another local variable with the same name exists within a higher scope, the new variable will replace the old variable until the scope of the new variable ends. For example, in the following code, i is declared in the first line of the main function and initialized with the value 9. Another i is then declared in the for loop, and iterates on the values 1 to 6. However, once the for loop ends, the scope of this new i ends, and it disappears. If we then try to access the original variable i, it will still have the original value 9:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint64_t i = 9;
    printf("(main) i = %" PRIu64 "\n", i);
    for (uint64_t i = 1; i <= 5; i++)
    {
        printf("(for) i = %" PRIu64 "\n", i);
    }
    printf("(main) i = %" PRIu64 "\n", i);
}

The output is:

(main) i = 9
(for) i = 1
(for) i = 2
(for) i = 3
(for) i = 4
(for) i = 5
(main) i = 9

Note that a code block does not have to be associated with anything in particular; we can begin and end a code block manually wherever we want. This is very useful if we want to declare one or more temporary variables that will only be used for a specific task, and then thrown away. By declaring them within a nested code block, we ensure that they will not conflict with any variables declared elsewhere in the program, and that the memory they used has been freed up. For example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const uint64_t x = 9;
    printf("(main) x = %" PRIu64 "\n", x);
    {
        const uint64_t x = 7;
        printf("(nested) x = %" PRIu64 "\n", x);
    }
    printf("(main) x = %" PRIu64 "\n", x);
}

The output is:

(main) x = 9
(nested) x = 7
(main) x = 9

However, it usually makes more sense to define a function rather than a nested code block in such cases. Notice also that even though we declared x as const both times, when we declare it for the second time inside the code block that doesn't count as "changing its value", since we are, of course, declaring a completely new variable in a local scope.

2.5 Arrays ^

2.5.1 Declaring arrays

Arrays allow a single variable to hold multiple values. In an array of constant length, memory will be allocated for all of the values in advance, and the values will be stored contiguously (one after the other) in memory. For now, we will only consider arrays whose length is constant and determined at compilation time. Later we will discuss how to declare and allocate memory for arrays with variable length.

To declare an array of constant size, we use the following syntax:

type name[size];

type is the data type of the values, such as int64_t; name is the name of the array; and size is the number of values in the array. The Nth element of the array can then be referred to using name[N - 1].

The array can also be initialized, as follows:

type name[] = {name[0], name[1], ..., name[size - 1]};

In this case, we don't have to specify the size of the array manually - the size will be automatically determined based on how many elements are in the list. Again, note that the first element is name[0] and the last one is name[size - 1].

In the following example, we first define an array with the first 5 primes, and then print the elements of the array:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const uint64_t primes[] = {2, 3, 5, 7, 11};
    for (uint64_t i = 0; i < 5; i++)
        printf("primes[%" PRIu64 "] = %" PRIu64 "\n", i, primes[i]);
}

The output will be:

primes[0] = 2
primes[1] = 3
primes[2] = 5
primes[3] = 7
primes[4] = 11

2.5.2 Initializing arrays to zeros ^

Above we warned that variables should always be initialized to a specific value as soon as they are declared, since memory is automatically allocated but not automatically initialized, so an uninitialized variable will just take whatever value happened to be stored in that particular address in memory at the time. The same goes for arrays. For example, consider this program:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const uint64_t nums[5];
    for (uint64_t i = 0; i < 5; i++)
        printf("nums[%" PRIu64 "] = %" PRIu64 "\n", i, nums[i]);
}

On my computer, one possible output is:

nums[0] = 229359221408
nums[1] = 140700945750376
nums[2] = 1582342677712
nums[3] = 4294967296
nums[4] = 140700945747968

The numbers also change every time I run the program. On your computer, the output will be different, depending on whatever happens to be in those particular memory addresses at the time.

To avoid potential errors, it is best to initialize the array as soon as we declare it so that all of the elements are zero. We could do this by writing the zeros explicitly, i.e. const uint64_t nums[5] = {0, 0, 0, 0, 0}, but if the array contained more than a few elements, this would be extremely tedious.

Luckily, there is a shorthand for this. If we only specify some of the elements in the initialization list, and the array's size is larger than the number of elements we initialized, then the remaining elements will be initialized to zero. For example, replace the line const uint64_t nums[5]; with

const uint64_t nums[5] = {1, 2};

The output is now:

nums[0] = 1
nums[1] = 2
nums[2] = 0
nums[3] = 0
nums[4] = 0

Therefore, to automatically initialize the entire array to zeros, we can simply initialize just one element to zero, and the rest will be initialized to zero as well:

const uint64_t nums[5] = {0};

Output:

nums[0] = 0
nums[1] = 0
nums[2] = 0
nums[3] = 0
nums[4] = 0

Of course, this means that we have to specify the size of the array manually so that the compiler knows how many elements to initialize.

2.5.3 Accessing array elements out of range ^

In the following example, we create an array of one element, and initialize this element to zero. This element is nums[0]. We then try to access nums[-1] and nums[1], which are both outside the range of the array:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t nums[1] = {0};
    for (int64_t i = -1; i <= 1; i++)
        printf("nums[%" PRId64 "] = %" PRId64 "\n", i, nums[i]);
}

On my computer, one possible output is:

nums[-1] = 4294967296
nums[0] = 0
nums[1] = 1

The "elements" nums[-1] and nums[1] are not actually part of the array; the numbers that were printed were simply the numbers that happened to be stored in memory before and after the space reserved for the array.

2.5.4 Multi-dimensional arrays ^

The arrays we have defined so far were 1-dimensional, analogous to vectors. It is also possible to define higher-dimensional arrays, analogous to matrices or higher-rank tensors. The syntax to define an N-dimensional array is:

type name[size1][size2]...[sizeN];

This will define a size1 by size2 by ... by sizeN array. Elements of a multi-dimensional array can be accessed using the same notation, with the element index inside each bracket. Recall that the first element has index 0 - so the first element in the array will be name[0][0]...[0].

To initialize the array, we use nested curly brackets:

type name[size1][size2]...[sizeN] = {elements1, elements2, ..., elementsN};

where here elements1 is a sub-array with size1 elements, given by a list inside curly brackets, and so on. For example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t a[2][3] = {{1, 2, 3}, {4, 5, 6}};

    printf("%" PRId64 "\n", a[0][1]);
}

The program prints 2 because that is the element in index [0][1] of the array; the 0 indicates we are in the first sub-array {1, 2, 3}, and the 1 indicates the second element of that sub-array. Note that we could also write a[][3], and the compiler will automatically recognize that the array has 2 sub-arrays; but the size of the sub-arrays has to be declared explicitly, so a[][] will not work.

2.5.5 Characters and strings ^

A string is a sequence of characters. In C, strings are literally arrays of elements of type char. To specify a specific value for a single character, we use single quotes:

char c = 'A';

This will define a variable c of data type char which has as its value the letter A. To specify a specific value for a string of characters, we declare the string as an array of characters, and use double quotes:

char s[] = "ABCDEFG";

When using printf, we have seen that the format placeholder %s stands for a string. Similarly, %c stands for a single character. Since a string is just an array of characters, we can read and write each character individually, as we would for an array:

#include <stdio.h>

int main(void)
{
    char s[] = "ABCDEFG";
    printf("%c\n", s[2]);       // Prints "C" since that is the 3rd character in the string (recall that arrays start at index 0)
    s[4] = 'e';                 // Changes the 5th character "E" to lowercase "e"
    printf("%s\n", s);          // Prints "ABCDeFG"
    printf("%zu\n", sizeof(s)); // Prints "8"
    printf("%d\n", s[7]);       // Prints "0"
}

Note the last two lines: sizeof(s) is 8 bytes, but the string only has 7 characters. Furthermore, s[7], the 8th character in the string, has a value of 0. The reason is that in C, strings are null-terminated: the last character in the string is followed by a null character, which is simply a char with a value of 0. The null character indicates that the string has terminated. This also means that 'e' and "e" are not the same, as 'e' is just one character (taking 1 byte of space) while "e" is a null-terminated string (taking 2 bytes of space, including the terminating null).

C provides a variety of standard functions for manipulating strings. We will discuss some of them later in the course.

2.6 Functions ^

2.6.1 Defining functions

A function is a block of code that gets an input, executes some statements, and returns an output. C, by itself, does not contain any functions; they are either defined by the user, or imported from libraries.

main is an example of a function defined by the user, and indeed, it must be defined in any C program. Its (optional) input is given in the form of command-line arguments, as we will discuss below. Its executed statements are the main code of the program itself. Its output, as we discussed above, is an integer, with 0 (returned by default) indicating successful execution.

An example of a function imported from a library is printf, which we import by including the header file stdio.h. Its (mandatory) input is a format string and the data to print. Its executed statements print the data to the terminal using the specified format. Its output is usually not important - it's an integer indicating the number of characters printed, or a negative value if an error occurred.

Functions are mainly used as a form of abstraction. When you use a function, you only need to know that it takes a certain input, performs a certain well-defined task, and returns a certain output. The details of how the function works internally are not relevant. For example, you don't need to know how exactly printf works; all you need to know is that it prints out the data you give it as input.

Of course, when you write your own functions, you do know how they work, since you wrote them. However, what's important here is that you can modify how those functions work internally, for example to fix bugs or to optimize their performance, and yet safely keep all the rest of the code unchanged, since any statements which call those functions do so independently of how the function works internally. (This approach is taken to the next level in object-oriented programming, which we will cover later in the course.)

Virtually any non-trivial C program must make use of some user-defined functions other than main. To define a function, we use the following syntax:

type name (type1 arg1, type2 arg2, ...)
{
    statement1;
    statement2;
    // etc...
    return value;
}

Where:

• type is the data type of the function's output. If the function returns no output, we use void as the data type.
• name is the function's name, which must follow the same rules as variable names.
• The function's input takes the form of variables arg1, arg2, etc. which are of the data types type1, type2, etc. respectively. Again, if the function doesn't take any arguments, we use void instead. If the function does not change the value of the argument, use const as part of the type declaration (see below).
• The statements executed by the function are those inside the code block indicated by the curly brackets.
• value is the value to be returned as the function's output, and it must be of the data type type declared in the function's definition. Note that there can be multiple return statements in a function, e.g. if we want to return one value in one case and another value in another case; however, once return is executed, the function terminates. If the function has a return type of void, we do not need to write a return statement.

To call this function, we simply use the syntax name(arg1, arg2, ...). If the function has no input, we use empty parentheses: name().

Any variables declared in the context of the function are completely independent of the rest of the program (recall the discussion on variable scope). Variables declared elsewhere in the program are not accessible within the function, and variables declared in the function, including both the arguments and any variables declared within the function's code block, are not accessible elsewhere in the program.

A function may only be defined once in the program - if we define two functions with the same name, the compiler won't know which one to call. Furthermore, functions cannot be nested. This means that we cannot define a function inside another function, including inside the main function. Instead, each function must be defined at the highest scope (the file scope).

Most functions generally take a fixed number of arguments, which have to be of specific data types. However, printf, for example, can take any number of arguments of any type, as long as the first argument is a string specifying the number and type of the remaining arguments (e.g. "%d %s" indicates that the function should expect one integer and one string). This is called a variadic function. User-defined functions can also be variadic, but this is almost never actually needed, so we will not cover it here.

2.6.2 Constant vs. non-constant arguments ^

Here is a simple example of defining and using a function:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int64_t add(const int64_t a, const int64_t b)
{
    return a + b;
}

int main(void)
{
    printf("%" PRId64 "\n", add(5, 6));
}

The function add simply takes two 64-bit integers and gives their sum as output. This means that add(5, 6) will return the value 11, which is then printed out using printf.

Notice that we added the const modifier to the arguments to indicate - both to the compiler and to the human reading our code - that these arguments will not be modified by the function. This can often help avoiding mistakes and bugs. If, for example, we write the statement a++; as the first line of the function, the program will not compile, since a is constant and thus cannot be changed.

Often we do actually want the function to be able to modify the values of the arguments it receives as input, in which case we do not use const. However, note that in this case, only the local copy of the variable, within the function's local scope, is modified. Here is an example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void increment(int64_t x)
{
    x++;
    printf("increment(): x = %" PRId64 "\n", x);
}

int main(void)
{
    int64_t x = 0;
    increment(x);
    printf("main():      x = %" PRId64 "\n", x);
}

The output of this program is:

increment(): x = 1
main():      x = 0

The local copy of x inside the function increment() has been incremented using x++, but this does not affect the value of x in main(). The only way for a function to modify variables outside its local scope is by using pointers, which we will learn about later.

2.6.3 Recursion ^

Recursion is when a function calls itself. Of course, this only makes sense if the recursion terminates at some point, otherwise the function will be called an infinite number of times. For example, let's write a program which calculates the Fibonacci sequence. This sequence, denoted F_n, is defined for any non-negative integer n using the relations

• F₀ = 0,
• F₁ = 1,
• F_n = F_n-1 + F_n-2 for n ≥ 2.

Since each element in the sequence is defined in terms of the previous two elements, it is natural to calculate the elements of this sequence by recursion:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

uint64_t fibonacci(const uint64_t n)
{
    if (n == 0)
        return 0;
    else if (n == 1)
        return 1;
    else
        return fibonacci(n - 1) + fibonacci(n - 2);
}

int main(void)
{
    for (uint64_t i = 0; i <= 10; i++)
        printf("F_%" PRIu64 " = %" PRIu64 "\n", i, fibonacci(i));
}

Output:

F_0 = 0
F_1 = 1
F_2 = 1
F_3 = 2
F_4 = 3
F_5 = 5
F_6 = 8
F_7 = 13
F_8 = 21
F_9 = 34
F_10 = 55

The function fibonacci is literally just the definition of the sequence: it returns 0 for n = 0, 1 for n = 1, and the sum of the two previous elements for n ≥ 2.

2.6.4 Forward declaration and mutual recursion ^

Above we declared and defined add before main, because add is being used in main, and it needs to be declared before it is used. Let us move the function add after main:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    printf("%" PRId64 "\n", add(5, 6));
}

int64_t add(const int64_t a, const int64_t b)
{
    return a + b;
}

The program does not execute, and gives some errors and warnings. Here is the full output from the compiler, as displayed in the Terminal tab:

C:\Users\barak\CSE701\main.c: In function 'main':

C:\Users\barak\CSE701\main.c:7:29: warning: implicit declaration of function 'add' [-Wimplicit-function-declaration]
    7 |     printf("%" PRId64 "\n", add(5, 6));
      |                             ^~~

C:\Users\barak\CSE701\main.c:7:12: warning: format '%lld' expects argument of type 'long long int', but argument 2 has type 'int' [-Wformat=]
    7 |     printf("%" PRId64 "\n", add(5, 6));
      |            ^~~              ~~~~~~~~~
      |                             |
      |                             int

In file included from C:\Users\barak\CSE701\main.c:1:
c:\users\barak\mingw64\x86_64-w64-mingw32\include\inttypes.h:33:19: note: format string is defined here
   33 | #define PRId64 "lld"

C:\Users\barak\CSE701\main.c: At top level:
C:\Users\barak\CSE701\main.c:10:9: error: conflicting types for 'add'; have 'int64_t(const int64_t,  const int64_t)' {aka 'long long int(const long long int,  const long long int)'}
   10 | int64_t add(const int64_t a, const int64_t b)
      |         ^~~
C:\Users\barak\CSE701\main.c:7:29: note: previous implicit declaration of 'add' with type 'int()'
    7 |     printf("%" PRId64 "\n", add(5, 6));
      |                             ^~~

Build finished with error(s).

What happened here is that we tried to use the function before it was declared, and therefore the compiler had to guess what kind of data type the function returns. By default, if the compiler doesn't know what the return type of a function is, it always assumes it returns an int. So the compiler implicitly declared the function as one that returns an int. Unfortunately, the function actually return an int64_t (that is, a 64-bit instead of a 32-bit integer), and therefore the actual function doesn't match the implicit declaration.

Note that if we defined the function as returning an int, then the program would actually compile, since the implicit declaration would then match the actual definition; but it will still generate warnings, and generally you should never rely on implicit declarations. Also, note that the types of the arguments (or even the number of arguments) do not need to be known in advance, only the return type.

You're probably wondering why the compiler can't just look ahead and find the declaration later in the code. This is certainly the case in many higher-level languages, but in C and C++, the language specifications require us to always declare functions before we use them. Although it should in principle be possible to modify the compiler so that it looks ahead for the declaration, this would be a very substantial change to the way the language works, and might break older code.

Unfortunately, there are some (rare) cases where a function cannot be declared before it is used. In such cases, we must still declare the function before it is used, but we can actually define the function - that is, provide the actual statements executed by the function - anywhere we want. This is called forward declaration, and the initial declaration is called a prototype.

As a trivial example of forward declaration, we can declare the return value of the add function at the top of the file, before main, and then define it at the bottom of the file, after main:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int64_t add();

int main(void)
{
    printf("%" PRId64 "\n", add(5, 6));
}

int64_t add(const int64_t a, const int64_t b)
{
    return a + b;
}

The code now executes with no warnings. Note that in the prototype declaration int64_t add(), we only needed to declare the return type of the function. We do not need to provide the types or even the number of arguments. A prototype declared without arguments can take any number of arguments of any type.

However, if we wanted to, we could declare the prototype using the full expression int64_t add(const int64_t a, const int64_t b), and that declaration would also have served to document the input and output types of the function for a human reader. If we wanted, we could even declare int64_t add(int64_t, int64_t) without the const modifier or the variable names, and that would still work.

In this simple case, forward declaration was not actually necessary, we could have just defined the function before main and saved ourselves the trouble. However, forward declaration is mandatory in some situations, for example if two functions call each other recursively, also known as mutual recursion. Here is an example:

#include <inttypes.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

bool is_odd();

bool is_even(const int64_t n)
{
    if (n > 0)
        return is_odd(n - 1);
    else if (n < 0)
        return is_odd(n + 1);
    else
        return true;
}

bool is_odd(const int64_t n)
{
    if (n > 0)
        return is_even(n - 1);
    else if (n < 0)
        return is_even(n + 1);
    else
        return false;
}

int main(void)
{
    const int64_t n = 7;
    printf("%" PRId64 " is %s", n, is_even(n) ? "even" : "odd");
}

This is an extremely inefficient way of determining whether an integer is even or odd - we are just giving it here as an example of mutual recursion. Basically, as long as the argument is not zero, each of the functions is_even and is_odd calls the other function with an argument closer to zero by one step (subtract 1 if positive, add 1 if negative). By simulating each step manually (e.g. on a piece of paper), you can convince yourself that this is indeed a (very bad) algorithm for finding if a number is even or odd.

If you remove the prototype declaration bool is_odd(), you will see that the program does not execute, because then is_odd is called from within is_even without being declared first, so the compiler implicitly defines it as returning int instead of bool. In this case, there is no way to rearrange the program so that we do not need to declare at least one of the functions in advance. Therefore, this is one case where forward declaration must be used.

2.6.5 Global variables ^

Above we discussed local variables, which are only visible within a particular scope. Global variables are those which are defined in the highest possible scope, before any functions, including main, are declared. Since they are not local to any specific scope, they are accessible from anywhere in the program, including the main function and any other function, unless any local variables with the same names are defined.

For example, the following program does not compile, since n is only defined locally in the main function and is thus inaccessible to the print_n function:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_n(void)
{
    printf("%" PRId64 "\n", n);
}

int main(void)
{
    int64_t n = 5;
    print_n();
}

If we declare n before main but after print_n, this still doesn't work, since print_n does not know about n:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_n(void)
{
    printf("%" PRId64 "\n", n);
}

int64_t n;

int main(void)
{
    n = 5;
    print_n();
}

However, if we declare n before print_n as well, the program now works:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int64_t n;

void print_n(void)
{
    printf("%" PRId64 "\n", n);
}

int main(void)
{
    n = 5;
    print_n();
}

Note also that if we declare another variable named n in main, then that is a local variable, visible only to main, and therefore changing that variable doesn't change the value of the global variable n. In the following example, the output will not be 5, but 7:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int64_t n = 7;

void print_n(void)
{
    printf("%" PRId64 "\n", n);
}

int main(void)
{
    int64_t n = 5;
    print_n();
}

Note that the compiler will warn us that n is an unused variable - this refers to the local variable n inside main(), which we indeed never used, since only the global n was used.

2.6.6 Static variables ^

We have seen that variables defined inside functions are local to that function. They are inaccessible by any other function, and moreover, their value is discarded once the function finishes. Static variables are variables that are local to a function, but keep their values after the function has finished executing, such that the value can still be accessed and modified every subsequent time the function is called. They are defined using the keyword static before the variable definition. Here is an example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void count(void)
{
    static uint64_t n = 0;
    n++;
    printf("This function has been called %" PRIu64 " times.\n", n);
}

int main(void)
{
    count();
    count();
    count();
}

The output is:

This function has been called 1 times.
This function has been called 2 times.
This function has been called 3 times.

However, if we delete the word static, all three lines will say This function has been called 1 times.

Note that the line static int64_t n = 0 itself is called only once, that is, n is only initialized the first time the function is called. Of course, this has to be the case, otherwise there would be no point to making the variable static.

3 Advanced topics in C programming ^

3.1 Debugging with Visual Studio Code and GDB

3.1.1 Getting ready for debugging

Debugging is the process of finding and fixing bugs in your program. In this course we will debug using GDB, the GNU Debugger, which comes with GCC. This debugger is conveniently integrated into Visual Studio Code's graphical user interface. For debugging to work, a workspace must be open in Visual Studio Code (the status bar must be blue, not purple), that workspace must include a .vscode folder with a properly-configured launch.json file, and a C or C++ source file must be open in the editor.

Click on the Run icon in the Activity bar on the left (looks like a "play" button with a little bug next to it), or press Ctrl+Shift+D. This opens up the Run view, which is the one that is used when debugging. If you did not configure launch.json yet, a big blue button with the label Run and Debug will appear. If that is the case, you need go back and configure GCC and Visual Studio Code properly according to my instructions above.

If you did properly configure launch.json, you will see a dropdown menu at the top of the Run view with the name of the task you created, which should be something like "gcc - Build and debug active file". The play button can be used to start debugging, but it's usually easier to just press F5. The gear button gives quick access to launch.json.

The overflow menu (three dots) allows you to enable or disable the four components of the Run view:

• Variables
• Watch
• Call Stack
• Breakpoints

Make sure all four are enabled. The last option in this menu opens the debug console (which can also be opened with Ctrl+Shift+Y).

If you configured the args field in the tasks.json file as I previously instructed, it should look similar to this:

"args": [
    "-g",
    "${file}",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe",
    "-Wall",
    "-Wextra",
    "-Wconversion",
    "-Wsign-conversion",
    "-Wshadow",
    "-Wpedantic",
    "-std=c17",
    "-D__USE_MINGW_ANSI_STDIO=1"
],

The first argument, -g, which was added automatically by VS Code, instructs the compiler to include debugging information in the compiled binary file. This information will be used by GDB to debug the program. However, we will use the argument -ggdb3 instead:

• The -ggdb part tells GCC to produce debugging information in the format most suitable for GDB, rather than in the operating system's native format. Since we are only going to be using GDB, this option is preferable.
• The 3 indicates that the maximum possible amount of information should be provided (0 produces no debugging information at all, 1 produces minimal information, and 2 is the default). This can improve our debugging experience.

So let us delete -g and add -ggdb3 instead:

"args": [
    "${file}",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe",
    "-Wall",
    "-Wextra",
    "-Wconversion",
    "-Wsign-conversion",
    "-Wshadow",
    "-Wpedantic",
    "-std=c17",
    "-D__USE_MINGW_ANSI_STDIO=1"
    "-ggdb3"
],

(I added it at the end so that it's in the same place as the other arguments.)

3.1.2 Breakpoints and the debug toolbar ^

One of the most important aspects of debugging is the ability to set particular points in the source code as breakpoints, meaning that when the execution of the program reaches any of these points, it pauses.

To add a breakpoint at a particular line, press F9 while the cursor is in that line. This will cause a red dot to appear on the left margin of the editor, to the left of the line number, indicating that a breakpoint has been set at that line. Alternatively, you can also click with the mouse on the margin where the red dot should be.

When you add a breakpoint, it will appear in the Breakpoints section of the Run view with the name of the source file and the line number. To remove the breakpoint from a line, press F9 while the cursor is in that line, click with the mouse on the red dot, right-click on it in the Breakpoints section and choose Remove Breakpoint, or hover over it with the mouse in the Breakpoints section and click on the "X".

You can disable a breakpoint temporarily, without removing it, by clicking on the checkbox next to it in the Breakpoints section, or by directly right-clicking on the red dot in the editor and choosing Disable Breakpoint. The dot will turn grey instead of red, and the breakpoint will not cause the program to pause until you enable it again.

If you hover the mouse over the Breakpoints section you will see three buttons. The button with two circles lets you deactivate all of the breakpoints, so that the execution will not stop on any breakpoints, whether enabled or disabled. The button with two squares permanently removes all of the breakpoints.

To experiment with breakpoints, paste the following program into the editor:

#include <stdio.h>

void test(void)
{
    printf("2 ");
    printf("3 ");
}

int main(void)
{
    printf("1 "); // Place a breakpoint here
    test();
    printf("4 ");
}

Place a breakpoint at the indicated line and press F5 run the program. You will see that the program pauses its execution, the line where the breakpoint is located is highlighted, and the debug toolbar appears on top of the editor. This toolbar has the following options from left to right:

• Continue / Pause (F5)
• Step Over (F10)
• Step Into (F11)
• Step Out (Shift+F11)
• Restart (Ctrl+Shift+F5)
• Stop (Shift+F5)

First, let us try Continue / Pause (F5). You will see that the program will simply continue running until it ends. Try this, and then press F5 to run the program again and pause on the breakpoint.

Now, let us try Step Over (F10). It will execute the first line on the main function, and you will see the output 1 in the terminal. Press F10 again to step over the second line, test(). You will notice that the output 2 3 is written to the terminal, but the debugger doesn't enter the test function itself - that is the meaning of stepping over the line. Finally, press F10 again to execute the last line of the main function, which will output 4 to the terminal.

Press Restart (Ctrl+Shift+F5) to restart the program and pause on the breakpoint again. Use Step Over (F10) on the first line to step over the printf function. But when the cursor is on the second line, press Step Into (F11) to step into the test function instead of over it. By pressing Step Over (F10) inside the function, you will be able to execute it line-by-line, until you reach the end of the code block (}), which will transfer you back to the main function. If you now try to step into the printf function, you will be taken into the header file stdio.h where the function is defined, but not into the actual function, since its source code is not available to the debugger.

Next, press Restart (Ctrl+Shift+F5) again, and Step Into (F11) the test function again. Then press Step Out (Shift+F11). You will see that you stepped out of the test function and back to the main function, with the execution now on the last line of the main function. Press Stop (Shift+F5) to stop the execution without executing the last line.

A function breakpoint is a breakpoint that will be triggered when a particular function is executed, instead of on a particular line. To add one, you can use one of the following methods:

1. Click on Run > New Breakpoint > Function Breakpoint....
2. In the Run view, hover with the mouse over the Breakpoints section, and click on the plus sign.
3. Use a keyboard shortcut. This is the most convenient way, but you will have to set up this shortcut yourself. You can do so by pressing F1 to bring up the Command Pallette and choosing "Preferences: Open Keyboard Shortcuts" (or just pressing Ctrl+K Ctrl+S). Then search for "Debug: Function Breakpoint" and set the keybinding (I like to use Ctrl+F10).

Remove the existing breakpoint, and add two function breakpoints: one for main and one for test. Notice that the symbol for a function breakpoint is a red triangle instead of a red dot. When you press F5, you will see that the execution stops in the beginning of the main function. Press Continue / Pause (F5) and execution will continue, and then stop in the beginning of the test function.

3.1.3 Conditional breakpoints and logpoints ^

A conditional breakpoint is a breakpoint that only triggers if a certain condition is met, rather than whenever execution reaches the line where the breakpoint was set.

Copy the following program into the editor:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    for (uint64_t i = 1; i <= 10; i++)
        printf("%" PRIu64 " ", i); // Place a breakpoint here
}

We would like to place a conditional breakpoint at the indicated line inside the for loop, which will only trigger when i reaches the value 5. There are three ways to do this:

1. Create a normal breakpoint with F9, right-click on the red dot, select Edit Breakpoint..., and choose "Expression" from the dropdown menu.
2. Click on Run > New Breakpoint > Conditional Breakpoint....
3. Use a keyboard shortcut. As above, press F1 to bring up the Command Pallette and choose "Preferences: Open Keyboard Shortcuts" (or just press Ctrl+K Ctrl+S), search for "Debug: Conditional Breakpoint", and set the keybinding (I like to use Ctrl+F9).

Using any of these methods, create a new conditional breakpoint at the indicated line, write i == 5 as the condition, and press Enter. Notice that the red dot will have a tiny equal sign on it. Now press F5 to run the program. You will see that the numbers 0 1 2 3 4 will be printed to the terminal, and only then, when the condition i == 5 is met, the execution will stop on the breakpoint. If you press F5 to continue, the program will keep running without breaking again.

A logpoint is similar to a breakpoint, except that instead of pausing the execution of the program, it prints a message to the debug console. Programmers often emulate logpoints manually by explicitly adding a statement such as printf("i is now %" PRIu64 "\n", i) into the source code, but a logpoint allows us to do this in a more convenient and dynamic way, without changing the source code itself.

As with conditional breakpoints, there are three ways to create logpoints:

1. Create a normal breakpoint with F9, right-click on it, select Edit Breakpoint..., and choose "Log Message" from the dropdown menu.
2. Click on Run > New Breakpoint > Logpoint....
3. Set up a keybinding for "Debug: Add Logpoint..." (I like to use Alt+F9).

First remove the conditional breakpoint, and then, using any of these methods, create a new logpoint at the indicated line and type for loop is running as the message. Notice that the symbol will be a red diamond instead of a red dot. Press F5, and the message will be written to the debug console (Ctrl+Shift+Y) ten times.

Logpoints can do more than just print messages: they can evaluate expressions when they are entered inside curly brackets {}. Edit the logpoint (right-click on it and select Edit Logpoint...) and change the message to i is now {i}. When you press F5, you will see that the messages i is now 1, i is now 2, etc. will be printed to the debug console.

However, be careful: expressions evaluated by logpoints will affect the program itself! For example, if you change the message to i is now {++i}, then you will see that only even values of i will be printed, both to the debug console and the terminal, since i is actually incremented twice in each run of the loop.

Finally, note that logpoints can also be conditional; for example, under Edit Logpoint..., we can specify i == 5 for Expression and Stopped at i == {i} for Log Message. This will print the message Stopped at i == 5 to the debug console when execution reaches i == 5, but will not otherwise pause the program.

3.1.4 Variables, watches, and the call stack ^

Consider the following program, which prints out a multiplication table:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_product(const uint64_t a, const uint64_t b)
{
    printf("%3" PRIu64 " ", a * b);
}

void mul_table(const uint64_t rows, const uint64_t cols)
{
    printf("Multiplication table with %" PRIu64 " rows and %" PRIu64 " columns:\n", rows, cols);
    for (uint64_t i = 1; i <= rows; i++)
    {
        for (uint64_t j = 1; j <= cols; j++)
            print_product(i, j);
        printf("\n");
    }
}

int main(void)
{
    const uint64_t num_rows = 10; // Place a breakpoint here
    const uint64_t num_cols = 10;
    mul_table(num_rows, num_cols);
}

Let us place a (normal) breakpoint at the indicated line - or alternatively, add a function breakpoint for the main function. Press F5 and look at the Variables section of the Run view. You will see a label "Locals", and under it the variables num_rows and num_cols, which are local to the scope of the main function. Notice that both num_rows and num_cols are currently uninitialized, so they will have garbage values.

Next, look at the Call Stack section of the Run view. You will see that Thread #1 is currently "paused on breakpoint". Since our program is not multi-threaded (that is outside the scope of our course), Thread #1 is the only relevant one. If you expand this thread using the bracket on the left, you will see main() and main.c (or whatever the name of your source file is) listed. This simply indicates that we are currently in the main function of the file main.c.

Now, follow these steps and notice the changes in the Run view each time a statement is executed:

1. Press F10. num_rows will be initialized to 10. num_cols is still uninitialized.
2. Press F10. num_cols will also be initialized to 10.
3. Press F11 to step into the function mul_table.
   • Notice that the Call Stack section changed to reflect that, with mul_table appearing above main; the order of the functions in the stack indicates that when mul_table finishes executing, control will be passed down to main.
   • Also notice that the variables in the Variables section are now rows, and cols, the variables local to the scope of mul_table. They will both have the value of 10 that they obtained via the function call. If you click on main in the call stack, you will see num_rows and num_cols again.
4. Press F10. Now we have entered the scope of the first for loop. A new variable i will be added to the list, uninitialized.
5. Press F10. Now we have entered the scope of the second for loop. i will be initialized to 1. A new variable j will be added to the list, uninitialized.
6. Press F10. j will be initialized to 1.
7. Press F11 to step into the function print_product.
   • Again, notice that this function is now on top of the call stack.
   • The Variables section now lists only the variables a and b, both equal 1 since those were the values passed to the function as arguments. I intentionally gave them different names to stress that they are different variables, not the same variables i and j that were local to mul_table.
8. Press F10. 1 will be printed to the terminal.

You can continue pressing F10, and see the variables i and j gradually increase and their products being printed to the terminal. Also, if the focus is on the Variables section, you can start typing the name of a variable, and it will be highlighted. This feature is useful when you have many variables and you're looking for a specific one.

In the Watches section of the Run view, you can click on the plus icon to create a new watch. This can be any expression, and it will be evaluated in real time as the program runs. Some examples of watches you can try include:

• i * j will show which number will be printed to the terminal in each iteration of the loop.
• cols * i + j - 10 will show which element in the table (out of 100) is currently being printed.
• i == j will evaluate to 1 if dealing with a diagonal element.

However, note that when i and/or j are out of scope - for example, when if you step into print_product, or even when the second for loop is finished printing a full row and therefore j is no longer defined - then expressions with i and j cannot be calculated.

Finally, you can press Shift+F11 (Step Out) to step out of mul_table, which will take you back to main with the entire table printed.

The variables in the Variables section can be of any type, including arrays, strings, and other types we will define below. Here is an example with a string:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    char letters[] = "abcde";
    for (uint64_t i = 0; i < 5; i++)
        printf("%c \n", letters[i]); // Place a breakpoint here
}

When you place a breakpoint at the indicated line and press F5 run the program, you will see the variables i and letters in the Variables section. Recall that strings in C are actually arrays of integers of type char, terminated with a null character, which has the value 0. You can expand letters to see that this is in fact the case.

Sometimes it's useful to be able to change the values of variables to see what happens. You can try it out with this program. First press F10, and you will see the letter a printed to the terminal. Now, before the letter b is printed, double-click on it (element [1] of the array) and change its value to 122, which corresponds to the letter z. Press F10 two more times and you will see that the letter z was printed to the terminal, not b.

3.1.5 Using the debug console ^

Above we saw that logpoints print log messages to the debug console. Another very important use of the debug console is to evaluate expressions manually during the run time of the program: simply write an expression at the bottom of the debug console and press Enter. You can also write expressions with multiple lines by pressing Shift+Enter to separate the lines (although this is seldom needed, since C++ doesn't care about newlines).

To illustrate how to use the debug console, let us use the following program:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int64_t square(const int64_t x)
{
    return x * x;
}

void print_square(const int64_t x)
{
    printf("%" PRId64 "\n", square(x));
}

int main(void)
{
    const int64_t n = 2;
    print_square(n); // Place a breakpoint here
}

Place a breakpoint at the indicated line, and press F5 run the program. Now go to the debug console (Ctrl+Shift+Y) and try the following:

• Calculations using standard operations. For example, 1 + 1 will print 2 to the debug console.
• Expressions involving variables in your program. For example:
  • n will print 2 to the debug console.
  • n = 9 will change the value of n to 9 and print that value to the debug console. (Note that the value of n will not change in the Variables section, but it will change if you add a watch.)
  • n will now print 9 to the debug console.
• Calls to functions defined in the program. For example:
  • square(5) will print 25 to the debug console.
  • square(n) will print 81 to the debug console.
  • print_square(n) will print void to the debug console, since that's the return type of print_square, but it will print 81 to the terminal.
• Calls to functions not defined in your program, but accessible by it, meaning that the proper header file has been included. For example, printf("test") will print test to the terminal.

3.1.6 Further reading about debugging ^

If you want to know more about debugging in Visual Studio Code, the relevant chapters of the user guide and the C/C++ extension guide provide a good overview, which also includes many screenshots. In addition, this page lists advanced configuration options that can be used in launch.json.

3.2 Floating-point data types ^

3.2.1 Floating-point numbers and bit width

For applications such as scientific computing, integers are not enough; we need to be able to do calculations with non-integer numbers. Furthermore, even a 64-bit long long int can only take values with magnitude up to roughly 9×10¹⁸, but sometimes we need to do calculations with larger numbers.

One option is to use infinite-precision (or arbitrary-precision) arithmetic, which allows doing calculations with arbitrary real numbers (or at least, arbitrary computable numbers) with any number of digits and of any magnitude.

Unfortunately, infinite-precision arithmetic is not implemented at the hardware level, but rather at the software level using special libraries (which we will discuss later in the context of C and C++). Therefore, infinite-precision calculations are much slower compared to calculations that can be done directly at the level of the CPU. Unless you're doing calculations in pure math, where it is crucial to get precise results rather than approximations, it is almost never worth it to use infinite-precision arithmetic.

The CPU represents and manipulates non-integer numbers using floating-point arithmetic. Unlike integer and infinite-precision numbers, which are always exact, floating-point numbers are almost always just an approximation. This is because there is an infinite number of real numbers within any interval, but only a limited number of floating-point representations, based on how many bits are allocated to represent the number. A 32-bit floating-point number, for example, will only allow storing at most 2³² different real numbers, by definition. Therefore, we can only represent numbers with a limited number of significant digits.

Floating-point arithmetic is generally very fast. In fact, a popular way to measure the performance of a computer is to find out how many floating-point operations per second (or FLOPS) it can achieve. Roughly speaking, an average laptop can achieve several hundred gigaFLOPS (where gigaFLOPS = 10⁹ FLOPS), a high-end PC with a top-of-the-line GPU can achieve a few dozen teraFLOPS (where teraFLOPS = 10¹² FLOPS), and the fastest supercomputers in the world right now can achieve several hundred petaFLOPS (where petaFLOPS = 10¹⁵ FLOPS).

A floating-point number is encoded in the CPU in a form similar to:

significand × base^exponent,

where:

• The significand (also called the mantissa) is an integer representing the significant digits of the number.
• The base is an integer representing the base of the number: usually 2 (binary), but it is also possible to use 10 (decimal) on some systems.
• The exponent is an integer representing the power to which we take the base.

For example, the number 42.75 is represented as a floating-point number as follows:

42.75 = 4275 × 10^-2.

This example is in base 10 because that's the base we are used to; but in the computer, this number will be represented as sequence of bits. Here there are some complications that we will discuss below, but just for the purpose of illustration, in base 2, this number has the form 101010.11. Therefore, its floating-point representation will be (notice that the base and exponent are also in binary, so 10 is actually 2):

101010.11 = 10101011 × 10^-10.

Since the base is fixed, we only have two integers to store: the significand and the exponent. In this case, the significand requires 8 bits and the exponent requires 2 bits. Now, imagine that we only have 7 bits of storage for the significand. Then we will have to truncate 10101011 to 1010101 and compensate by decreasing the exponent, so the number will be:

101010.1 = 1010101 × 10^-1.

In decimal, this is 42.5, which is a very crude approximation of the original number. Of course, in practice, floating-point numbers have more than 7 bits of storage. But no matter how many bits you have, floating-point numbers will always be just approximations, except for some specific numbers that can be represented exactly, such as 42.5 in this example.

In C (as in most programming languages), floating-point numbers are represented using the IEEE-754 floating-point standard, which is more complicated than our simple example. Here is how floating-point numbers are actually stored in memory:

• Floating-point numbers are always signed, and the sign is stored in the first bit: 0 for positive and 1 for negative.
• The next bits represent the exponent. The exponent is also signed. The way this works is that, for N bits in the exponent, the actual exponent is the bit value minus 011..111 (zero followed by N-1 ones), that is, the value minus 2^N-1-1. We say that the exponent has a bias of 2^N-1-1. So 011..111 is an exponent of zero, 011..110 is -1, 100..000 (one followed by N-1 zeros) is +1, and so on. Furthermore, the representations 000..000 (all 0s) and 111..111 (all 1s) are reserved for special numbers, which we will discuss below. Therefore, the available range of exponents is from -(2^N-1-2) to +2^N-1-1.
• The rest of the bits represent the significand. However, although in the examples above I used an integer significand for simplicity, in IEEE-754 the significand is a fraction of the form 1 followed by a radix point (analogous to a decimal point, but in binary) and then the rest of the bits. This is similar to scientific notation; there is always exactly one digit before the radix point. Since that digit is always 1 (there are no other options - unlike in decimal, where it can be any digit from 1 to 9), the first 1 is implied and is not stored explicitly. So effectively we have one more bit of storage, but we must reserve a special value for zero.

3.2.2 Single, double, and extended precision ^

The three floating-point types used in C are:

• float, or single-precision floating-point type. Uses a total of 32 bits, of which 1 is a sign, 8 are for the exponent, and 23 (effectively 24) for the significand.
• double, or double-precision floating-point type. Uses a total of 64 bits, of which 1 is a sign, 11 are for the exponent, and 52 (effectively 53) for the significand.
• long double, or extended-precision floating-point type. The number of bits here is platform-dependent, but on x86 systems it generally uses a total of 80 bits, of which 1 is a sign, 15 are for the exponent, and 64 for the significand. (Since this is not a standard IEEE-754 type, it does not use the trick where the first bit is implied to be 1.)

Note that the C standard merely requires that long double is at least as precise as double and double is at least as precise as float, but the exact sizes depend on the implementation. However, the sizes of 32, 64, and 80 bits are implemented in most systems.

The following program is analogous to the program we used above to display the ranges of integers:

#include <float.h>
#include <stdio.h>

int main(void)
{
    printf("\nA %s has a minimum value of %e and a maximum value of %e, with at least %d decimal digits of precision.\n", "float", FLT_MIN, FLT_MAX, FLT_DIG);
    printf("\nA %s has a minimum value of %e and a maximum value of %e, with at least %d decimal digits of precision.\n", "double", DBL_MIN, DBL_MAX, DBL_DIG);
    printf("\nA %s has a minimum value of %Le and a maximum value of %Le, with at least %d decimal digits of precision.\n", "long double", LDBL_MIN, LDBL_MAX, LDBL_DIG);
}

Here are some new things in this code:

• The header file float.h stores the limits of floating-point types, just as limits.h stores the limits of integer types. They are stored in the variables FLT_MIN, FLT_MAX, and so on.
• The format placeholder %e for printf indicates that a floating-point number is to be printed using scientific notation, i.e. as a significand followed by an exponent. The output will have the format X.XXXe±YYY where X.XXX is the significand and ±YYY is the exponent. %E does the same, but with an uppercase E for the exponent.
• The syntax %Le is necessary if using a long double, similarly to how %lld is necessary if using a long long. On my computer, the output is:

A float has a minimum value of 1.175494e-38 and a maximum value of 3.402823e+38, with at least 6 decimal digits of precision.

A double has a minimum value of 2.225074e-308 and a maximum value of 1.797693e+308, with at
least 15 decimal digits of precision.

A long double has a minimum value of 3.362103e-4932 and a maximum value of 1.189731e+4932, with at least 18 decimal digits of precision.

On your computer, the output might be different, as your operating system, CPU, and/or compiler might not support an 80-bit long double.

In choosing between these data types, there are five factors that need to be taken into consideration:

1. Range:
   • float has a very limited range, which is often insufficient. For example, the Planck time, a fundamental unit of measurement in theoretical physics, is approximately 5.4e-44 seconds, which is too small to be represented by a float.
   • The range of double is sufficient for almost any conceivable scientific calculation.
   • The range of long double is basically overkill and not needed in most applications.
2. Precision:
   • float has very low precision, only guaranteeing 6 significant digits. It is therefore unsuitable for scientific calculations where accuracy is important.
   • double provides a very significant improvement, more than doubling the number of significant digits.
   • The improvement provided by long double isn't as significant, but those few extra digits may prove to be very important in some applications.
3. Memory:
   • float takes the least amount of space, 32 bits.
   • double takes double that space, 64 bits.
   • long double, even though it technically only uses 80 bits, is actually stored in memory using 96 or 128 bits, because the computer likes to access memory in 32-bit increments. If you need to store billions of numbers in memory, this might be an issue; for example, 1 billion float numbers will take up 4 GB of memory, compared to up to 16 GB for long double numbers.
4. Performance:
   • On most 64-bits systems, float and double offer roughly the same performance.
   • long double will generally be slower on 64-bit Intel and AMD CPUs, since it is calculated using an older and slower instruction set (namely x87, while the newer SSE instruction set only supports up to 64-bits floating-point numbers).
5. Portability:
   • float and double are supported by virtually all 64-bit CPUs, operating systems, and compilers.
   • An 80-bit long double is not always supported. For example, in the Microsoft Visual C++ compiler, long double and double are both 64-bit. (This is done for maximum compatibility with different types of CPUs.)

My recommendation is as follows:

• The only situation where you should use float is if memory is limited. In all other cases, float should be avoided, as it provides much less precision with no boost to performance.
• double should be used in most cases. It is also the default floating-point type used by the C standard library functions.
• long double should only be used when very high precision and/or range are desired, provided you are absolutely sure your program will only run on platforms that support 80-bit floating-point types, and you are willing to accept the trade-off of slower performance and higher memory usage.

3.2.3 Entering and printing floating-point numbers ^

Constant numbers written in the source code are automatically interpreted as double if they contain a decimal point followed by at least one digit. This digit can also be 0, so e.g. 1 is an integer but 1.0 is a floating-point number. To interpret them as float instead, append f to the number , e.g. 1.0f. To interpret them as long double, append L to the number , e.g. 1.0L.

We have seen above that %e is used to print floating-point numbers in scientific notation, that is, with an exponent. %f prints the number as-is, without an exponent, which can sometimes result in very long numbers. If a number is added after the %, this specifies the width for the purpose of alignment on the screen - as we saw above for integers. For example, %20f indicates that the number should take a space of (at least) 20 characters, padding with spaces if needed. Note that the decimal point also counts as one characters, so 123.456 has a width of 7.

If a . is added after the width (or after the %, if no width is specified), this specifies the number of digits to print after the decimal point. For example, %.10f indicates that there should be 10 digits after the decimal point. The default, if no value is entered, is 6 digits, so %f is equivalent to %.6f This is illustrated in the following code:

#include <stdio.h>

int main(void)
{
    const double d = 1.23456789;
    printf("%12.2f\n", d);
    printf("%12.4f\n", d);
    printf("%12f\n", d);
    printf("%12.8f\n", d);
    printf("%12.10f\n", d);
}

The output is:

        1.23
      1.2346
    1.234568
  1.23456789
1.2345678900

Notice that the numbers get rounded, not truncated. With 2 digits after the decimal, the number gets rounded down to 1.23 since the next digit is 4, while with 4 digits, it gets rounded up to 1.2346 since the next digit is 6.

3.2.4 Rounding errors and special values ^

In the last line of the program above, we printed the number 1.23456789 with 10 digits after the decimal, which is 2 more than the 8 digits after the decimal in the original number, and as a result it seemingly got padded with zeros. This seems to indicate that the number 1.23456789 is stored exactly as-is in memory. Unfortunately, that is not the case.

As we explained above, only a very small set of real numbers can be represented exactly using the limited number of bits available to us - and 1.23456789 is not one of those numbers. The difference between the intended number and the number stored in memory is called a rounding error.

For example, consider the following program:

#include <stdio.h>

int main(void)
{
    const float f = 1.23456789f;
    const double d = 1.23456789;
    const long double l = 1.23456789L;
    printf("float:       %.20f\n", f);
    printf("double:      %.20f\n", d);
    printf("long double: %.20Lf\n", l);
}

The output on my computer is:

float:       1.23456788063049316406
double:      1.23456788999999989009
long double: 1.23456789000000000003

We can see that all three floating-point data types get the first 8 significant digits right, but then differences begin to appear:

• float, which has the smallest precision, essentially replaced the last digit, 9, with a number that is very close to 8, and the rounding error is of the order of 10^-8.
• double does a better job, replacing the last digit, 9, with something very close to 9, and the rounding error only appears in the 16th digit after the decimal, so it is of the order of 10^-16
• long double, of course, provides the highest precision. The rounding error now only appears in the 20th digit after the decimal, so it is of the order of 10^-20. However, there is still a rounding error!

You will find that most real numbers inevitably introduce rounding errors when represented as floating-point numbers. This is especially true for non-integers, but even large enough integers cannot be represented exactly. For example, 4e10 can be represented exactly as a float, but 5e10 cannot, although is can still be represented exactly as a double or long double. If we go up to 5e22, it cannot even be represented exactly as double anymore, but it can be represented exactly as a long double:

#include <stdio.h>

int main(void)
{
    printf("float:       %54.30f\n", 4e10f);
    printf("double:      %54.30f\n", 4e10);
    printf("long double: %54.30Lf\n\n", 4e10L);

    printf("float:       %54.30f\n", 5e10f);
    printf("double:      %54.30f\n", 5e10);
    printf("long double: %54.30Lf\n\n", 5e10L);

    printf("float:       %54.30f\n", 5e22f);
    printf("double:      %54.30f\n", 5e22);
    printf("long double: %54.30Lf\n", 5e22L);
}

Output:

float:                   40000000000.000000000000000000000000000000
double:                  40000000000.000000000000000000000000000000
long double:             40000000000.000000000000000000000000000000

float:                   49999998976.000000000000000000000000000000
double:                  50000000000.000000000000000000000000000000
long double:             50000000000.000000000000000000000000000000

float:       49999998890981541806080.000000000000000000000000000000
double:      49999999999999995805696.000000000000000000000000000000
long double: 50000000000000000000000.000000000000000000000000000000

In the case of fractions, those that can be written exactly in binary (to within the bit limit of the significand) can generally be represented exactly as floating-point numbers. For example, 0.25 = 1/4 can be written in binary as 0.01, but 0.20 = 1/5 has the binary representation 0.0011 (i.e. 0011 repeating infinitely). Therefore, the former can be represented exactly, but the latter cannot - although it is, of course, more exact as a double and even more exact as a long double:

#include <stdio.h>

int main(void)
{
    printf("float:       %.30f\n", 0.25f);
    printf("double:      %.30f\n", 0.25);
    printf("long double: %.30Lf\n\n", 0.25L);

    printf("float:       %.30f\n", 0.20f);
    printf("double:      %.30f\n", 0.20);
    printf("long double: %.30Lf\n", 0.20L);
}

Output:

float:       0.250000000000000000000000000000
double:      0.250000000000000000000000000000
long double: 0.250000000000000000000000000000

float:       0.200000002980232238769531250000
double:      0.200000000000000011102230246252
long double: 0.200000000000000000002710505431

Another interesting feature of floating-point numbers is that some sequences of bits are reserved to represent special numbers. These include:

• Negative zero, -0.0, which is simply zero with the sign bit set to 1. It is the same as the usual (positive) zero, but behaves as a negative number in arithmetic, so for example -0 × +0 = -0 and -0 × -0 = +0.
• Positive and negative infinity, +∞ and -∞, which are obtained whenever a result's magnitude is above the maximum value allowed by the data type (e.g. above roughly 1.797693e+308 for a double), or for example when dividing by zero.
• Not-a-Number, NaN, which is obtained whenever the result is undefined or indeterminate, such as when dividing zero by zero or infinity by infinity.

The following program demonstrates this:

#include <stdio.h>

int main(void)
{
    printf("+0.0 * +0.0 = %+.1f\n", +0.0 * +0.0);
    printf("-0.0 * +0.0 = %+.1f\n", -0.0 * +0.0);
    printf("-0.0 * -0.0 = %+.1f\n\n", -0.0 * -0.0);

    printf("double:      2 * 1.7e+308 = %.1e\n", 2 * 1.7e+308);
    printf("long double: 2 * 1.7e+308 = %.1Le\n\n", 2 * 1.7e+308L);

    printf("1.0 / 0.0 = %e\n", 1.0 / 0.0);
    printf("0.0 / 0.0 = %e\n", 0.0 / 0.0);
}

Output:

+0.0 * +0.0 = +0.0
-0.0 * +0.0 = -0.0
-0.0 * -0.0 = +0.0

double:      2 * 1.7e+308 = inf
long double: 2 * 1.7e+308 = 3.4e+308

1.0 / 0.0 = inf
0.0 / 0.0 = nan

Note that here we used the specifier + after % to print out the sign whether the number is positive or negative.

All of these special numbers are represented by specific strings of bits within the floating-point representation that are not used for other numbers. We won't discuss how exactly this works, since it is beyond the scope of this course. Interested students can check the Wikipedia pages for floating-point arithmetic and IEEE 754 for this and many other technical details of floating-point numbers.

3.2.5 Diving deeper into the floating point representation ^

The following program contains the function IEEE754_float(), which takes a number as a string and prints out its binary IEEE-754 representation, that is, the actual bits stored in memory, as well as some additional information. The reason it takes the number as a string is so that it can print out both the number we wanted and the number we actually got, which in most cases will be different.

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void IEEE754_float(const char* str)
{
    printf("32-bit IEEE-754 representation of %s:\n", str);

    const float flt = strtof(str, NULL);
    const uint32_t bits = *(uint32_t*)&flt;
    char sign = (char)(((bits >> 31) & 1) + '0');
    char exp[] = "00000000";
    for (size_t i = 0; i < 8; i++)
        exp[i] = (char)(((bits >> (30 - i)) & 1) + '0');
    char mantissa[] = "00000000000000000000000";
    for (size_t i = 0; i < 23; i++)
        mantissa[i] = (char)(((bits >> (22 - i)) & 1) + '0');
    printf("%c|%s|%s\n", sign, exp, mantissa);

    printf("Sign bit: %c -> %s\n", sign, sign == '1' ? "negative" : "positive");
    printf("Exponent: %s - 01111111 -> ", exp);
    const int32_t the_exp = (int32_t)(strtol(exp, NULL, 2) - 127);
    if (the_exp == 128)
        printf("128 (inf or nan)\n");
    else
        printf("%" PRId32 "\n", the_exp);
    char mantissa_val_str[33] = "001111111";
    strcat_s(mantissa_val_str, 33, mantissa);
    uint32_t mantissa_val_int = strtoul(mantissa_val_str, NULL, 2);
    printf("Mantissa: 1.%s -> %f\n", mantissa, *(float*)&mantissa_val_int);
    printf("Actual number: %.32f\n\n", *(float*)&bits);
}

int main(void)
{
    IEEE754_float("0");
    IEEE754_float("-0");
    IEEE754_float("1");
    IEEE754_float("-1");
    IEEE754_float("1.234");
    IEEE754_float("1.25");
    IEEE754_float("1e-20");
    IEEE754_float("1e+20");
    IEEE754_float("nan");
    IEEE754_float("inf");
}

Here is the output:

0|00000000|00000000000000000000000
Sign bit: 0 -> positive
Exponent: 00000000 - 01111111 -> -127
Mantissa: 1.00000000000000000000000 -> 1.000000
Actual number: 0.00000000000000000000000000000000

32-bit IEEE-754 representation of -0:
1|00000000|00000000000000000000000
Sign bit: 1 -> negative
Exponent: 00000000 - 01111111 -> -127
Mantissa: 1.00000000000000000000000 -> 1.000000
Actual number: -0.00000000000000000000000000000000

32-bit IEEE-754 representation of 1:
0|01111111|00000000000000000000000
Sign bit: 0 -> positive
Exponent: 01111111 - 01111111 -> 0
Mantissa: 1.00000000000000000000000 -> 1.000000
Actual number: 1.00000000000000000000000000000000

32-bit IEEE-754 representation of -1:
1|01111111|00000000000000000000000
Sign bit: 1 -> negative
Exponent: 01111111 - 01111111 -> 0
Mantissa: 1.00000000000000000000000 -> 1.000000
Actual number: -1.00000000000000000000000000000000

32-bit IEEE-754 representation of 1.234:
0|01111111|00111011111001110110110
Sign bit: 0 -> positive
Exponent: 01111111 - 01111111 -> 0
Mantissa: 1.00111011111001110110110 -> 1.234000
Actual number: 1.23399996757507324218750000000000

32-bit IEEE-754 representation of 1.25:
0|01111111|01000000000000000000000
Sign bit: 0 -> positive
Exponent: 01111111 - 01111111 -> 0
Mantissa: 1.01000000000000000000000 -> 1.250000
Actual number: 1.25000000000000000000000000000000

32-bit IEEE-754 representation of 1e-20:
0|00111100|01111001110010100001000
Sign bit: 0 -> positive
Exponent: 00111100 - 01111111 -> -67
Mantissa: 1.01111001110010100001000 -> 1.475739
Actual number: 0.00000000000000000000999999968266

32-bit IEEE-754 representation of 1e+20:
0|11000001|01011010111100011101100
Sign bit: 0 -> positive
Exponent: 11000001 - 01111111 -> 66
Mantissa: 1.01011010111100011101100 -> 1.355253
Actual number: 100000002004087734272.00000000000000000000000000000000

32-bit IEEE-754 representation of nan:
0|11111111|10000000000000000000000
Sign bit: 0 -> positive
Exponent: 11111111 - 01111111 -> 128 (inf or nan)
Mantissa: 1.10000000000000000000000 -> 1.500000
Actual number: nan

32-bit IEEE-754 representation of inf:
0|11111111|00000000000000000000000
Sign bit: 0 -> positive
Exponent: 11111111 - 01111111 -> 128 (inf or nan)
Mantissa: 1.00000000000000000000000 -> 1.000000
Actual number: inf

The output is mostly self-explanatory. Notice that inf and nan are indicated by setting the exponent to 128. You should try it out with different numbers to see what you get. Developing intuition for how floating point numbers work is very important, because using them incorrectly can and will lead to incorrect results.

In this program, I used some more advanced programming techniques such as pointers and string operations, which I will not explain right now, as we will learn about them later in a more organized fashion. Come back after the C portion of the course is over, and the code will be much easier to understand.

3.2.6 Common mathematical functions ^

The header file tgmath.h contains many useful mathematical functions that act on floating-point numbers. In older C standards, you had to use math.h, which contained a different function for each type; for example, exp() is the exponential function that takes a double and outputs a double, while expf() does the same with float and expl() with long double. However, tgmath.h, which stands for type-generic math, is much convenient since it offers just one function exp() which accepts all data types.

Here is an example:

#include <stdio.h>
#include <tgmath.h>

int main(void)
{
    const double x = 2.0;
    printf("sqrt(2)   = %f\n", sqrt(x));
    printf("exp(2)    = %f\n", exp(x));
    printf("log(2)    = %f\n", log(x));

    const long double pi = acos(-1.0L);
    printf("sin(pi/4) = %Lf\n", sin(pi / 4));
    printf("cos(pi/3) = %Lf\n", cos(pi / 3));
    printf("tan(pi/2) = %Lf\n", tan(pi / 2));
}

The output on my computer is:

sqrt(2)   = 1.414214
exp(2)    = 7.389056
log(2)    = 0.693147
sin(pi/4) = 0.707107
cos(pi/3) = 0.500000
tan(pi/2) = -36893488147419103232.000000

Here I used a trick: to find the value of pi, I took the arccosine of -1, acos(-1.0L). Note that tan(pi/2) should be infinity, but due to accumulating errors, it is merely a very large but non-infinite number. As we stressed before, floating-point arithmetic is not precise! Infinite-precision arithmetic would have provided us with the exact answer "infinity", but would have taken longer to calculate.

For a full list of the available functions in tgmath.h, please see the C reference.

3.2.7 Complex numbers ^

In scientific programming, we sometimes need to use complex numbers, that is, numbers of the form a+ib where i²=-1. For example, complex numbers are used in Fourier transforms. The header file tgmath.h allows us to use complex numbers in C. (There is also another header file complex.h which was used in older C standards, but it is not type-generic and thus less convenient to use.)

We declare complex variables using float complex, double complex, or long double complex, and enter the imaginary unit i using I. Many functions declared in tgmath.h, such as exp, log, and so on, work on complex numbers as well.

Furthermore, there are functions specific to complex numbers:

• creal returns the real part.
• cimag returns the imaginary part.
• conj returns the complex conjugate.
• carg returns the argument (or phase), i.e. the angle on the complex plane.
• fabs returns the absolute value (or magnitude). Do not use cabs, as it is not type-generic.

Here is an example:

#include <stdio.h>
#include <tgmath.h>

int main(void)
{
    const double complex z = 1 + 2 * I;
    printf("z      = %4.1f%+4.1fi\n", creal(z), cimag(z));
    printf("z*     = %4.1f%+4.1fi\n", creal(conj(z)), cimag(conj(z)));
    printf("|z|    = %9f\n", fabs(z));
    printf("arg(z) = %9f\n", carg(z));
    printf("z^2    = %4.1f%+4.1fi\n", creal(pow(z, 2)), cimag(pow(z, 2)));
    printf("1/z    = %4.1f%+4.1fi\n", creal(1 / z), cimag(1 / z));
}

Output:

z      =  1.0+2.0i
z*     =  1.0-2.0i
|z|    =  2.236068
arg(z) =  1.107149
z^2    = -3.0+4.0i
1/z    =  0.2-0.4i

3.3 Type conversion ^

As we have seen, variables in C belong to very strictly defined and constrained data types. However, it is possible to convert from one type to another.

3.3.1 Implicit conversion

When a value in one type is assigned to a variable declared in another type, that value is implicitly converted to the target variable's type. For example, a number with a decimal point in the source code is automatically interpreted as a double, but if we assign it to a variable with an integer data type, it will be implicitly converted to an integer. Note that the value will not be rounded to the nearest integer; anything after the decimal point will simply be thrown away.

To illustrate, the following code will output 3, meaning that x has the value 3 and not 3.6, due to implicit conversion from double to int64_t:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 3.6;
    printf("%" PRId64 "\n", x);
}

If you turned on the -Wconversion compiler flag as I instructed above, you will be warned that this implicit conversion changes the value of x. Therefore, it is very important to turn this warning flag on, as otherwise you may not be aware that x does not have the correct value.

3.3.2 Explicit conversion: type casting ^

A value can be explicitly converted from one data type to another using type casting. To do this, add the target type in brackets before the value to be converted.

One example where this is needed is when we divide two integers. In C, dividing two integers results in an integer, with anything after the decimal truncated. So for example, 5/3 ≈ 1.666667 will be truncated to 1. To get a fraction, we must first cast the integers to a floating-point data type such as double:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int64_t x = 5, y = 3;
    // Integer division truncates towards zero, so 5/3 will be truncated to 1.
    printf("Integer division:   x / y = %" PRId64 "\n", x / y);
    // Generates a warning and does not print the correct result, since we are trying to format an integer as a floating-point number.
    printf("No casting:         x / y = %f\n", x / y);
    // Generates a warning, but does print the correct result since x is cast to double.
    printf("Casting x:          x / y = %f\n", (double)x / y);
    // Same as the last one, but this time we cast y to double, with the same effect.
    printf("Casting y:          x / y = %f\n", x / (double)y);
    // To avoid the warning, we must cast both integers to double.
    printf("Casting both:       x / y = %f\n", (double)x / (double)y);
}

Output:

Integer division:   x / y = 1
No casting:         x / y = 0.000000
Casting x:          x / y = 1.666667
Casting y:          x / y = 1.666667
Casting both:       x / y = 1.666667

3.4 Pointers ^

3.4.1 Memory addresses and the stack

Any variable defined in C (or indeed, any programming language) is stored in the computer's memory. We can find the variable's address - a number specifying where in the memory it is stored - by preceding the variable's name with an ampersand &. Consider the following program:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int8_t var_int8_t = 0;
    const int16_t var_int16_t = 0;
    const int32_t var_int32_t = 0;
    const int64_t var_int64_t = 0;
    const long double var_long_double = 0;
    const double var_double = 0;
    const float var_float = 0;

    printf("sizeof(var_int8_t)      = %2zu, &var_int8_t      = %p\n", sizeof(var_int8_t), (void *)&var_int8_t);
    printf("sizeof(var_int16_t)     = %2zu, &var_int16_t     = %p\n", sizeof(var_int16_t), (void *)&var_int16_t);
    printf("sizeof(var_int32_t)     = %2zu, &var_int32_t     = %p\n", sizeof(var_int32_t), (void *)&var_int32_t);
    printf("sizeof(var_int64_t)     = %2zu, &var_int64_t     = %p\n", sizeof(var_int64_t), (void *)&var_int64_t);
    printf("sizeof(var_long_double) = %2zu, &var_long_double = %p\n", sizeof(var_long_double), (void *)&var_long_double);
    printf("sizeof(var_double)      = %2zu, &var_double      = %p\n", sizeof(var_double), (void *)&var_double);
    printf("sizeof(var_float)       = %2zu, &var_float       = %p\n", sizeof(var_float), (void *)&var_float);
}

On my computer, one possible output is as follows:

sizeof(var_int8_t)      =  1, &var_int8_t      = 000000af047ff7ff
sizeof(var_int16_t)     =  2, &var_int16_t     = 000000af047ff7fc
sizeof(var_int32_t)     =  4, &var_int32_t     = 000000af047ff7f8
sizeof(var_int64_t)     =  8, &var_int64_t     = 000000af047ff7f0
sizeof(var_long_double) = 16, &var_long_double = 000000af047ff7e0
sizeof(var_double)      =  8, &var_double      = 000000af047ff7d8
sizeof(var_float)       =  4, &var_float       = 000000af047ff7d4

This program prints out the memory addresses of variables of various bit sizes. The output will change every time you run the program, since the program's memory is allocated in a different location each time it runs.

To print the addresses, I used the format placeholder %p, which is intended specifically to print memory addresses. The type cast (void *) is used to convert the pointers to the appropriate data type, void *, which is expected by %p. (The code will work even without the casting, but it will produce warnings.)

%p prints out each address as a 16-digit hexadecimal number, which is appropriate since its size is exactly 64 bits. Hexadecimal is base 16, so one hexadecimal digit represents log₂16 = 4 bits, and thus 16 digits represent 16 × 4 = 64 bits.

For the digits above 9, we use a = 10, b = 11, c = 12, d = 13, e = 14, and f = 15. Therefore, 0000000000000000 is the very first memory address, and ffffffffffffffff would be the largest address it is possible to access on a 64-bit system (if I happened to have 2⁶⁴ bytes = 16 exabytes of memory).

The memory for these variables was allocated automatically by the compiler; I didn't have to explicitly allocate memory for them. This means that these variables are stored in the stack, which is the (small) portion of memory used to store all of the variables for which memory has been automatically allocated.

The stack is small, typically around 1-8 MB, and is generally used to store small amounts of temporary data, such as local variables, and not anything that's too big (such as large arrays) or that needs to be stored for a long time, which should instead be stored in the heap (more on that later).

As you can see by comparing the last digits of each address, newer variables stored at lower addresses than older variables. This is how addresses in the stack are usually allocated: from top to bottom. The data for the variables themselves is stored in consecutive bytes in ascending order, so for example, var_int16_t takes up the 2 bytes at the addresses 000000af047ff7fc and 000000af047ff7fd.

If you run the program several times, you may notice that the last digit always stays the same; this is due to stack alignment. On 64-bit CPUs, memory blocks are aligned to 16 bytes (or 128 bits), which means each block starts at a memory address that is a multiple of 16 - and therefore the starting address always ends with a 0, even though the preceding digits can be arbitrary. Since the stack for this program always contains the same variables with the same sizes, their addresses will always have the same last digit.

The stack pointer holds the address of the last variable that was allocated in the stack. When a new variable is declared, the stack pointer goes down one step, and when the scope of a variable expires (i.e. we exit the code block in which it was declared), the stack pointer goes up one step. You can see an illustration on Wikipedia.

You may be wondering why there is a gap of 3 bytes between var_int8_t and var_int16_t (in hexadecimal, f - c = 3), even though var_int16_t only takes up 2 bytes. This is again due to alignment; each variable must be stored at an address that is an integer multiple of the size of the variable, so var_int16_t must be stored at an even address. Storing it at 00000012afdff9fd would eliminate the gap, but would also violate the alignment, since this address is odd. If you add another 1-byte variable between var_int8_t and var_int16_t, then you will see that it fills the gap.

3.4.2 Using pointers ^

A pointer is simply a variable which points to a particular address in memory. As I said in the introduction, C, unlike higher-level programming languages, allows you to access memory directly - which, if done correctly, can result in significantly improved flexibility, performance, and resource use compared to other languages. Directly accessing memory is done using pointers.

Pointers are declared using an asterisk *, with the syntax:

type *name;

Here, type indicates the type of the variable the pointer points to - not the type of the actual value of the pointer itself, which (on a 64-bit system) is always going to be a 64-bit integer, since memory addresses are 64 bits long. * indicates that we are declaring a pointer, and name is the name of the pointer.

Once we declared the pointer, name will be the address it points to, while *name will be the variable stored at that address. This is demonstrated in the following program:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    int32_t x = 7;
    int32_t *p = &x;
    printf("p = %p, *p = %d\n", (void *)p, *p);
    *p = 9;
    printf("x = %d\n", x);
}

On my computer, the output is:

p = 000000000061fe14, *p = 7
x = 9

Let us go over the code line by line:

• In the first line, int32_t x = 7; declares and initializes a 32-bit integer variable x. This means that 32 bits of memory are automatically allocated (in the stack), and the number 7 is then stored at that point in memory.
• In the second line, int32_t *p = &x; declares a pointer p which will be used to point to a 32-bit integer. We initialize p to &x, which is the (64-bit) address where the value of x is stored in memory.
• In the third line, we print out the values of p and *p. You can see that p is a memory address, while *p is the value stored at that address, which is 7 since that is the value we assigned to x. Reading or writing the value at the address pointed to by a pointer via the syntax *p is called dereferencing a pointer.
• In the fourth line, *p = 9 changes the value at the address pointed to by p (not the value of p itself) to 9. Of course, since the value at that address is none other than the value of x, this means that the value of x will now be 9. This is another example of dereferencing a pointer.
• In the fifth line, we print the value of x to verify this.

Note that the declaration void * can be used to define (or type cast) a general pointer that doesn't refer to any specific data type; this is what we used in the programs above to print the addresses using the %p placeholder.

It is important to understand that even if we don't use pointers explicitly in our code, behind the scenes any variable is nothing but a pointer to a certain address in memory. This means that every time we write something like x = 7, what actually happens is *(&x) = 7, that is, the number 7 is stored in the address in memory pointed to by &x. In other words, once we assign p = &x, the dereference *p is essentially synonymous to x.

3.4.3 Constant pointers vs. pointers to constant variables ^

Consider the following program:

#include <stdio.h>

int main(void)
{
    double var = 0;
    double other_var = 0;
    const double con = 0;
    const double other_con = 0;

    double *var_ptr_to_var = &var;
    double *const con_ptr_to_var = &var;
    const double *var_ptr_to_con = &con;
    const double *const con_ptr_to_con = &con;

    var = 1; // Legal: var is not const, so can be changed.
    con = 1; // Illegal: con is const, so cannot be changed.

    var_ptr_to_var = &other_var; // Legal: pointer itself is not const, so can be changed.
    *var_ptr_to_var = 2;         // Legal: variable pointed to is not const, so can be changed.

    con_ptr_to_var = &other_var; // Illegal: pointer itself is const, so cannot be changed.
    *con_ptr_to_var = 2;         // Legal: variable pointed to is not const, so can be changed.

    var_ptr_to_con = &other_con; // Legal: pointer itself is not const, so can be changed.
    *var_ptr_to_con = 2;         // Illegal: variable pointed to is const, so cannot be changed.

    con_ptr_to_con = &other_con; // Illegal: pointer itself is const, so cannot be changed.
    *con_ptr_to_con = 2;         // Illegal: variable pointed to is const, so cannot be changed.
}

This program illustrates an important distinction between:

1. A constant vs. non-constant variable,
2. A constant vs. non-constant pointer.

• A non-constant variable has the type type. The variable can then be changed at will.
• A constant variable has the type const type. Once it is defined and initialized, it can never be changed. This has two benefits. First, it helps the human reader know that the variable is not supposed to be changed, and if they try to modify the program in a way that changes the variable (which can potentially cause bugs), it will not compile. Second, it helps the compiler know that the variable will not change, which could result in better optimizations.
• A non-constant pointer has the type type * or const type *. The pointer itself can then be changed at will, meaning that the memory address it points to can be changed to a different address. Whether the actual variable stored at that address can be changed depends on whether that variable is constant or not:
  • type * is a non-constant pointer to a non-constant variable of type type, so the variable can be changed as well.
  • const type * is a non-constant pointer to a constant variable of type const type, so the variable cannot be changed, even though the pointer itself can be changed.
• A constant pointer has the type type *const or const type *const. The pointer itself can never be changed, meaning that it forever points to the same memory address. Whether the actual variable stored at that address can be changed depends on whether that variable is constant or not:
  • type *const is a constant pointer to a non-constant variable of type type, so the variable can be changed even though the pointer cannot be changed.
  • const type *const is a constant pointer to a constant variable of type const type, so the variable cannot be changed either.

This can be confusing at first, but it becomes easier to understand once you realize that types in C must be read from right to left:

• type x means "a variable x of type type".
• const type x means "a variable x of type type which is constant".
• type *p means "a variable p which serves as a pointer (*) to a variable of type type".
• const type *p means "a variable p which serves as a pointer (*) to a variable of type type which is constant".
• type *const p means "a variable p which is constant and serves as a pointer (*) to a variable of type type".
• const type *const p means "a variable p which is constant and serves as a pointer (*) to a variable of type type which is constant".

3.4.4 Arrays and pointers ^

An array in C is actually nothing more than a pointer to the address in memory where the first element of the array is stored. Consider the following code:

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const int32_t a[] = {2, 3, 5};
    printf("First element:  address %p, value %d\n", (void *)a, *a);
    printf("Second element: address %p, value %d\n", (void *)(a + 1), *(a + 1));
    printf("Third element:  address %p, value %d\n", (void *)(a + 2), *(a + 2));
}

On my computer, the output is:

First element:  address 000000000061fe14, value 2
Second element: address 000000000061fe18, value 3
Third element:  address 000000000061fe1c, value 5

In the first line, we see that the value of the array a itself is, in fact, a pointer to the address where the first element is stored - on my computer, that address is 000000000061fe14. When we dereference that pointer using *a, we get the first element of the array, a[0].

In the next line, we add 1 to the address. Confusingly, this does not result in 000000000061fe15, as one might expect, but rather in 000000000061fe18. This is because each element of the array is a 32-bit integer, and 32 bits is 4 bytes; when we add 1 to the pointer, C instead adds the number of bytes required to advance to the next element in the array - in this case, 4 bytes. Similarly, when we add 2 to the pointer in the third line, C actually adds 8 to the address. This is called pointer arithmetic. From this we learn that a[n] in C is actually just a convenient shorthand for *(a + n)!

Also note that a is automatically a constant pointer, since if you try to assign any value to a itself, the program will not compile.

3.4.5 Functions and pointers ^

When a function gets its input arguments, they are stored in new local variables within that function's scope. These variables are, as we explained above, completely independent of any other variables in the program, and will be destroyed when the function finishes executing.

Consider the following (incorrect) program:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void swap(int64_t x, int64_t y)
{
    const int64_t temp = x;
    x = y;
    y = temp;
}

int main(void)
{
    int64_t a = 1, b = 2;
    printf("Before swap: a = %" PRId64 ", b = %" PRId64 "\n", a, b);
    swap(a, b);
    printf("After swap:  a = %" PRId64 ", b = %" PRId64 "\n", a, b);
}

If you run the program, you will see that a and b did not actually swap their values. This is because when we called swap(a, b), the values of a and b are stored in the new local variables x and y, which exist at a completely different place in memory. The function then swaps these two local variables with each other, but the original variables a and b remain untouched.

You might think that changing the names of a and b in main to x and y will solve the problem. However, as we stressed above (see variable scope and functions), any variable declared within a scope is a new variable local to that scope, regardless of whether any other variables with the same name already exist in other scopes. Therefore, this will not work.

To make this program work, we must give the function swap the pointers to a and b instead of their values. Here is how to do it:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void swap(int64_t *const x, int64_t *const y)
{
    const int64_t temp = *x;
    *x = *y;
    *y = temp;
}

int main(void)
{
    int64_t a = 1, b = 2;
    printf("Before swap: a = %" PRId64 ", b = %" PRId64 "\n", a, b);
    swap(&a, &b);
    printf("After swap:  a = %" PRId64 ", b = %" PRId64 "\n", a, b);
}

Now swap is declared with arguments that are pointers to integers, and accesses the values of these integers by dereferencing them, with the usual syntax *x and *y. When we call swap, we do not pass the values of a and b, but rather their addresses, using the syntax &a and &b. If you run this code, you will see that it works as intended:

Before swap: a = 1, b = 2
After swap:  a = 2, b = 1

Notice that the arguments of swap() have the type int64_t *const, which as we explained above means the pointer itself is constant, but not the variable it points to. If you instead write const int64_t *, you will get an error, because then the variable itself is const and thus cannot be changed. int64_t *const means "a const pointer to a variable of type int64_t", thus the pointer (i.e. the address of the variable) is constant, which is indeed the case here since we never change the actual pointer, but the variable itself (i.e. the value at that address) can be changed, which must be the case here since we want to change both variables.

3.4.6 Passing arrays to functions ^

Consider the following program:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_array(const char name[const], const uint64_t size, const uint64_t the_array[const])
{
    for (uint64_t i = 0; i < size; i++)
        printf("%s[%" PRIu64 "] = %2" PRIu64 " (%p)\n", name, i, the_array[i], (void *)&the_array[i]);
}

int main(void)
{
    const uint64_t primes[] = {2, 3, 5, 7, 11};
    print_array("primes", 5, primes);
}

The function print_array() takes three arguments:

1. An array of chars, or in other words, a string, which provides the name of the array to print.
2. The size of the array to print. This must be given, since the function can't tell the size of the array otherwise, so it won't know how many elements to print!
3. An array of uint64_t, which is the actual array to print.

(I'll explain what the [const] means in a moment.) The function prints the elements of the_array, as well as the memory address of each element. One possible output is:

primes[0] =  2 (000000893a3ffd40)
primes[1] =  3 (000000893a3ffd48)
primes[2] =  5 (000000893a3ffd50)
primes[3] =  7 (000000893a3ffd58)
primes[4] = 11 (000000893a3ffd60)

Notice that the values are stored in consecutive addresses, with 8 bytes (the size of an int64_t) between each address.

Above we said that an array in C is equivalent to a pointer to the memory address of the first element. Therefore, when we pass an array to a function, we are actually passing a pointer. In fact, we can replace the arrays in the arguments of print_array() with pointers to the appropriate data types, and the program will run exactly the same:

void print_array(const char *const name, const uint64_t size, const uint64_t *const the_array)

By comparing this with the previous function definition we can see what [const] means in the declaration of the arrays as function arguments. type a[] is the same as type *a, that is, a non-constant pointer, while type a[const] is the same as type *const a, that is, a constant pointer.

To illustrate, consider what happens if we add the following line to the function:

name = "different name";

Note that this does not modify the contents of the memory address pointed to by name! Instead, it modifies name itself to point to a different memory address.

With the definition const char name[const] (equivalent to const char *const name), the pointer name is constant, and the code will not compile. However, if you change the definition to const char name[] (equivalent to const char *name), the code will compile. Of course, whether you should define the pointer as const or not depends on whether you intend to change it or not.

So which syntax should you use for passing arrays to functions, array syntax type a[] or pointer syntax type *a? Personally I prefer the array syntax, since it gives more information to the reader. If you write type *a, then the reader may think a is just a pointer to a single variable. Writing type a[] makes it clear that a is expected to be an array of multiple elements.

3.4.7 Passing multi-dimensional arrays to functions ^

For multi-dimensional arrays, the situation is a bit more complicated. If the dimensions of the array are known at compilation time, then we can pass the array directly:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_array_2D(const char name[const], const uint64_t the_array[const 3][2])
{
    for (uint64_t i = 0; i < 3; i++)
        for (uint64_t j = 0; j < 2; j++)
            printf("%s[%" PRIu64 "][%" PRIu64 "] = %" PRIu64 " (%p)\n", name, i, j, the_array[i][j], (void *)&the_array[i][j]);
}

int main(void)
{
    const uint64_t matrix[3][2] = {{1, 2},
                                   {3, 4},
                                   {5, 6}};
    print_array_2D("matrix", matrix);
}

To pass the_array as a constant pointer, we added const inside the first bracket. If we intended to change the pointer for some reason, we would have passed it as the_array[3][2] instead.

One possible output is:

matrix[0][0] = 1 (000000986d9ff930)
matrix[0][1] = 2 (000000986d9ff938)
matrix[1][0] = 3 (000000986d9ff940)
matrix[1][1] = 4 (000000986d9ff948)
matrix[2][0] = 5 (000000986d9ff950)
matrix[2][1] = 6 (000000986d9ff958)

Notice, again, that the elements are stored consecutively in steps of 8 bytes. In fact, we see that this 2-dimensional array is just a 1-dimensional array in disguise! The element matrix[i][j] is actually the element matrix[2 * i + j]. This means that the compiler must know the number of columns in the array in order to use the matrix[i][j] notation; if the number of columns is unknown, then the compiler won't know how to convert matrix[i][j] to the correct 1-dimensional array element matrix[2 * i + j].

Since the compiler only needs to know the number of columns, but not the number of rows, we can also define print_array_2D without specifying the number of rows, as follows:

void print_array_2D(const char name[const], const uint64_t the_array[const][2])

However, if we don't specify any dimensions, the_array[][], or we only specify the number of rows, the_array[3][], then the program will not compile. This is not a desirable situation, since in general we want to have generic functions that can accept arrays of any size, as we had above for the 1-dimensional arrays.

To write a generic function, we can use the following syntax:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_array_2D(const char name[const], const uint64_t rows, const uint64_t cols, const uint64_t the_array[const rows][cols])
{
    for (uint64_t i = 0; i < rows; i++)
        for (uint64_t j = 0; j < cols; j++)
            printf("%s[%" PRIu64 "][%" PRIu64 "] = %" PRIu64 " (%p)\n", name, i, j, the_array[i][j], (void *)&the_array[i][j]);
}

int main(void)
{
    const uint64_t matrix[3][2] = {{1, 2},
                                   {3, 4},
                                   {5, 6}};
    print_array_2D("matrix", 3, 2, matrix);
}

Note that the arguments rows and cols must appear before the array itself in the argument list, since we use their values to define the dimensions of the array.

Another way to do this, which does not require passing rows and cols before the array itself, is to cast the array into a pointer to a 1-dimensional array, pass that pointer, and then use the_array[cols * i + j] explicitly. This will have the same result:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

void print_array_2D(const char *const name, const uint64_t *const the_array, const uint64_t rows, const uint64_t cols)
{
    for (uint64_t i = 0; i < rows; i++)
        for (uint64_t j = 0; j < cols; j++)
            printf("%s[%" PRIu64 "][%" PRIu64 "] = %" PRIu64 " (%p)\n", name, i, j, the_array[cols * i + j], (void *)&the_array[cols * i + j]);
}

int main(void)
{
    const uint64_t matrix[3][2] = {{1, 2},
                                   {3, 4},
                                   {5, 6}};
    print_array_2D("matrix", (uint64_t *)matrix, 3, 2);
}

(Here we also passed name as a pointer, just for consistency.)

3.4.8 Jagged arrays ^

The 2-dimensional array we used above had the shape of a matrix, with the same number of columns in each row. A jagged array is a 2-dimensional array in which each row can contain a different number of columns. More generally, a jagged n-dimensional array is an array of arrays (of arrays, etc...), with sub-arrays of different sizes.

A 2-dimensional jagged array is thus as an array of arrays, which means an array of pointers. A commonly-used type of jagged array is an array of strings; since a string is just an array of chars, this is indeed an array of arrays. Here is an example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

void print_jagged_array(const char name[const], const char *const the_array[const], const uint64_t rows)
{
    for (uint64_t i = 0; i < rows; i++)
        printf("%s[%" PRIu64 "] = %-5s (%p -> %p, size %zu)\n", name, i, the_array[i], (void *)&the_array[i], (void *)the_array[i], strlen(the_array[i]));
}

int main(void)
{
    const char *const jagged[] = {"One", "Two", "Three", "Four"};
    print_jagged_array("jagged", jagged, 4);
}

The output looks like this:

jagged[0] = One   (0000004fb21ffd10 -> 00007ff6a85bb076, size 3)
jagged[1] = Two   (0000004fb21ffd18 -> 00007ff6a85bb07a, size 3)
jagged[2] = Three (0000004fb21ffd20 -> 00007ff6a85bb07e, size 5)
jagged[3] = Four  (0000004fb21ffd28 -> 00007ff6a85bb084, size 4)

Each of the elements of jagged is a pointer to a string. For example, jagged[0], the first element, is located at 0000004fb21ffd10, and contains the pointer 00007ff6a85bb076. At the memory address 00007ff6a85bb076, we find the string "One", which has a size of 3. (We used the function strlen(), from the header file string.h, to find the length of the string; you can find a list of all the functions available in this header file in the C reference.)

Notice that the strings are also stored consecutively in memory, with the number of bytes used by each string being its size plus 1 (recall that in C, every string has a null character appended to it, which indicates where the string ends). For example, the string "One" uses the 4 bytes from 00007ff6a85bb076 to 00007ff6a85bb079, while the string "Three" uses the 6 bytes from 00007ff6a85bb07e to 00007ff6a85bb083.

We defined the function print_jagged_array() to take the array as a const char *const the_array[const], which means "a constant pointer to an array ([const]) named the_array which contains const pointers (*) to chars which are const".

We could also define the argument as const char *const *const the_array, which means "a variable named the_array which is a const pointer (*) to a const pointer (*) to a char which is const". (Again, types in C are best understood by reading from right to left!)

As with 1-dimensional arrays, the notation type *a[] is more informative than type **a, since it tells us a is supposed to be an array of pointers to type, and not just a pointer to a single pointer to type. Therefore, the notation type *a[] (with or without const) should be preferred.

Do we really need three separate consts in the function argument definition? Probably not... You will most likely never see anything like const char *const *const in "real life", but I used it here for pedagogical reasons, since it guarantees 100% that a beginner programmer cannot change any aspect of the input argument and potentially cause bugs. Experienced C programmers don't really need all this extra protection from human error, so you generally won't see three consts in one definition, but there's nothing wrong with taking precautions, except that it looks a bit cumbersome.

However, since I initially defined jagged as const char *const jagged[], which has two separate consts, if I just wrote char **the_array or equivalently char *the_array[] (without any consts), or even const char **the_array or equivalently const char *the_array[], or char *const *the_array or equivalently char *const the_array[] (with just one const), I would have received a warning from the compiler, since the type of the_array would not have matched the type of jagged. Remember: const is considered part of the type definition. The third const, however, is optional; that's the one that protects the pointer the_array itself, rather than defining the type of the array elements.

3.5 Dynamic memory allocation ^

3.5.1 Allocating memory in the heap

Above we said that when C allocates memory for a variable automatically, it does so in the stack. This can be done for any variable whose size is already known at compilation time - that is, we explicitly specified in the source code that we are, for example, allocating a 64-bit double, or an array of five 8-bit chars.

However, often we do not know in advance how much memory we need to allocate. A common example is reading data from a file, which can be of any size. In this case, we must employ dynamic memory allocation, manually allocating the required amount of memory at run time. In this case, the memory will not be allocated from the stack, but rather from the heap.

The stack is typically only a few MB in size. The heap is much larger - typically only limited by how much total memory the computer has. Therefore, for very large arrays, even if the size is already known at compile time, it is often best to allocate memory for them in the heap anyway - otherwise, we may run out of space in the stack, which results in a stack overflow error, and typically causes the program to crash.

To use dynamic memory allocation, we must include the header file stdlib.h, which stands for "standard library". The relevant functions are:

• malloc(total_size) allocates total_size bytes and returns a pointer to the memory address where the allocated block begins.
• calloc(number, element_size) allocates memory for an array with number elements of element_size bytes each, initializes all elements to zero, and returns a pointer to the memory address where the allocated block begins. Note that calloc(x, y) is equivalent to malloc(x * y) in terms of how much space is allocated.
• realloc(pointer, new_size) resizes the memory block allocated at pointer by malloc, calloc, or realloc to new_size. Returns a new pointer, which may point to an address different from the old pointer, especially if the block size has increased and needed to be moved to a location with more free space. If the new address is different, realloc automatically copies the contents of the memory block at the old address and frees it up.
• free(pointer) frees up (deallocates) the space allocated at the pointer by malloc, calloc, or realloc.

3.5.2 Proper use of malloc and calloc ^

To avoid bugs, you must make sure to use dynamic memory allocation properly, by following these guidelines:

1. Always check for allocation failure. If malloc, calloc, or realloc fail, they return a null pointer, which is given by the constant NULL. This should be checked whenever you use any of these functions, and if the result is NULL, the program should either do something else (e.g. try to allocate less memory), print out an error message, and/or quit.
2. Always deallocate memory using free when you are done with it. Failure to do so will cause a memory leak, and the computer may run out of memory. If the pointer to the allocated memory was defined within a scope (such as a function), then it must be freed before the scope ends, since otherwise the variable containing the pointer will no longer be accessible.
3. Never try to use memory before allocating it, or after freeing it. This will cause a segmentation fault and crash your program.

The following program demonstrates proper use of dynamic memory allocation with malloc and free:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const uint64_t size = 1000;
    int64_t *array = malloc(size * sizeof(*array));
    if (array == NULL)
    {
        printf("Failed to allocate memory!\n");
        return -1;
    }
    printf("Successfully allocated memory for an array of %zu elements of %zu bytes each at address %p using malloc.\n", size, sizeof(*array), (void *)array);
    printf("First element (uninitialized): %" PRId64 ".\n", array[0]);
    free(array);
}

Notice that if we fail to allocate the memory, we terminate the program by calling return -1. Recall that return is used to return a certain value from a function. But main() is a special function, which contains the main code of the program, so calling return in main() terminates the program itself. The integer value that is returned can then (optionally) be processed by some other program.

If no return value is specified, main() returns 0 by default, which means the program finished successfully. Any number other than 0 means there was an error, and here we are using the number -1 to indicate an error with memory allocation, although we could have used any other number. If we call this program as part of a script, then we can check the return value to figure out if the program ran successfully, or if not, what was the error.

If memory is being allocated inside a function, and we wish to terminate the program, then of course we cannot call return, since that will just terminate that particular function and not the whole program. In such a case we should use exit(n) where n is the number we want the program to return. For example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int64_t *allocate_memory(const uint64_t size)
{
    int64_t *array = malloc(size * sizeof(*array));
    if (array == NULL)
    {
        printf("Failed to allocate memory!\n");
        exit(-1);
    }
    printf("Successfully allocated memory for an array of %zu elements of %zu bytes each at address %p using malloc.\n", size, sizeof(*array), (void *)array);
    return array;
}

int main(void)
{
    int64_t *array = allocate_memory(1000);
    printf("First element (uninitialized): %" PRId64 ".\n", array[0]);
    free(array);
}

In the following program, we replaced malloc with calloc, so now the array is initialized to zero, which is often the preferred behavior:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const uint64_t size = 1000;
    int64_t *array = calloc(size, sizeof(*array));
    if (array == NULL)
    {
        printf("Failed to allocate memory!\n");
        return -1;
    }
    printf("Successfully allocated memory for an array of %zu elements of %zu bytes each at address %p using calloc.\n", size, sizeof(*array), (void *)array);
    printf("First element (initialized): %" PRId64 ".\n", array[0]);
    free(array);
}

3.5.3 Proper use of realloc ^

When using realloc, we need to be careful, because if it fails, the original pointer still remains valid and needs to be deallocated with free to prevent memory leaks. Therefore, we can't use the same variable to store both the old pointer and the new pointer. Here is how to use realloc properly:

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const uint64_t size1 = 1000, size2 = 100, size3 = 10000;
    int64_t *array1 = NULL, *array2 = NULL, *array3 = NULL;

    array1 = malloc(size1 * sizeof(*array1));
    if (array1 == NULL)
    {
        printf("Failed to allocate memory!\n");
        return -1;
    }
    printf("Successfully allocated memory for an array of %zu elements of %zu bytes each at address %p using malloc.\n", size1, sizeof(*array1), (void *)array1);

    array2 = realloc(array1, size2 * sizeof(*array2));
    if (array2 == NULL)
    {
        printf("Failed to reallocate memory!\n");
        free(array1);
        return -1;
    }
    printf("Successfully reallocated memory for an array of %zu elements of %zu bytes each at address %p using realloc.\n", size2, sizeof(*array2), (void *)array2);

    array3 = realloc(array2, size3 * sizeof(*array3));
    if (array3 == NULL)
    {
        printf("Failed to reallocate memory!\n");
        free(array2);
        return -1;
    }
    printf("Successfully reallocated memory for an array of %zu elements of %zu bytes each at address %p using realloc.\n", size3, sizeof(*array3), (void *)array3);

    free(array3);
}

Here, since we don't use all of the pointers array1, array2, and array3 immediately, we made sure to initialize them to NULL, which stands for a null pointer, that is, a pointer that doesn't point to anything. If we did not initialize these pointers, they would have pointed to some random addresses in memory. As always, all variables must be properly initialized, and that includes pointers!

On my computer, the output is:

Successfully allocated memory for an array of 1000 elements of 8 bytes each at address 0000000000163f90 using malloc.
Successfully reallocated memory for an array of 100 elements of 8 bytes each at address 0000000000163f90 using realloc.
Successfully reallocated memory for an array of 10000 elements of 8 bytes each at address 0000000000620080 using realloc.

Note how when we reallocated a smaller amount of memory, the same memory address was used, but to reallocate a larger amount of memory, the old location was not suitable anymore, so a new address was used instead.

In any of the above programs, you can change the size of the array to a very large number (e.g. 1e15) to see what happens when the program fails to allocate or reallocate memory.

3.6 Input and output ^

3.6.1 Input from the command line

So far, we have always declared main as int main(void), which means that it (and thus, the program as a whole) does not take any arguments. However, often - especially if your program does not have a graphical user interface - you want it to take arguments from the command line. In this case, you must declare main as follows:

int main(int argc, char *argv[])

• argc (argument count) is an integer which counts the number of arguments passed to the program, which are assumed to be separated by spaces.
• argv (argument vector) is an array of argc pointers to strings which contain the actual arguments passed.

Note that argc is usually at least 1, since it also counts the name of the executable file of the program itself, which is always stored in argv[0].

Here is an example:

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("argc = %d\n", argc);
    for (int i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);
}

If you just run this program by pressing F5 in the IDE, you will get an output similar to this:

argc = 1
argv[0] = main

Alternatively, you can compile it and then write in the command line:

main first second third "fourth fifth"

Then the output will be:

argc = 5
argv[0] = main
argv[1] = first
argv[2] = second
argv[3] = third
argv[4] = fourth fifth

Note that "fourth fifth" counts as one argument, since the words are enclosed in quotes.

3.6.2 Input from the terminal during run time ^

Alternatively (or additionally), you can ask the user for input from the terminal after the program runs. This is done using the function scanf, which accepts a format string similar to printf as its first arguments, and the addresses of the variables to store the input in the next arguments. As for printf, each format placeholder corresponds to one consecutive argument.

The output of scanf is an int containing the number of arguments received, or 0 in case the input does not match the format string. It is important to check the output, in case the user inputs the wrong value. In this case, the program can either terminate or ask again for the correct value.

Try this example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    int64_t x = 0, y = 0;
    int r = 0;

    printf("Enter x: ");
    r = scanf("%" PRId64, &x);
    if (r == 0)
    {
        printf("Incompatible value entered!");
        return -1;
    }

    printf("Enter y: ");
    r = scanf("%" PRId64, &y);
    if (r == 0)
    {
        printf("Incompatible value entered!");
        return -1;
    }

    printf("The sum of the numbers is %" PRId64 " + %" PRId64 " = %" PRId64 ".\n", x, y, x + y);
}

If you enter two integers, their sum is displayed. However, if you enter something else, such as a letters, the program will terminate.

3.6.3 Input from a file ^

To open a file, we use the function fopen, which is defined in stdio.h. The first argument is the name of the file, and the second argument specifies the file access mode:

• "r" opens the file for reading only. "r+" opens the file for both reading and writing.
  • If the file exists, reading begins from the start.
  • If the file does not exist, an error occurs.
• "w" opens the file for writing only. "w+" opens the file for both reading and writing.
  • If the file exists, its contents are destroyed.
  • If the file does not exist, it is created.
• "a" opens the file for appending. "a+" opens the file for both reading and appending.
  • If the file already exists, the output is appended to the existing contents.
  • If the file does not exist, it is created.

The output of fopen is a pointer to a variable of type FILE, which is used whenever we want to access the file. Once we're done with the file, we must close it with fclose, which takes the FILE pointer as its argument. To read a character from a file, we use fgetc. To read a formatted string from a file, we use fscanf, which functions like scanf but reads from a file rather than from the terminal.

The following program prints out its own source file (assuming that the file is called print_self.c):

#include <stdio.h>

int main(void)
{
    const char filename[] = "print_self.c";
    int chr = 0;
    FILE *file_ptr = NULL;

    file_ptr = fopen(filename, "r");
    if (file_ptr == NULL)
    {
        perror("Cannot open file");
        return -1;
    }

    while ((chr = fgetc(file_ptr)) != EOF)
    {
        putchar(chr);
    }

    if (ferror(file_ptr))
        printf("\nEncountered an error before reaching the end of file %s.", filename);
    else if (feof(file_ptr))
        printf("\nSuccessfully read file %s.", filename);

    fclose(file_ptr);
}

After calling fopen, we store the generated FILE pointer in the variable file_ptr. This variable is used to access the file throughout the program.

If file_ptr == NULL, this indicates that an error has occurred. We use perror to inform the user of this error. perror prints out the given string, followed by ": ", followed by an automatically-generated description of the error code stored in the system variable errno. For example, if you change filename[] to a file that does not exist, you will see the error message Cannot open file: No such file or directory.

We use a while loop with the condition (chr = fgetc(file_ptr)) != EOF to read the file. fgetc reads one character from file_ptr, and we store the output in the variable chr. Notice that chr is an int, not a char; this is because it needs to be able to store not only characters, but also the special value EOF (typically set to -1) which indicates that either an error has occurred or the end of the file has been reached.

At each step of the loop, we compare the result (i.e. the value of chr) with EOF. As long as EOF has not been reached, we print out the character that was read from the file using the function putchar, which simply prints one character to the terminal.

Once EOF has been reached, we use the function ferror, which checks file_ptr for errors. If this function returns true, then we tell the user about the error. Otherwise, we use the function feof to confirm that we indeed reached the end of the file, and if it returns true, we notify the user of the successful operation.

Finally, we close the file using fclose. This is very important, as it releases the file so that other programs can use it, frees up memory, and in the case of opening a file for writing, ensures that all the data we wrote to the file is saved on the disk.

The function fscanf works similarly to scanf, except that it takes a file pointer as its first argument. We can use it to read data from files in a particular format. For example, perhaps we would like to read integers stored in CSV (comma-separated values) format. Create a file named data.csv and enter the following into it:

1,2,3
4,5,6
7,8,9

We can read this file with the following program:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const char filename[] = "data.csv";
    int num_read = 0;
    FILE *file_ptr = NULL;
    int64_t x = 0, y = 0, z = 0;
    uint64_t line = 1;

    file_ptr = fopen(filename, "r");
    if (file_ptr == NULL)
    {
        perror("Cannot open file");
        return -1;
    }

    do
    {
        num_read = fscanf(file_ptr, "%" PRId64 ",%" PRId64 ",%" PRId64, &x, &y, &z);
        if (num_read == 3)
            printf("Read values: (%" PRId64 ", %" PRId64 ", %" PRId64 ") on line %" PRIu64 ". Sum is %" PRId64 ".\n", x, y, z, line, x + y + z);
        else
        {
            printf("Error: Encountered invalid data on line %" PRIu64 "!\n", line);
            break;
        }
        line++;
    } while (!feof(file_ptr));

    if (feof(file_ptr))
        printf("Successfully read the file %s (%" PRIu64 " lines total).", filename, line - 1);

    fclose(file_ptr);
}

To read the three integers we simply tell fscanf that the format of the input is integer - comma - integer - comma - integer. fscanf will return the total number of integers read, so if it's 3 we know the line was formatted correctly; if not, then either we've reached the end of the file, or there was invalid data.

The output is:

Read values: (1, 2, 3) on line 1. Sum is  6.
Read values: (4, 5, 6) on line 2. Sum is 15.
Read values: (7, 8, 9) on line 3. Sum is 24.
Successfully read the file data.csv (3 lines total).

But if I change data.csv so that one of the lines contains invalid data, for example:

1,2,3
aaa,5,6
7,8,9

Then the output will be:

Read values: (1, 2, 3) on line 1. Sum is 6.
Error: Encountered invalid data on line 2!

By the way, notice that in this program I defined num_read, the variable that stores the return value of fscanf, as int. You may be wondering: doesn't that make the program not portable? Why did I not use, for example, int32_t instead?

The reason is that the C standard explicitly defines fscanf as a function that returns int. So I cannot define num_read as an integer with a specific number of bits, such as int32_t, since the number of bits stored in that variable may be different on different systems, depending on how int is defined on each system. This means that, perhaps counter-intuitively, the only portable way to use fscanf is to define its return variable as int.

3.6.4 Output to a file ^

If we open a file for writing, we can use fputc to write one character or fprintf to write a formatted string. The syntax of fprintf is exactly the same as that of printf, except that the first argument is a FILE pointer. Here is an example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const char filename[] = "squares.txt";
    const uint64_t num_squares = 100;
    FILE *file_ptr = NULL;

    file_ptr = fopen(filename, "w");
    if (file_ptr == NULL)
    {
        perror("Cannot open file");
        return -1;
    }

    for (uint64_t i = 1; i <= num_squares; i++)
    {
        if (fprintf(file_ptr, "%" PRIu64 "\n", i * i) < 0)
        {
            perror("Error occurred");
            fclose(file_ptr);
            return -1;
        }
    }

    printf("Squares of all numbers from 1 to %" PRIu64 " written successfully to file %s.\n", num_squares, filename);
    fclose(file_ptr);
}

There is much more to be said about input, output, and other file operations, but we will not cover it here. Instead, please see the C reference.

3.7 Structs and typedefs ^

3.7.1 Structs

As we have seen, arrays can be used to group together different values. However, all values in an array must have the same type. Structures, declared with the keyword struct, allow us to conveniently store any desired combination of different data types in one variable. The syntax is as follows:

struct name
{
    type1 member1;
    type2 member2;
    // etc...
};

Here name is the name of the structure, and member1, member2, and so on are the members, which have data types type1, type2, etc. respectively.

One example of where we might want to use a struct is for database entries. For example, we can store a student's ID, name, and email address in one struct data type as follows:

struct student
{
    uint64_t id;
    char *name;
    char *email;
};

Here, we have defined a new data type called struct student. Note that since we do not know in advance the size of the strings that will contain the name and email address, we don't define them as a fixed-size array (e.g. char name[20]) but rather as simply a pointer to a string, which will be stored elsewhere in memory. (This is not necessarily the fastest method, since the program will then have to navigate to the other memory addresses to access the strings, but it is the most convenient.)

Once we define a struct, we have to declare an actual variable which will have the new data type. This is done as usual with the syntax type var_name, so in this case, struct struct_name var_name. The members are then accessed using a dot: var_name.member1, var_name.member2, and so on. In the example of a student entry, struct student s declares s as a variable of type struct student. The fields id, name, and email and then accessed using s.id, s.name, and s.email.

To initialize a struct, we use the following syntax:

struct name var_name = {.member1 = value1, .member2 = value2, ...};

Note that struct should usually be defined outside the main function, so that it is a global definition that can be accessed by other functions. For example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

struct student
{
    uint64_t id;
    char *name;
    char *email;
};

int main(void)
{
    const struct student s = {.id = 654873, .name = "Alice", .email = "alice@universityname.ca"};
    printf("| Student ID: %" PRIu64 " | Name: %s | Email: %s |\n", s.id, s.name, s.email);
}

3.7.2 Arrays of structs ^

Often, we will want to declare an array of structs. For example, for an array of 3 students, we can use struct student s[3]. Then s[i] is the ith element of the array (starting from zero, as usual). To access the individual values, we use s[i].id, s[i].name, and s[i].email. Here is an example:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

struct student
{
    uint64_t id;
    char *name;
    char *email;
};

int main(void)
{
    const uint64_t num_students = 3;
    struct student s[num_students];

    s[0].id = 654873;
    s[0].name = "Alice";
    s[0].email = "alice@universityname.ca";

    s[1].id = 23564;
    s[1].name = "Bob";
    s[1].email = "bob@universityname.ca";

    s[2].id = 7634126;
    s[2].name = "Charlie";
    s[2].email = "charlie@universityname.ca";

    for (uint64_t i = 0; i < num_students; i++)
        printf("| Student ID: %7" PRIu64 " | Name: %-7s | Email: %-25s |\n", s[i].id, s[i].name, s[i].email);
}

Note that we used width specifiers in the %s format placeholders to make the output look nice. The minus sign, just as for numbers, specifies that the string should align to the left. The output will be:

| Student ID:  654873 | Name: Alice   | Email: alice@universityname.ca   |
| Student ID:   23564 | Name: Bob     | Email: bob@universityname.ca     |
| Student ID: 7634126 | Name: Charlie | Email: charlie@universityname.ca |

3.7.3 Structures as pointers ^

We can streamline the previous program by defining a function that will store values inside a struct:

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

struct student
{
    uint64_t id;
    char *name;
    char *email;
};

void store_student(struct student *const s, const uint64_t id, char *const name, char *const email)
{
    s->id = id;
    s->name = name;
    s->email = email;
}

int main(void)
{
    const uint64_t num_students = 3;
    struct student s[num_students];

    store_student(&s[0], 654873, "Alice", "alice@universityname.ca");
    store_student(&s[1], 23564, "Bob", "bob@universityname.ca");
    store_student(&s[2], 7634126, "Charlie", "charlie@universityname.ca");

    for (uint64_t i = 0; i < num_students; i++)
        printf("| Student ID: %7" PRIu64 " | Name: %-7s | Email: %-25s |\n", s[i].id, s[i].name, s[i].email);
}

Since we want the function to modify the contents of the array, we pass the addresses of the array elements using the & modifier. This means that, inside the function store_student, the variable s is a pointer. In this case, we use the syntax -> instead of . to access the values inside the struct. Note that s->id is equivalent to (*s).id.

3.7.4 Typedef ^

A typedef is used to define a shorthand for a particular type. It has the syntax:

typedef original_type new_name;

We have encountered typedefs before. For example, uint64_t is actually a typedef for unsigned long long:

typedef unsigned long long uint64_t;

typedefs are often used to define shorter names for structs. For example, we can write

typedef struct
{
    uint64_t id;
    char *name;
    char *email;
} student;

This will allow us to write just student instead of struct student when we declare a variable of this type.

3.8 Further reading ^

Unfortunately, in this course we only have limited time. I chose to talk in detail here only about the most important things you need to know in order to start programming in C. For more information, a good starting point is the C reference, which lists all the keywords, types, functions, and other important aspects of C and its standard library.

Stack Overflow is another very good website with trustworthy content in the form of questions and answers, where you can also ask your own questions if needed - but before posting a new question, make sure it has not been asked already!

I find that most online C tutorials are not of very good quality, and sometimes even just plain wrong. For this reason, I recommend not to use them, or if you do, to take them with a grain of salt. For learning C seriously, there is no replacement for a proper textbook.

I will not recommend any particular C textbooks here, since I don't think you'll need them - the intention of this course is for you to eventually program in C++, which is a much more useful and modern language than C. I will recommend some great C++ textbooks below.

4 Introduction to C++ ^

Now that we have a fairly good mastery of C, we can start learning C++. C is, for the most part, a subset of C++. Most C programs will compile using a C++ compiler, perhaps with a few changes, but the opposite is not true. We will see that many aspects of C remain the same in C++, but some things are done a bit differently, and many new features and concepts are added - most importantly, object-oriented programming.

C++ can do everything C can do, and more. The main benefit of C compared to C++ is that it is lower-level, supported on more types of systems, and simpler. Therefore, it is great for embedded systems, operating systems, device drivers, and so on. However, for most applications, including scientific computing, it is generally better to use C++. You will soon see why.

Note that both C and C++ are evolving languages. Some of the things I will list here as new in C++ compared to C are also new in C++ compared to older revisions of C++. However, I will always assume here that you are using a compiler which supports the latest revision, C++20, which is what you should have if you installed the latest version of GCC as I instructed in the beginning of the course. (However, note that as of 2022, some C++20 features are still not supported by GCC, or supported only experimentally; more details can be found here.)

You should create a new Visual Studio Code workspace for your C++ programs, separate from the workspace you used so far for your C programs, since it will have slightly different .json configuration files. The steps to configure Visual Studio Code to run C++ programs and generate the .json files are exactly the same as in creating and configuring your first program above, except for two changes:

• First, whenever the compiler gcc is mentioned in the instructions above, replace it with g++.
• Second, replace the argument -std=c17 in tasks.json with -std=c++20. This will instruct the compiler to comply with the C++20 standard. (The warning flags should be the same, and -g should be replaced with -ggdb3 as we instructed above).

Note: In c_cpp_properties.json, the value of intelliSenseMode will still contain gcc-x64, and in tasks.json, the value of the problemMatcher will still be $gcc. That's normal.

4.1 Some new features of C++

4.1.1 The "Hello, World!" program

Copy and paste the following program to VS Code:

#include <iostream>

int main()
{
    std::cout << "Hello, World!\n";
}

Let us consider several new things in this program:

• #include <iostream> is basically the C++ equivalent of #include <stdio.h>. However, in C++ the relevant header file is iostream, and we don't add .h to the file name; the actual file's name is, in fact, just iostream without any extension. iostream stands for input/output stream.
  • To include the a C header file of the form NNN.h, use #include <cNNN>. For example, to include math.h, we use #include <cmath>.
• int main() is the same old main function from C. However, while the C standard requires that void appears in the parentheses if the program does not take command-line arguments, the C++ standard instead requires that nothing appears in the parentheses. Both options, void or no void, work in both languages, but here we will adhere to the standard. To get input from the command line, the exact same syntax as in C should be used: int main(int argc, char *argv[]).
• std::cout, which is declared in iostream, allows us to print output to the terminal. Although printf still works in C++, std::cout is preferred whenever we don't need the output to be formatted in a particular way.
  • std indicates that we are accessing the standard library namespace. A namespace is simply a space where we can declare names so that they do not conflict with names declared in other namespaces. For example, I can (although this is not a very good idea...) define another object named cout in another namespace, and it will not conflict with cout in the std namespace.
  • :: indicates that we are accessing an object in the namespace.
  • cout is an object in the namespace std, which represents the standard output stream. Usually, the standard output stream is the terminal. The name cout stands for character output. Note that cout is not a function, it is an object; it doesn't have any input or output, like printf does.
• The operator << ("put to") indicates that the string "Hello, World!\n" should be written into the standard output stream std::cout. Since the stream represents the terminal, writing this string to the stream means that "Hello, World!\n" will be printed to the terminal.

4.1.2 Using namespaces ^

The object cout is in the std namespace, so we had to write std:: in front of it in order to access it. This can get tedious when an object is used frequently. However, we can eliminate the need to write std:: by invoking the following statement:

using namespace std;

This will instruct the compiler that we are "using" the namespace std, which essentially means we merge that namespace with the namespace of our program. Now we can simply write cout:

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello, World!\n";
}

We will generally invoke using namespace std throughout the course, since it makes C++ code more compact and readable. The only downside is that we cannot define objects in our program which have the same names as objects in the C++ standard library (such as cout), but that would be a bad idea anyway.

4.1.3 Reserved keywords ^

The 2011 version of the C++ standard, also called C++11, defined the following 83 reserved keywords: alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case, catch, char, char16_t, char32_t, class, compl, const, constexpr, const_cast, continue, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or, or_eq, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while, xor, and xor_eq.

These include 33 of the 34 C keywords (restrict is the only one missing), plus 50 new keywords. However, many of the new keywords in fact already existed in C. For example, the operators and, or, and not are just more readable alternatives for the operators &&, ||, and ! respectively. Similarly, bool, true, and false can be used in C if we include the header file stdbool.h.

The next two versions, C++14 and C++17, changed the meaning of some keywords but did not add any new ones. However, C++20 added 8 new keywords: char8_t, concept, consteval, constinit, co_await, co_return, co_yield, and requires.

4.1.4 Function overloading ^

In C++, we can define different functions with the same name, which accept different numbers and/or types of arguments. This is called function overloading. Here is an example:

#include <iostream>
using namespace std;

void print_type(const int32_t x)
{
    cout << "I got a 32-bit integer: " << x << '\n';
}

void print_type(const int64_t x)
{
    cout << "I got a 64-bit integer: " << x << '\n';
}

void print_type(const double x)
{
    cout << "I got a double: " << x << '\n';
}

void print_type(const char x)
{
    cout << "I got a character: " << x << '\n';
}

int main()
{
    print_type(1);             // Prints "I got a 32-bit integer: 1"
    print_type(1000000000000); // Prints "I got a 64-bit integer: 1000000000000"
    print_type(1.0);           // Prints "I got a double: 1"
    print_type('1');           // Prints "I got a character: 1"
}

By default, C++ interprets any literal integer (i.e. an integer written explicitly in the source code) as the smallest data type among int, long, and long long that can fit that integer. 1 fits into int, which on most 64-bit platforms means int32_t. However, 1000000000000 is too big to be represented using 32 bits, and thus it only fits into a long long, which on most 64-bit platforms means int64_t. You can remind yourself about integer data types here and read more about how integer literals are interpreted in C++ here.

Therefore, when we invoke print_type(1), the function print_type(int32_t) is called, but when we invoke print_type(1000000000000), the function print_type(int64_t) is called. Similarly, print_type(1.0) calls print_type(double) and print_type('1') calls print_type(char x).

Notice also that we used multiple <<'s to print out multiple strings and numbers by putting them into cout in order. This is (arguably) more convenient than using printf and having to specify the exact type of each value we are printing using the appropriate format placeholder. With cout, the type is automatically detected.

Function overloading is especially useful in the case of mathematical functions. Recall that in C, unless we used tgmath.h, we had different function names for different types of arguments, e.g. sqrt for double, sqrtf for float, and sqrtl for long double. In C++, there is just one sqrt function (defined in the header <cmath>) that can accept any floating-point or integer type.

4.1.5 Constant expressions ^

In C, we learned that the const keyword allows us to define a variable that cannot be changed later; if we try to change it, we will get an error from the compiler. In C++, an additional keyword constexpr (constant expression) is provided.

While const can be used even if the value of the constant is known only at run time (i.e. when the user actually runs the program), constexpr can only be used if the value is known at compile time (i.e. when we compile the code). Generally, constexpr is preferred to const since it provides better performance.

For example, consider the following code: (In C++, you do not need to include stdint.h manually to use fixed-width integer types, it is automatically included when you include iostream.)

#include <iostream>
using namespace std;

int64_t add_one(const int64_t n)
{
    return n + 1;
}

int main()
{
    const int64_t x = add_one(1);
    cout << x;
}

The value returned by add_one() is not known at run time, but that's okay, because when we define x as const, all that really means is that we prevent it from being changed later; the initial value can be decided at any time. However, if we replace const with constexpr, the code will not compile, since the value of x is not known until we evaluate the function add_one() at run time.

If we also add the keyword constexpr to the definition of add_one(), the code will work:

#include <iostream>
using namespace std;

constexpr int64_t add_one(const int64_t n)
{
    return n + 1;
}

int main()
{
    constexpr int64_t x = add_one(1);
    cout << x;
}

In this case, the function add_one() will be evaluated in advance at compilation time and the value of x will be recorded, so that we do not need to evaluate the function again at run time. Obviously, this wouldn't work if the function depended on something that will only be known at runtime, such as input from a file; in that case the program would not compile.

4.1.6 The cin object ^

Just as in C++ we usually prefer to use cout instead of printf to print output to the terminal, we also usually prefer cin to scanf to get input from the terminal. Here is an example:

#include <iostream>
using namespace std;

int main()
{
    int64_t n = 0;
    cout << "Enter a number: ";
    cin >> n;
    cout << "The square of the number is " << n * n << ".\n";
}

Here, >> is the operator "get from", the opposite of <<, the operator "put to". Instead of putting output into cout, we get input from cin.

4.1.7 Namespaces revisited ^

Just as the std namespace is defined in <iostream>, we can define our own namespaces. This is used whenever we want to guarantee that none of the names we used in our code (variables, functions, etc.) will clash with the names used in other peoples' code, and vice versa. Here is an example:

#include <iostream>

namespace other
{
    constexpr int64_t cout = 7;
}

int main()
{
    // Prints "Value of other::cout is 7."
    std::cout << "Value of other::cout is " << other::cout << ".\n";
}

There are two couts in this code:

• The usual std::cout, the standard output stream, defined in the namespace std.
• Our custom other::cout, which is not a stream but an integer, defined in the custom namespace other.

You can see that both couts can be used in conjunction, even in the same statement, as long as the prefix indicating the namespace (std:: or other::) is included. Of course, if we write just cout without an explicit namespace for either of them, the code will not compile - since that name is only defined within the context of these namespaces.

So far, we have added the statement using namespace std to every program, which imports all of the names in the namespace std. However, it is actually possible to only import individual names with using. For example, let us import only cin but not cout or anything else:

#include <iostream>

using std::cin;

int main()
{
    int64_t n = 0;
    std::cout << "Enter n: ";
    cin >> n;
    std::cout << "The square of n is " << n * n << ".\n";
}

You can see that cin works without the std:: prefix here, but if you try to replace std::cout with cout, you will get an error.

4.1.8 Default function arguments ^

We can specify a default value for a function's argument, which will be used if that argument is omitted. For example:

#include <cmath>
#include <iostream>
using namespace std;

double root(const double num, const int32_t rt = 2)
{
    return pow(num, 1.0 / rt);
}

int main()
{
    cout << "Square root of 5: " << root(5) << '\n';
    cout << "Cubic  root of 5: " << root(5, 3) << '\n';
}

Here, the function root() takes the root of the first argument with respect to the second argument, but if the second argument is omitted, the default is a square root. (We used the function pow() from the header <cmath> to calculate the roots; pow(base, exp) returns base to the power exp.)

Note that arguments with default values cannot be followed by arguments without default values. In other words, the arguments with default values must be the last arguments of the function. So f(double x, double y = 0) is okay, and so is f(double x = 0, double y = 0), but f(double x = 0, double y) is invalid.

4.2 Pointers and references ^

4.2.1 References

Consider a variable declared as type x, where type is any data type and x is the variable's name. We have seen that this variable is simply a value of the corresponding data type, stored in a particular address in memory. This address can be determined by &x.

We can define a pointer p that will store the address of a variable using type *p = &x. When we dereference the pointer using the syntax *p, we can read or modify the value of x - that is, the value stored at the address &x - without using x itself.

Unfortunately, pointers are one of the most confusing and prone-to-errors concepts in C. To remedy that, C++ introduces the new concept of references. A reference is similar to a const pointer, in that it points to an address in memory, but once it is initialized to the address of a particular variable, this address can never be changed.

Furthermore, as you will see, unlike pointers, references do not need to be dereferenced - whenever the reference is used, it is automatically replaced with the variable it refers to. This essentially means that a reference is just another name, or alias, for an already existing variable. We never have to deal with the actual memory address directly.

To define a reference, we use the following syntax:

type &ref = var;

Where ref is the name of the reference, var is the name of the variable it will point to, and type is the data type. This is illustrated in the following example:

#include <iostream>
using namespace std;

int main()
{
    int64_t var = 0;     // Declare an integer var and initialize it to 0
    int64_t &ref = var;  // Declare a reference ref and initialize it to be an alias of var
    int64_t *ptr = &var; // Declare a pointer ptr and initialize it to the address of var
    cout << "Initialization: "
         << "var = " << var << ", ptr = " << ptr << ", *ptr = " << *ptr << ", ref = " << ref << ".\n";
    var++;
    cout << "var++:          "
         << "var = " << var << ", ptr = " << ptr << ", *ptr = " << *ptr << ", ref = " << ref << ".\n";
    ref++;
    cout << "ref++:          "
         << "var = " << var << ", ptr = " << ptr << ", *ptr = " << *ptr << ", ref = " << ref << ".\n";
    (*ptr)++;
    cout << "(*ptr)++:       "
         << "var = " << var << ", ptr = " << ptr << ", *ptr = " << *ptr << ", ref = " << ref << ".\n";
    ptr++; // Warning: This increases the address ptr points to, NOT the value at the address!
    cout << "ptr++:          "
         << "var = " << var << ", ptr = " << ptr << ", *ptr = " << *ptr << ", ref = " << ref << ".\n";
}

On my computer, the output is:

Initialization: var = 0, ptr = 0x1f91fff648, *ptr = 0, ref = 0.
var++:          var = 1, ptr = 0x1f91fff648, *ptr = 1, ref = 1.
ref++:          var = 2, ptr = 0x1f91fff648, *ptr = 2, ref = 2.
(*ptr)++:       var = 3, ptr = 0x1f91fff648, *ptr = 3, ref = 3.
ptr++:          var = 3, ptr = 0x1f91fff650, *ptr = 135593457232, ref = 3.

We see that adding 1 to var using var++ is the same as adding 1 to ref using ref++; they are essentially two names for the same variable. Dereferencing ptr and adding 1 to the value at the address it points to using (*ptr)++ is also equivalent. You can think of a reference as essentially a fixed pointer for which the * is automatically added whenever the reference is used.

However, if we do not dereference ptr, and instead add 1 to the value of ptr itself using ptr++, we change the address the pointer points to, and the value at the new address is garbage - whatever happens to be in memory at that address at the time. (On your computer, the address that ptr points to will be different, and the garbage value in the last line will also be different.)

One way to avoid making mistakes like this is to declare the pointer as const, as we discussed above and as we have indeed done whenever possible in our code examples so far:

int64_t *const ptr = &var;

Now the code will not compile, since we are trying to change ptr itself (which is const) rather than var (which is not const).

References in C++ have many uses, and in particular, they simplify some uses that would have required pointers in C. We will see some of these uses below.

4.2.2 Functions and references ^

Above, in functions and pointers, we considered the following program (slightly rewritten here for C++):

#include <iostream>
using namespace std;

void swap(int64_t *const x, int64_t *const y)
{
    const int64_t temp = *x;
    *x = *y;
    *y = temp;
}

int main()
{
    int64_t a = 1, b = 2;
    cout << "Before swap: a = " << a << ", b = " << b << '\n';
    swap(&a, &b);
    cout << "After swap: a = " << a << ", b = " << b << '\n';
}

By passing pointers to the variables to be swapped instead of the values of the variables, we can modify the variables from within the function, even though they are in a different scope. In C++, this code can be rewritten in a much cleaner way, without all the *s, using references instead of pointers:

#include <iostream>
using namespace std;

void swap(int64_t &x, int64_t &y)
{
    const int64_t temp = x;
    x = y;
    y = temp;
}

int main()
{
    int64_t a = 1, b = 2;
    cout << "Before swap: a = " << a << ", b = " << b << '\n';
    swap(a, b);
    cout << "After swap: a = " << a << ", b = " << b << '\n';
}

Notice that all we needed to do was add & in the argument list of the function's definition; every instance of a, b, x, and y is simply the variable's name without any *s, resulting in more compact and easy to read code. Furthermore, when calling swap() we simply pass a and b themselves, rather than their addresses &a and &b, as we had to do in the case of pointers.

Since references cannot be changed to refer to a different variable, we do not need to make them const; in other words, a reference works similarly to a const pointer.

4.2.3 Improving performance with (constant) references ^

As we discussed above, functions have their own scope, so arguments passed to a function are treated as new variables within that new scope, independent of variables in any other scope. This means that when a variable is passed to a function, its value has to be copied to a new address in memory, so that if it is modified, it will not affect the original variable.

In the example of the swap function above, we explicitly wanted to modify the variables passed as arguments, instead of creating new variables in the function's scope. In order to do that, we passed the arguments by reference, which ensured that the function could directly access the passed variables instead of their copies.

However, even if we don't need the function to be able to modify the variables that were passed as arguments, it is still often preferable to pass arguments by reference, since this can provide us with a performance boost. The reason is that copying the value of the variable to a different address in memory can be a time-consuming task - especially for large objects such as structs (or classes, which we will discuss later).

On the other hand, if we are not careful, passing an argument by reference may cause unexpected behavior. Consider this example:

#include <iostream>
using namespace std;

void print_plus_one(int64_t x)
{
    x++;
    cout << "print_plus_one: " << x << '\n';
}

int main()
{
    int64_t a = 1;
    print_plus_one(a);             // Prints "print_plus_one: 2"
    cout << "main: " << a << '\n'; // Prints "main: 1"
}

The function print_plus_one accepts an integer, increases it by one, and prints out the result. Notice that the variable a in the scope of the main function was not modified by print_plus_one, since it created a new variable x within its own scope. The value of a was copied to a new address in memory for this purpose.

Perhaps we would like to improve the performance of our program by passing the argument as reference. (Obviously, in this case it would make no difference, but if we're passing 1 GB of data to the function, the performance improvement would be very significant!) Naively, we would just add & to the argument of the function:

#include <iostream>
using namespace std;

void print_plus_one(int64_t &x)
{
    x++;
    cout << "print_plus_one: " << x << '\n';
}

int main()
{
    int64_t a = 1;
    print_plus_one(a);             // Prints "print_plus_one: 2"
    cout << "main: " << a << '\n'; // Prints "main: 2"
}

Notice that now the variable a in the scope of the main function has also changed, since x in the scope of print_plus_one is not an independent variable, it is merely an alias for a and refers to the same address in memory. This was not the intended behavior; we just wanted print_plus_one to print the value plus one, but not change the variable that was passed to it.

This error could have been prevented if we declared the argument as a const reference. If you define void print_plus_one(const int64_t &x) and try to run the following program, it will not compile, and we will get the error increment of read-only reference 'x' from the compiler.

The correct way to write this code using references is:

#include <iostream>
using namespace std;

void print_plus_one(const int64_t &x)
{
    cout << "print_plus_one: " << x + 1 << '\n';
}

int main()
{
    int64_t a = 1;
    print_plus_one(a);             // Prints "print_plus_one: 2"
    cout << "main: " << a << '\n'; // Prints "main: 1"
}

Now we enjoy increased performance (at least in principle, if the program was more complicated) by using a reference to x instead of copying it, but we also do not modify x before we print it, which would inadvertently modify a as well.

Finally, notice that if the argument of print_plus_one is defined as a non-constant int64_t &x, then the function cannot take literals as arguments - that is, we cannot call, for example, print_plus_one(5). The reason is that 5 is a literal, not a variable, so there is no way to create an alias for it. However, if the argument of print_plus_one is defined as const int64_t &x, then we are free to call the function with either a variable or a literal.

In conclusion, a good programming practice is to follow these rules:

• Functions should only accept variables as arguments if they must make copies of the variables, and there is no simple way to use references instead.
• Otherwise, functions should always accept references.
  • If the function is meant to change the value of the variable, as in swap, then the references should not be const.
  • Otherwise, the references should always be const to prevent accidental modification, allow passing literals as arguments, and increase readability.

4.2.4 Range-based for loops and references ^

for loops are almost always used to iterate on a specific range or specific values. C++ introduces a new type of for loop which greatly simplifies this. Simply write

for (type i : a)

Where a is the array of values you want to iterate on, and type is the type of the values. You can also write explicitly

for (type i : {value1, value2, ...})

Where value1, value2, etc. are the values to be iterated on. Here is an example:

#include <iostream>
using namespace std;

int main()
{
    constexpr uint64_t primes[] = {2, 3, 5, 7, 11};

    for (const uint64_t p : primes)
        cout << p << '\n';
}

This will simply print out the elements of the array primes. It is important to understand that here p is not a variable that gets incremented in each step, as with a normal for loop; in each step, p will be the actual value of each array element.

Here we declared p as const since we do not change p itself inside the loop. p is a local variable inside the loop, hence a local copy, so we can change it if we want, without affecting the actual array elements; as with all other variables, if we do not plan to change it, then we should define it as const both to avoid accidental modification and to make the code more readable.

In some cases, we do want to change p, while not changing the array elements themselves. This is okay, since p is just a local copy of each element, so we can change it without changing the array; we just need to remove the const qualifier. For example:

#include <iostream>
using namespace std;

int main()
{
    constexpr uint64_t primes[] = {2, 3, 5, 7, 11};

    for (uint64_t p : primes)
    {
        p++;
        cout << p << '\n';
    }

    for (const uint64_t p : primes)
        cout << p << '\n';
}

The first loop will increase the value of each prime and then print it. However, this will not affect the array primes itself, since p is a copy.

If the array we're looping on contains a lot of data, then we should avoid copying each element, since that can take a significant amount of time. As with passing arguments to functions, we can avoid copying the elements of the array by using references:

#include <iostream>
using namespace std;

int main()
{
    constexpr uint64_t primes[] = {2, 3, 5, 7, 11};

    for (const uint64_t &p : primes)
        cout << p << '\n';
}

Now p is not a copy, but rather a reference to each array element. This may considerably improve performance in many cases.

However, now we should be careful; we can remove the const qualifier to allow modifying p, but doing so will now also modify the array (as long as the array itself is not const or constexpr, of course). For example, in the following code we permanently increase each element of the array by 1:

#include <iostream>
using namespace std;

int main()
{
    uint64_t primes[] = {2, 3, 5, 7, 11};

    for (uint64_t &p : primes)
    {
        p++;
        cout << p << '\n';
    }

    for (const uint64_t &p : primes)
        cout << p << '\n';
}

The first loop iterates over the references &p, which are used as aliases for the array elements. So in the first iteration &p will be an alias for primes[0], in the second iteration it will be an alias for primes[1], and so on. When we write p++, this increases the array elements themselves, as if we were writing primes[0]++ and so on. The second loop iterates over the elements again and prints them - you will notice that their values have indeed increased by 1, which did not happen in the previous example, where we increased only the copies.

In other words, the loop

for (uint64_t &p : primes)
    p++;

Is equivalent to

for (uint64_t i = 0; i < 5; i++)
    primes[i]++;

Again, as with passing references to functions, if we don't intend to change the array itself then we should define the references as const. Here it's even more important than in the first example, as we may be accidentally changing the array itself and not just a copy.

The same rules we discussed in the case of passing arguments to functions as references also apply here:

• You should only loop over copies if you must make copies of the array elements, and there is no simple way to use references instead.
• Otherwise, you should only loop over references.
  • If the loop is meant to change the values of the array elements, then the references should not be const.
  • Otherwise, the references should always be const to prevent accidental modification and to increase readability.

4.2.5 Null pointers ^

In C, we saw that the null pointer (e.g. as returned by fopen) was given by NULL and had the value 0. In C++, to prevent confusion between the integer 0 and the null pointer, the latter is instead given by nullptr, which in fact is a pointer and not an integer. Note that there is no "null reference".

As an (artificial) example of the difference between NULL and nullptr, consider the following code:

#include <iostream>
using namespace std;

void print_type(const uint64_t x)
{
    cout << "I got a 64-bit integer: " << x << '\n';
}

void print_type(const void *const x)
{
    cout << "I got a pointer: " << x << '\n';
}

int main()
{
    print_type(NULL);
}

This code won't compile, and will produce the error call of overloaded 'analyze(NULL)' is ambiguous. This is because the compiler doesn't know if NULL is meant to be an integer or a pointer. However, if we replace NULL with nullptr, the code will compile and will output I got a pointer: 0.

As in C, the null pointer is useful when we declare a pointer variable, but only assign a value to it later. In this case, the pointer will have a garbage value until we assign its value, which may lead to bugs. To avoid this, we can simply initialize it to the null pointer, for example:

double *p = nullptr;

4.3 Vectors and strings ^

4.3.1 Vectors

C++ introduces vectors, which are a much improved version of C arrays. Vectors are a type of container; we will discuss other C++ containers later.

The main benefit of C++ vectors is that they manage memory automatically. You can create an array of any size, and later add or remove elements to it, and it will automatically allocate and deallocate memory as needed. Memory is also freed up automatically when the vector is no longer being used. This means you never have to worry about managing memory manually, which is prone to bugs and leaks. Furthermore, vectors can be accessed in a safe way which prevents accessing elements out of the range of the array.

You pay for this convenience with slightly reduced performance. The penalty to performance is most significant in situations where the vector needs to resize itself, which may mean having to reallocate memory and copy everything to the new memory address. However, if you declare the vector in advance with a size big enough to store everything you plan to put in it, you can avoid the need to resize it later. Merely accessing the elements of a vector is essentially just as fast as accessing the elements of an array.

To use vectors, we must #include <vector>. Then, we define vectors using the new type std::vector, or just vector if we are using namespace std. The syntax is:

vector<type> name(size);

This will create a vector with size elements of type type. If size is not specified, i.e. the parentheses are omitted, it will be zero by default. The elements will be automatically initialized, so we don't need to worry about initialization. Here is an example:

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int64_t> vec(5);

    for (int64_t &i : vec)
        cout << i << '\n';
}

This will output 5 zeros, since the vector has been automatically initialized to zeros. We can also initialize it manually with the usual array syntax, e.g.:

vector<uint64_t> primes = {2, 3, 5, 7, 11};

In this case we did not need to specify the size of the vector; it was automatically inferred from the initialization list. The standard array notation [] works for vectors too, starting from zero as usual, so for example, primes[0] is 2 and primes[4] is 11.

vector contains many useful member functions. These are functions that are accessed using the syntax vec.function(arguments) where vec is the name of the vector, function is the name of the functions, and arguments are optional arguments to be passed to the function.

Here are some examples of commonly-used member functions:

• size() returns the number of elements in the vector.
• push_back(value) adds an element with specified value to the end of the vector.
• assign({value1, value2, ...}) re-initializes the vector with the specified elements.
• pop_back() removes the last element in the vector.
• clear() re-initializes the vector to size zero.

These functions are demonstrated in the following program:

#include <iostream>
#include <vector>
using namespace std;

void print_vector(const vector<uint64_t> &v)
{
    cout << "Size: " << v.size() << ", Elements: ";
    for (const uint64_t &i : v)
        cout << i << ' ';
    cout << '\n';
}

int main()
{
    vector<uint64_t> vec;
    print_vector(vec); // Size: 0, Elements:
    vec.push_back(5);
    print_vector(vec); // Size: 1, Elements: 5
    vec.push_back(7);
    print_vector(vec); // Size: 2, Elements: 5 7
    vec.assign({1, 2, 3});
    print_vector(vec); // Size: 3, Elements: 1 2 3
    vec.pop_back();
    print_vector(vec); // Size: 2, Elements: 1 2
    vec.clear();
    print_vector(vec); // Size: 0, Elements:
}

Notice that we passed the vector to print_vector by (constant) reference in order to avoid copying the whole vector every time we call the function. For this reason, we also had to define the reference i inside the for loop as const uint64_t &i - otherwise, if it was not a constant reference, we could have modified the elements of the vector by modifying i, which is forbidden since we passed the vector as a constant reference. (If you write for (uint64_t &i : v) instead, you will get an error from the compiler.)

Another very important member function is at(n), which returns the element at position n, starting from 0 as usual. vec.at(n) is equivalent to vec[n] as long as n is between 0 and vec.size() - 1. However, if n is out of range, vec[n] will simply return whatever garbage value is in the memory address being referred to, just as was the case for C arrays. That's not good!

On the other hand, vec.at(n) will cause an error if n is out of range. (More precisely, it will throw an exception; we will learn what that means later.) Naturally, this means that there is a bit of overhead to at compared to [], since at must spend some extra time checking if the requested element is in range or not. Therefore, [] may be preferred if you need the maximum performance possible, but only if you are absolutely sure that the element you are requesting will never be out of range.

Here is an example of using [] vs. at:

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int64_t> vec = {1, 2, 3};
    // Accessing out-of-range element permitted: will print garbage
    cout << vec[5] << '\n';
    // Accessing out-of-range element prohibited: will terminate the program
    cout << vec.at(5) << '\n';
}

For a full list of the available member functions for vector, please see the C++ reference or Microsoft's C++ reference.

4.3.2 Strings ^

In C, strings were null-terminated arrays with elements of type char. C++ introduces a new way to define strings. To use vectors, we must #include <string>. Then, we define vectors using the new type std::string, or just string if we are using namespace std. For example:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string message = "This is a string.";
    cout << message << '\n';
}

You can concatenate strings by using the + operator:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string message1 = "This is ";
    string message2 = "a string.";
    string message = message1 + message2;
    cout << message << '\n'; // Prints "This is a string."
}

Note that this was not possible in C, since you can't "add" arrays. (Instead, you would have had to #include <string.h> and use the function strcat.) However, it is still possible to use the array operator [] to access individual characters in the string, starting from 0 as usual:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string message = "ABCDE";
    cout << message[0] << '\n'; // Prints "A"
    message[1] = 'b';
    cout << message << '\n'; // Prints "AbCDE"
}

You can also compare two strings using the == and != operators:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string password = "1234";
    string input;
    cout << "Enter password: ";
    cin >> input;
    if (input == password)
        cout << "Password is correct.\n";
    else
        cout << "Password is incorrect.\n";
}

Again, in C this was not possible (you would have had to use the function strcmp). Notice that we did not initialize input; one of the great benefits of using string is that strings are automatically initialized to an empty string if no initialization string is provided.

string has many useful member functions, including:

• size() returns the length of the string.
• insert(position, string) inserts string at position.
• replace(position, length, string) replaces length characters at position with string.
• find(string) looks for an instance of string and returns its position. Returns npos if the string was not found.
• substr(position, length) extracts a substring of length characters starting at position.

The following program illustrates these functions:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string message = "I like apples.\n";
    cout << message; // I like apples.
    // Length of string: 15 characters.
    cout << "Length of string: " << message.size() << " characters.\n";
    message.insert(7, "red ");
    cout << message; // I like red apples.
    message.replace(7, 3, "green");
    cout << message; // I like green apples.
    // "apple" found at position 13.
    cout << "\"apple\" found at position " << message.find("apple") << ".\n";
    // 4 characters starting at position 2: "like".
    cout << "4 characters starting at position 2: \"" << message.substr(2, 4) << "\".\n";
}

For a full list of the available member functions for string, please see the C++ reference or Microsoft's C++ reference.

5 Classes and object-oriented programming ^

5.1 Classes

5.1.1 Introduction to classes

Classes are the most important and significant new feature offered by C++. They provide an additional level of abstraction beyond the abstractions we have discussed so far such as variables, functions, and structures. Essentially, a class is a user-defined type. Just like we can create, for example, a variable of type int, we can also create a variable - or, more generally, an object - of a user-defined type defined using a class.

A class can have two types of members: data, in the form of variables, and code, in the form of functions. The concept of an object with internal variables is already familiar to us from our discussion of structs in C above, and the concept of member functions is familiar to us from our discussion of vectors and strings - which are, in fact, classes defined in the C++ standard library (more precisely, vector is a template, but I will explain what that means later).

Classes have two separate parts: interface and implementation. The interface is the part that users can access directly. The implementation is only accessible internally, to the class itself, and not to the user. As an analogy, in a calculator, the interface is the buttons (input) and the display (output), while the implementation is the code that performs the actual calculations.

We define a class using the following syntax:

class name
{
public:
// Public members
private:
// Private members
};

The public members correspond to the interface (they are accessible to the user) while the private members correspond to the implementation (they are inaccessible to the user). Note that members are private by default, but one should always include the labels public: and private: explicitly to enhance readability and prevent confusion.

Most people who read the code for your class would only be interested in knowing the syntax for the public functions that they can access via the interface, and not the private functions and data that are part of the internal implementation of the class. Therefore, public members should always appear first.

5.1.2 Classes and structures ^

A struct in C++ is essentially equivalent to a class. The only difference is that in a struct, members are public by default, while in a class, members are private by default. We access members of a struct or a class, both data and functions, using a dot as in C structs - a notation that we are already familiar with from the classes string and vector. Consider a struct defining a point:

#include <iostream>
using namespace std;

struct point
{
    double x, y;
};

int main()
{
    point p;
    // Error: uninitialized, prints two arbitrary numbers
    cout << '(' << p.x << ", " << p.y << ")\n";
}

The declaration point p creates a new object of the structure point. We access the members of this object using p.x and p.y, as usual. Note that we did not need to write struct point or use a typedef, as in C; we only need to write point to declare an object.

Of course, the problem here is that the user did not initialize the point, so the members have garbage values. To avoid such errors, we should add some default values to the definition of the struct:

#include <iostream>
using namespace std;

struct point
{
    double x = 0, y = 0;
};

int main()
{
    point p;
    cout << '(' << p.x << ", " << p.y << ")\n"; // Prints (0, 0)
}

If the user does want to initialize this point, they can do so using array syntax:

point p = {1, 2};
cout << '(' << p.x << ", " << p.y << ")\n"; // Prints (1, 2)

This syntax works because point is a passive data structure (sometimes referred to as "plain old data" or POD), that is, it only holds specific data types in a specific order and does nothing else (just like a struct in C). For more complicated objects, we will need to use constructors.

5.1.3 Member functions ^

Let us now start using class instead of struct, even though they are essentially the same thing; class is what you should normally use in C++, because it is preferable to hide members from the users by making them private. We rewrite the program as follows:

#include <iostream>
using namespace std;

class point
{
public:
    double x = 0, y = 0;
};

int main()
{
    point p;
    cout << '(' << p.x << ", " << p.y << ")\n"; // Prints (0, 0)
}

It would be nice if point could automatically print its coordinates to the terminal, so we won't have to write a clunky cout statement every time. This will also allow us to easily change the format of all outputs at once by changing how point implements the output. So let's add a public member function print, which prints the point as a tuple:

#include <iostream>
using namespace std;

class point
{
public:
    void print()
    {
        cout << '(' << x << ", " << y << ")\n";
    }

    double x = 0, y = 0;
};

int main()
{
    point p1 = {1, 2};
    point p2 = {3, 4};
    p1.print(); // Prints (1, 2)
    p2.print(); // Prints (3, 4)
}

Notice that we now declared two different points, named p1 and p2, and used the member function print to easily print each of the points. Also, notice that inside point itself, the members are simply referred to by their names. x is just x when we're inside point, and it will always refer to the particular x for the object for which the code of print is being executed.

Finally, let us also add a member function to scale both coordinates of the point by the same factor:

#include <iostream>
using namespace std;

class point
{
public:
    void print()
    {
        cout << '(' << x << ", " << y << ")\n";
    }

    void scale(const double &s)
    {
        x *= s;
        y *= s;
    }

    double x = 0, y = 0;
};

int main()
{
    point p = {1, 2};
    p.scale(3);
    p.print(); // Prints (3, 6)
}

We could similarly add member functions to rotate the point around the origin, calculate its distance from the origin, and so on.

5.1.4 Constructors ^

Constructors are special member functions used to properly initialize a newly-created object of the given class. The constructors generate the object based on some input, and they are free to do whatever processing and error-checking is needed in order to properly create an object from the input. Constructors are defined as follows:

• They are member functions with the same name as the class.
• They must be public, since the user needs to access them as part of the class interface in order to initialize objects.
• They have no return value.
• Their arguments are the input used to initialize the object.

Often, there are multiple overloaded versions of constructors that take different kinds of inputs. In the case of point, let us define three different constructors:

#include <iostream>
using namespace std;

class point
{
public:
    // Default constructor: coordinates are initialized to their default values as specified below
    point() {}
    // Constructor with one argument: assumes the argument is the value of both x and y
    point(const double &_xy) : x(_xy), y(_xy) {}
    // Constructor with two arguments
    point(const double &_x, const double &_y) : x(_x), y(_y) {}

    // Prints the coordinates of the point as a tuple
    void print()
    {
        cout << '(' << x << ", " << y << ")\n";
    }

    // Scales both coordinates by the specified amount
    void scale(const double &s)
    {
        x *= s;
        y *= s;
    }

    // The values of the coordinates
    double x = 0, y = 0;
};

int main()
{
    point p1;       // Uses default constructor
    p1.print();     // (0, 0)
    point p2(5);    // Uses constructor with one argument
    p2.print();     // (5, 5)
    point p3(6, 7); // Uses constructor with two arguments
    p3.print();     // (6, 7)
}

Note that the constructors in this case are all empty code blocks {}; the actual assignment of values happens through the initializer list, which is of the form member(argument), ..., assigning the arguments of the function to specific member variables. The constructor

point(const double &_x, const double &_y) : x(_x), y(_y) {}

Does the same thing as

point(const double &_x, const double &_y)
{
    x = _x;
    y = _y;
}

However, it is more compact. More importantly, the values are assigned before the body of the function is executed. Here this doesn't really matter, since the function body is empty anyway, but in other cases, it would ensure that the members have been properly initialized, so that the function body cannot possibly make use of uninitialized variables, which would - as usual - cause unexpected behavior.

5.1.5 Exceptions: try-throw-catch ^

Consider a function invert() which returns the multiplicative inverse of a number:

#include <iostream>
using namespace std;

double invert(const double &x)
{
    return 1.0 / x;
}

int main()
{
    cout << invert(10); // Prints "0.1"
}

What happens if we call invert(0)? Nothing too catastrophic, actually; it simply returns inf, that is, the special floating-point value representing infinity. So we could use the function isinf(), defined in the header <cmath>, to check if the result is infinity, and issue an error message in that case:

#include <cmath>
#include <iostream>
using namespace std;

double invert(const double &x)
{
    return 1.0 / x;
}

int main()
{
    const double result = invert(0);
    if (isinf(result))
        cout << "Error: Division by zero!";
    else
        cout << result;
}

This works, but if we wanted to invert several different numbers, we would have to check for this error every single time. Things become even more complicated if, for example, we have a function that calls another function that calls another function that calls invert()... In that case, we would have to check for division by zero all over again in each function, and then propagate that error all the way back to main(). This would quickly make the code very cumbersome.

C++ includes a much smarter and more convenient way to handle errors in the form of exceptions. We enclose a block of code that may generate an error in brackets following the keyword try. The code may then generate an exception using the keyword throw. If an exception is thrown, execution of the try block is terminated, and control transfers to a catch block. If there is no catch block, or if we don't catch the specific exception that was thrown, the program itself terminates.

Here's how to implement the division by zero check using exceptions:

#include <iostream>
#include <stdexcept>
using namespace std;

double invert(const double &x)
{
    if (x == 0)
        throw invalid_argument("Division by zero!");
    return 1.0 / x;
}

int main()
{
    try
    {
        cout << invert(10) << '\n';
        cout << invert(0) << '\n';
        cout << invert(20) << '\n';
    }
    catch (const invalid_argument &e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

The output of this program is:

0.1
Error: Division by zero!

In main(), we try to print out the inverse of some numbers. The first line calls invert(10), which returns 0.1, and prints the result. The second line calls invert(0). Looking at the invert() function itself, we see that if x is zero, the function uses the throw keyword to throw an exception. Once the exception is thrown, the execution of the try block terminates, so the third line, which calls invert(20), never gets executed.

In this case, we chose to throw the exception invalid_argument, which is a ready-made exception class defined in the header file <stdexcept>, intended to be used when an invalid argument (in this case 0) is passed to a function. Note that <stdexcept> is included automatically when we include <iostream>, so we don't need to include separately, but we included it anyway for readability purposes. When we write invalid_argument("Division by zero!"), we are constructing an invalid_argument object and giving the constructor the string "Division by zero!" which is the error message to be (optionally) passed to the user.

For a full list of pre-defined exception classes, please see the C++ reference. We can also make our own custom exceptions by deriving them from the exception class, which is indeed how invalid_argument and other ready-made exceptions are defined; we will explain what "deriving" means later.

In principle, we could throw any user-defined class, or even a fundamental data type such as int. However, that is not recommended, since the user will expect to catch an exception object like invalid_argument. If we throw other types of objects, the user will need to consult the documentation to know which ones to catch. Furthermore, using exception objects makes the code more readable since the reader can immediately know what each exception means.

In the catch statement, we caught the exception as a constant reference. Although in principle exceptions can be caught by value, that's not recommended, as it would mean having to make a local copy of the object; you will get a warning from the compiler if you try to do that. As with any other object, it is best to deal with a reference to the object and not a copy of the object, as that is faster and takes up less space in memory.

The invalid_argument class, as well as any other class derived from the exception class, only has one member function: what(), which simply returns the string passed to the constructor. Therefore, when we call e.what(), we get the string "Division by zero!", which we then print out as a user-friendly description of the error.

5.1.6 Invariants, private members, and encapsulation ^

Let us now define a class named triangle, which describes a triangle with sides of lengths a, b, and c. Unlike the coordinates of a point, which can be any two real numbers, the sides of a triangle must have non-negative length and must satisfy the triangle inequality.

Since we can't just trust the user to give us valid input, our constructor must validate the input by checking that the numbers can define a triangle. Furthermore, the values of the sides must be private, so that once the sides have been validated, the user won't be able to change them to invalid values.

To facilitate error checking, if invalid input is given, the constructor will throw an invalid_argument exception. We also provide a print() member function to print out the value of the sides. Here is how it works:

#include <iostream>
#include <stdexcept>
using namespace std;

class triangle
{
public:
    triangle(const double &_a, const double &_b, const double &_c)
        : a(_a), b(_b), c(_c)
    {
        if ((a < 0) or (b < 0) or (c < 0))
            throw invalid_argument("Sides cannot be negative!");
        if ((a > b + c) or (b > c + a) or (c > a + b))
            throw invalid_argument("Triangle inequality must be satisfied!");
    }

    void print()
    {
        cout << '(' << a << ", " << b << ", " << c << ")\n";
    }

private:
    double a = 0, b = 0, c = 0;
};

int main()
{
    try
    {
        triangle t1(4, 2, 5);
        t1.print();
        triangle t2(6, -7, 8);
        t2.print();
        triangle t3(2, 2, 5);
        t3.print();
    }
    catch (const invalid_argument &e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

The first triangle t1 gets initialized successfully. However, the second triangle t2 has a negative side length, so it does not get initialized, and instead we get an exception. Execution of the try block will then terminate. If you remove or fix t2, then t3 will also generate an exception, since it does not satisfy the triangle inequality.

We defined a public constructor, but the side lengths a, b, and c are private so they are inaccessible to the user. Indeed, if you try to write, for example,

t1.a = 1;

you will get errors saying that a is private and inaccessible. This is very important, since it ensures that the implementation of triangle can always assume it is dealing with a valid triangle, with non-negative side lengths which satisfy the triangle inequality.

The condition for what constitutes valid data for a class is called an invariant. This condition is assumed to be satisfied always - it does not vary, which is why it's called "invariant". A well-written class must ensure that the invariant is always satisfied by:

• Writing proper constructors which enforce the invariant,
• Making all data private and thus inaccessible to the user,
• Ensuring that any member function which changes the data does so in a way which preserves the invariant.

If this is done correctly - and it must, if you intend to write a good C++ program - it greatly simplifies the implementation, improves performance, and eliminates bugs. The reason is that verifying the invariant every time a member function is called could significantly decrease performance, while not verifying it would lead to bugs whenever the data is invalid. If your code guarantees that the invariant is always satisfied, you don't have to verify it every time a member function is called.

Therefore, either we don't allow the user to change the sides at all once the triangle object has been initialized, or we provide a member function change_sides() which will only change the sides if the input is valid. In that case, the constructor can simply call that same member function, so we don't have to write the validation code twice. Here is how it works:

#include <iostream>
#include <stdexcept>
using namespace std;

class triangle
{
public:
    triangle(const double &_a, const double &_b, const double &_c)
    {
        change_sides(_a, _b, _c);
    }

    void change_sides(const double &_a, const double &_b, const double &_c)
    {
        if ((_a < 0) or (_b < 0) or (_c < 0))
            throw invalid_argument("Sides cannot be negative!");
        if ((_a > _b + _c) or (_b > _c + _a) or (_c > _a + _b))
            throw invalid_argument("Triangle inequality must be satisfied!");
        a = _a;
        b = _b;
        c = _c;
    }

    void print()
    {
        cout << '(' << a << ", " << b << ", " << c << ")\n";
    }

private:
    double a = 0, b = 0, c = 0;
};

int main()
{
    triangle t(4, 2, 5);
    t.print();
    try
    {
        t.change_sides(4, 3, 5);
        t.change_sides(1, 3, 5);
    }
    catch (const invalid_argument &e)
    {
        cout << "Error: " << e.what() << '\n';
    }
    t.print();
}

The output is:

(4, 2, 5)
Error: Triangle inequality must be satisfied!
(4, 3, 5)

Therefore, t.change_sides(4, 3, 5) succeeded, and the sides were changed, but t.change_sides(1, 3, 5) failed, so the try block terminated and the sides were not allowed to change. When we print out the sides after the try-catch blocks, we see that indeed, the sides were changed to (4, 3, 5) but not to (1, 3, 5).

We have defined two classes so far: point and triangle. These classes illustrate encapsulation, one of the fundamental principles of object-oriented programming. This principle has two components:

1. Data should be bundled together with the functions that process and manipulate that data. In other words, an object - that is, an instance of a class - should be a self-sufficient package. For example, a point object not only contains the data on the coordinates of the point, but also the member functions print and scale which operate with that data.
2. Data should not be directly accessible, instead only accessible via member functions that ensure its validity. In other words, there should be a "filter" that does not let any invalid data be stored in the object. For example, a triangle object ensures that it always holds data for a valid triangle, which would be impossible if the user was able to manually modify each side of the triangle instead of going through the constructor.

5.1.7 Constructors for the triangle class ^

There's no such thing as an "uninitialized" triangle object. In its current form, a triangle cannot be declared without initializing all three sides explicitly. If we try to declare

triangle t;

we will get an error saying no default constructor exists for class "triangle". The compiler doesn't know how to construct this object, since the only constructor we have expects three arguments, while here we have zero arguments. Trying to initialize it as triangle t{}; will also fail, this time with the error no instance of constructor "triangle::triangle" matches the argument list.

If we want to allow initializing an "empty" or degenerate triangle object, with all its sides set to the default value of zero, we must create a default constructor (i.e. a constructor which does not take any arguments) manually, as we did for the point class.

Let us, then, define a default constructor for the triangle class; and while we're at it, let us also define constructors for each possible number of arguments. The class will now have four constructors:

• The constructor with no arguments will create a degenerate triangle with all sides equal to zero.
• The constructor with one argument will create an equilateral triangle with all sides of the same length.
• The constructor with two arguments will create a right triangle with the third side given by the Pythagorean theorem (c² = a² + b²), using the function sqrt() from the header <cmath>.
• The constructor with three arguments will be the one we defined previously.

All constructors will use change_sides() to validate the input. The final result is:

#include <cmath>
#include <iostream>
#include <stdexcept>
using namespace std;

class triangle
{
public:
    // Constructor with no arguments: define a degenerate triangle with all sides equal to zero.
    triangle()
    {
        change_sides(0, 0, 0);
    }

    // Constructor with one argument: define an equilateral triangle with all sides equal to a.
    triangle(const double &_a)
    {
        change_sides(_a, _a, _a);
    }

    // Constructor with two arguments: define a right triangle with sides a and b. The third side will be determined by the Pythagorean theorem.
    triangle(const double &_a, const double &_b)
    {
        change_sides(_a, _b, sqrt(_a * _a + _b * _b));
    }

    // Constructor with three arguments: define an arbitrary triangle with sides a, b, c.
    triangle(const double &_a, const double &_b, const double &_c)
    {
        change_sides(_a, _b, _c);
    }

    // Change (or initialize) the sides of the triangle, after making sure the values are valid.
    void change_sides(const double &_a, const double &_b, const double &_c)
    {
        if ((_a < 0) or (_b < 0) or (_c < 0))
            throw invalid_argument("Sides cannot be negative!");
        if ((_a > _b + _c) or (_b > _c + _a) or (_c > _a + _b))
            throw invalid_argument("Triangle inequality must be satisfied!");
        a = _a;
        b = _b;
        c = _c;
    }

    // Print the sides of the triangle.
    void print()
    {
        cout << '(' << a << ", " << b << ", " << c << ")\n";
    }

private:
    // The lengths of the sides.
    double a = 0, b = 0, c = 0;
};

int main()
{
    try
    {
        triangle degenerate_triangle;
        degenerate_triangle.print();
        triangle equilateral_triangle(1);
        equilateral_triangle.print();
        triangle right_triangle(3, 4);
        right_triangle.print();
        triangle arbitrary_triangle(5, 6, 7);
        arbitrary_triangle.print();
    }
    catch (const invalid_argument &e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

We also added comments to explain how to class works, since it has become quite large. The output is:

(0, 0, 0)
(1, 1, 1)
(3, 4, 5)
(5, 6, 7)

5.1.8 Separating member functions from the class ^

To make the code (arguably) more readable, we can move the code for the member functions outside of the class, and only include their prototype declarations inside it. When we define a member outside of the class, we must add triangle:: before the name of the member, so that the compiler knows which class it belongs to:

#include <cmath>
#include <iostream>
#include <stdexcept>
using namespace std;

class triangle
{
public:
    // Constructor with no arguments: define a degenerate triangle with all its sides equal to zero.
    triangle();
    // Constructor with one argument: define an equilateral triangle with all sides equal to a.
    triangle(const double &_a);
    // Constructor with two arguments: define a right triangle with sides a and b, and the third side given by the Pythagorean theorem.
    triangle(const double &_a, const double &_b);
    // Constructor with three arguments: define an arbitrary triangle with sides a, b, c.
    triangle(const double &_a, const double &_b, const double &_c);
    // Change (or initialize) the sides of the triangle, after making sure the values are valid.
    void change_sides(const double &_a, const double &_b, const double &_c);
    // Print the sides of the triangle.
    void print();

private:
    // The lengths of the sides.
    double a = 0, b = 0, c = 0;
};

triangle::triangle()
{
    change_sides(0, 0, 0);
}

triangle::triangle(const double &_a)
{
    change_sides(_a, _a, _a);
}

triangle::triangle(const double &_a, const double &_b)
{
    change_sides(_a, _b, sqrt(_a * _a + _b * _b));
}

triangle::triangle(const double &_a, const double &_b, const double &_c)
{
    change_sides(_a, _b, _c);
}

void triangle::change_sides(const double &_a, const double &_b, const double &_c)
{
    if ((_a < 0) or (_b < 0) or (_c < 0))
        throw invalid_argument("Sides cannot be negative!");
    if ((_a > _b + _c) or (_b > _c + _a) or (_c > _a + _b))
        throw invalid_argument("Triangle inequality must be satisfied!");
    a = _a;
    b = _b;
    c = _c;
}

void triangle::print()
{
    cout << '(' << a << ", " << b << ", " << c << ")\n";
}

Now, anyone who reads our code will immediately see that there are four constructors and one member function, and the comments will explain what they do. This is the external interface of the class, the part that the user is going to make use of. The details of the internal implementation of the class, that is, the code itself, are kept separate, as they are generally not of any interest to the user.

5.1.9 Inline functions ^

Note that it is not just a matter of taste and/or readability whether to include the member function definitions inside or outside the class. Functions that are included inside a class are automatically interpreted as inline functions, which means that the compiler will attempt to generate a copy of the function "inline" in the machine code, rather than a call to a function located elsewhere.

Inlining can provide a performance boost, as calling a function takes time. On the other hand, it means that the code itself will be larger and occupy more memory, and that might actually hurt performance. Generally, functions should only be inlined if they consist of no more than one or two lines, but this is not a rule that applies to every situation.

If we want to move a function outside of the class, but still have it be an inline function, we can add the keyword inline. This is added only to the definition of the function, i.e. the part that contains the code, and not to the prototype declaration of the function inside the class itself, which is only meant to convey information about the interface. Whether the function is inline or not is part of the implementation, not the interface, so it is not of interest to the user. For example:

class triangle
{
public:
    triangle();
    // ...
}

inline triangle::triangle()
{
    change_sides(0, 0, 0);
}

However, note that the inline keyword is only a suggestion; most compilers will inline short functions anyway as part of the optimization process. We will talk more about inline functions and performance optimization later in the course.

5.1.10 Splitting a project into separate files ^

The code for the triangle class has become quite long. It may be easier to handle if we split it into separate files. The standard way to do this in C++ is to split the class into two files: a header file (.hpp extension) containing the prototype declarations, and a source file (.cpp extension) containing the function definitions. We also split the class from the main program. Thus we split the project into three files:

• main.cpp will contain the main() function and possibly some other functions that are unrelated to the triangle class.
• triangle.cpp will contain the triangle class and the definitions of all its member functions.
• triangle.hpp will contain the prototype declarations of the triangle class and all its member functions and variables, but not any actual code.

What happens then isn't simply that the code for both files is compiled together. Instead, main.cpp and triangle.cpp will be compiled separately, and then linked together; we will discuss this in more detail later. main.cpp must know how the functions in triangle.cpp were declared in order to use them, e.g. what kind of arguments they get and what type of values they return. This is achieved by including triangle.hpp, since it contains the required information.

You may ask why the compiler can't just look inside triangle.cpp and figure out how the functions work on its own. Theoretically that may be possible, but the idea is that in C++, different .cpp files must be able to compile independently of each other. So they compiler doesn't know or care about triangle.cpp when you compile main.cpp. In fact, sometimes you may not even have access to the source code for triangle, only the pre-compiled machine code. As long as you have the appropriate header file, that will not be a problem.

Here are the contents of the three files.

main.cpp:

#include "triangle.hpp"

int main()
{
    triangle t(1, 2, 3);
    t.print();
}

Note that in this simple example we didn't have to include the lines #include <iostream>, #include <cmath>, or using namespace std in main.cpp since they are never needed there; we only use functions from the C++ standard library within the triangle class. However, we did need to write #include "triangle.hpp" so that we have access to the class itself.

triangle.hpp:

class triangle
{
public:
    // Constructor with no arguments: define a degenerate triangle with all its sides equal to zero.
    triangle();
    // Constructor with one argument: define an equilateral triangle with all sides equal to a.
    triangle(const double &_a);
    // Constructor with two arguments: define a right triangle with sides a and b, and the third side given by the Pythagorean theorem.
    triangle(const double &_a, const double &_b);
    // Constructor with three arguments: define an arbitrary triangle with sides a, b, c.
    triangle(const double &_a, const double &_b, const double &_c);

    // Change (or initialize) the sides of the triangle, after making sure the values are valid.
    void change_sides(const double &_a, const double &_b, const double &_c);
    // Print the sides of the triangle.
    void print();

private:
    // The lengths of the sides.
    double a = 0, b = 0, c = 0;
};

This header file contains only the interface of the class, with no actual code. It will be used, separately, by both main.cpp and triangle.cpp, and neither of them will compile without it. Therefore, both .cpp files must contain the line #include "triangle.hpp". Furthermore, this is the file that the user will read in order to understand how the class works, so it should contain comments to explain the role of each member of the class.

triangle.cpp:

#include <cmath>
#include <iostream>
#include <stdexcept>
#include "triangle.hpp"
using namespace std;

triangle::triangle()
{
    change_sides(0, 0, 0);
}

triangle::triangle(const double &_a)
{
    change_sides(_a, _a, _a);
}

triangle::triangle(const double &_a, const double &_b)
{
    change_sides(_a, _b, sqrt(_a * _a + _b * _b));
}

triangle::triangle(const double &_a, const double &_b, const double &_c)
{
    change_sides(_a, _b, _c);
}

void triangle::change_sides(const double &_a, const double &_b, const double &_c)
{
    if ((_a < 0) or (_b < 0) or (_c < 0))
        throw invalid_argument("Sides cannot be negative!");
    if ((_a > _b + _c) or (_b > _c + _a) or (_c > _a + _b))
        throw invalid_argument("Triangle inequality must be satisfied!");
    a = _a;
    b = _b;
    c = _c;
}

void triangle::print()
{
    cout << '(' << a << ", " << b << ", " << c << ")\n";
}

This file contains the actual implementation of triangle.

Before we can compile the project with these three separate files, we will need to make some small modifications to the configuration files of our Visual Studio Code project (located in the .vscode subdirectory). First, open the file tasks.json. Currently, the args field should look something like this:

"args": [
    "${file}",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe",
    "-Wall",
    "-Wextra",
    "-Wconversion",
    "-Wsign-conversion",
    "-Wshadow",
    "-Wpedantic",
    "-std=c++20",
    "-ggdb3"
],

(If you don't have these arguments in your JSON file, you should add them now - I explained their purpose in the beginning of the course and the meaning of -std=c++20 in the beginning of this chapter.)

Notice the highlighted string "${file}". Currently, VS Code is configured to only compile the active file; ${file} is a placeholder that will get replaced by that file's name. If we try to compile the program now, only the active file will be compiled, either main.cpp or triangle.cpp, but not both. If main.cpp is the active file, then it won't know about the class triangle and the compilation will fail. If triangle.cpp is the active file, then the compilation will also fail because there is no main function in that file.

We can fix this in one of two ways: either we write the names of the files explicitly, i.e. replace ${file} with main.cpp triangle.cpp, or simply replace ${file} with ${workspaceFolder}\\*.cpp, which will automatically compile all of the files in the workspace folder. * is a wildcard which will match any file name, so *.cpp will match any file with the extension .cpp.

The latter is usually the preferred option, since it means that we do not have to modify tasks.json every time we add a new source file or change its name. Of course, this means that all of the files in the workspace folder must belong to the same project, since they will be compiled and linked together, and conversely, all files to be linked must be placed in the same folder.

The second highlighted string determines the name of the executable file. Again, the default is to name the file after whatever source file is currently open in the editor. That is not a good idea, since if we are editing main.cpp the executable file will be main.exe and if we're editing triangle.cpp the executable file will be triangle.exe, even though in both cases the same executable file will be generated.

To solve this problem, let us replace the string "${fileDirname}\\${fileBasenameNoExtension}.exe" with "${workspaceFolder}\\CSE701.exe". Of course, you can choose any other name for the executable file, and you can put it in any other folder you want; in fact, for big projects it makes sense to put the source, header, and executable files all in different folders, but there's no reason to do that for our simple project.

Note: On Linux, the executable file should not have the extension .exe, and the path should have a slash / instead of a double backslash \\ (this is actually just one backslash, but since a backslash is used to escape special characters, such as \n for a newline character, we need to escape the backslash itself as well). Use ${workspaceFolder}/*.cpp for the first highlighted line and "${workspaceFolder}/CSE701" for the second.

Now let us open the launch.json file. It should look something like this:

{
    "version": "0.2.0",
    "configurations": [
        {
            // ...
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
            // ...
        }
    ]
}

Replace the highlighted string with "${workspaceFolder}\\CSE701.exe", so that VS Code will know to execute the file CSE701.exe when we enter debug mode. On Linux, use "${workspaceFolder}/CSE701" instead.

Lastly, open the file c_cpp_properties.json, which should look like this:

{
    "configurations": [
        {
            // ...
            "includePath": [
                "${workspaceFolder}/**"
            ],
            // ...
        }
    ],
    "version": 4
}

Make sure the includePath field includes the folder ${workspaceFolder}/**. This means that VS Code will look for include files (.h or .hpp) in the workspace folder and all its subfolders. The wildcard ** matches not only any file name, but also any file in any subfolder.

The .json files that I used to compile this program on my computer are as follows:

tasks.json:

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: g++.exe build active file",
            "command": "C:/Users/barak/mingw64/bin/g++.exe",
            "args": [
                "${workspaceFolder}\\*.cpp",
                "-o",
                "${workspaceFolder}\\CSE701.exe",
                "-Wall",
                "-Wextra",
                "-Wconversion",
                "-Wsign-conversion",
                "-Wshadow",
                "-Wpedantic",
                "-std=c++20",
                "-ggdb3"
            ],
            "options": {
                "cwd": "C:/Users/barak/mingw64/bin"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "compiler: C:/Users/barak/mingw64/bin/g++.exe"
        }
    ]
}

launch.json:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "g++.exe - Build and debug active file",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}\\CSE701.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "C:\\Users\\barak\\mingw64\\bin\\gdb.exe",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "C/C++: g++.exe build active file"
        }
    ]
}

c_cpp_properties.json:

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "windowsSdkVersion": "10.0.20348.0",
            "compilerPath": "C:/Users/barak/mingw64/bin/g++.exe",
            "intelliSenseMode": "windows-gcc-x64",
            "cStandard": "c17",
            "cppStandard": "c++20"
        }
    ],
    "version": 4
}

I'm only including these files here for reference; they will not work on your system in their current form, unless your name is also Barak, you're also using Windows, and your compiler is also located in the folder C:/Users/barak/mingw64/bin.

Now we are ready to run the program! No matter which file is currently open in the editor, pressing F5 will compile both main.cpp and triangle.cpp, link them into the executable file triangle.exe, and then execute that file in debug mode. You should see the output (1, 2, 3) in the terminal.

Finally, a note about inline functions when using multiple files in a project. An inline function is copied as-is into the code, so the compiler needs to have the source code for the function. Therefore, an inline function must be defined in the header file, because if triangle.cpp is already compiled and we don't have the source for it, then the compiler won't know what code to use for the inline function.

5.1.11 Const vs. non-const member functions ^

Some member functions of a class modify an object's data, while others do not. We can let the compiler know that a member function does not modify the data by adding the const keyword to its definition.

In the case of triangle, print() should be a const member function, since it does not modify the data. However, change_sides() should not be const, since it obviously does modify the data. So we should change the declaration of print() in triangle.hpp to:

void print() const;

and in triangle.cpp to:

void triangle::print() const

Let us define two new member functions:

• scale will multiply each of the triangle's side lengths by a scalar. This changes the data, so will not be a const member function.
• area will return the area of the triangle as calculated from the side lengths (using Heron's formula). This does not change the data, so it will be a const member function.

Add the following to triangle.hpp, in the public section:

// Scale the triangle by the given scalar.
void scale(const double &);
// Calculate the area of the triangle.
double area() const;

Add the following to triangle.cpp:

void triangle::scale(const double &s)
{
    if (s < 0)
        throw invalid_argument("Scalars cannot be negative!");
    a *= s;
    b *= s;
    c *= s;
}

double triangle::area() const
{
    const double s = (a + b + c) / 2;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

To test these functions, we can use the following main.cpp:

#include <iostream>
#include "triangle.hpp"
using namespace std;

int main()
{
    triangle t(3, 4, 5);
    cout << "Triangle sides: ";
    t.print();
    cout << "Triangle area: ";
    cout << t.area() << '\n';
    const double s = 2;
    t.scale(s);
    cout << "Triangle sides after scaling by " << s << ": ";
    t.print();
    cout << "Triangle area after scaling by " << s << ": ";
    cout << t.area();
}

It is important to declare member functions which do not change the object's data as const for two main reasons. The first is readability: const provides information about how the function behaves, not only the compiler, but also to the user who reads the header file.

The second reason is that if the user defines a const object, the compiler will generate an error when a non-const member function is called. You can check this by changing the line triangle t(3, 4, 5) to const triangle t(3, 4, 5); the compiler will let you call area(), but not scale().

5.1.12 Enumeration classes ^

Enumerations in C++ work very similarly to enumerations in C. However, in C, an enum just assigned labels to integers, and any variable defined with that enum was secretly an int, which could lead to bugs if we're not careful - for example, by assigning to it an integer value that does not have a corresponding label. In C++, by defining an enumeration as an enum class, we define an entirely new type. For example, consider an improvement of our color enumeration from the C example:

enum class color
{
    red,
    green,
    blue
};

Notice that now we write the labels in lowercase, since they are no longer global constants, as they were in C. Instead, they are accessible using color::red, color:green, and color::blue. Also, we define a variable of this type using color c instead of enum color c; in C++, you don't need to write the enum directly (same as for struct).

In the following example we are using a "plain" enum instead of an enum class (also called a scoped enumeration):

#include <iostream>
using namespace std;

enum color
{
    red,
    green,
    blue
};

int main()
{
    color c = red;   // Note that red is in the global scope, causing potential collisions.
    int x = c;       // Works; enum is implicitly converted to an int.
    cout << x + red; // Also works; can add int and color, which doesn't make sense. Prints 0.
}

This is a bit problematic. First, just like with C enumerations, the labels red, green, and blue are in the global scope. Usually in C++ we prefer to separate names into different namespaces. Furthermore, when we create a new int and assign the value of c to it, that value is implicitly converted to an int, and the same happens when we try to add an int and a color. That doesn't make sense; as I explained regarding C enumerations, the integer values of each label should never be used explicitly.

Let us now use enum class instead:

#include <iostream>
using namespace std;

enum class color
{
    red,
    green,
    blue
};

int main()
{
    color c = color::red;   // Note that red is in the color:: scope, not the global scope.
    int x = c;              // Error: a value of type "color" cannot be used to initialize an entity of type "int".
    cout << x + color::red; // Error: cannot add an int and a color.
}

We see that color is now indeed an entirely new type, which can only take the specific values we assigned as labels; it is not an int, nor can it be implicitly converted to an int.

It is always better to use enum class, as it prevents bugs due to incorrectly comparing an enum with an int - or even with another enum. For example, consider this code:

#include <iostream>
using namespace std;

enum color
{
    red,
    green,
    blue
};

enum shape
{
    triangle,
    circle,
    square
};

int main()
{
    color c = red;
    shape s = triangle;
    if (c == s) // Comparing is possible with enum, but not with enum class
        cout << "Values are the same!";
}

The first thing to notice here is that if we still used the triangle class we defined above, it would clash with the label triangle. This is exactly why it is better to put things in separate namespaces.

Furthermore, this program will print out "Values are the same!" because both of them are secretly equal to 0, as both are the first labels in their respective enumerations, and there is an implicit conversion taking place here. (The compiler warns about it, but still compiles.)

However, if we change both enums to enum class, and correspondingly red to color::red and triangle to shape::triangle, we will get an error - as we should, since this is very bad code - and the program won't compile.

Finally, note that both in the case of enum and enum class, it is still not possible to write something like c = 0, as we could in C. (Well, you could write c = (color)0 to explicitly typecast 0 to color if you really wanted, but you shouldn't.)

5.1.13 Static class members ^

Static class members, defined with the keyword static, are a generalization of static function variables. They are members that exist in the class itself, independently of any specific objects of that class.

For example, we can use a static member variable to keep count of how many objects of a class have been created. This is illustrated in the following program:

#include <iostream>
using namespace std;

class counter
{
public:
    counter()
    {
        total_count++;
        my_count = total_count;
    }

    void print_count() const
    {
        cout << "I am object #" << my_count << ".\n";
    }

    inline static uint64_t total_count = 0;
    uint64_t my_count;
};

int main()
{
    const counter first;
    const counter second;
    const counter third;

    cout << "Created " << counter::total_count << " objects in total.\n";

    first.print_count();
    second.print_count();
    third.print_count();
}

The output is:

Created 3 objects in total.
I am object #1.
I am object #2.
I am object #3.

We see that the static member variable total_count keeps count of how many objects were created in total, and it is accessed not via a specific object, but rather as a name in the namespace counter, i.e. counter::total_count. This member exists independently of any specific objects of that class - in fact, it would still exist if we did not create any objects at all.

In addition to static, we also declared total_count as inline. The reason is that this allows us to initialize it within the class itself. Without the inline keyword, we would have had to initialize it outside the class definition, or rely on the user to initialize it manually; in both cases it is possible that due to oversight total_count will not be properly initialized, and thus will start the count with some garbage value.

We can also define static member functions. For example, it's a good idea to make total_count and my_count private members, since the class invariants in this case are that:

• total_count must be equal to the total number of objects we created,
• my_count must be consecutive and unique for each counter.

So we don't want to user to manually change the values of these variables and break the invariant. However, if total_count is private, then we should make a public static member function get_total_count() to allow read-only access to the variable:

#include <iostream>
using namespace std;

class counter
{
public:
    counter()
    {
        total_count++;
        my_count = total_count;
    }

    void print_count() const
    {
        cout << "I am object #" << my_count << ".\n";
    }

    static uint64_t get_total_count()
    {
        return total_count;
    }

private:
    inline static uint64_t total_count = 0;
    uint64_t my_count;
};

int main()
{
    const counter first;
    const counter second;
    const counter third;

    cout << "Created " << counter::get_total_count() << " objects in total.\n";

    first.print_count();
    second.print_count();
    third.print_count();
}

This will have the same output as before. Note that static member functions are accessed similar to static member variables: with the class namespace prefix, e.g. counter::get_total_count(). Also note that we did not need to declare get_total_count as a const member function, since it cannot access member variables of any specific objects anyway, only static member variables of the class itself, and thus there is no situation in which a const object can accidentally be modified by the function.

5.2 Operator overloading ^

5.2.1 Introduction to operator overloading

Operators such as + and - have a well-defined meaning for fundamental types such as int and double. An extremely useful feature of C++ is the ability to give meaning to such operators for user-defined types (that is, classes) as well. For example, if we have a matrix class, we could define + to be the operation of matrix addition and * to be matrix multiplication. This is called operator overloading.

We can overload almost every operator, as long as it is an existing operator in C++; we cannot create new operators with new symbols. The full list of operators that can be overloaded is:

• Arithmetic operators:
  • Binary infix: + (add), - (subtract), * (multiply), / (divide), % (modulo), += (add and assign), -= (subtract and assign), *= (multiply and assign), /= (divide and assign), %= (modulo and assign)
  • Unary prefix: + (positive), - (negative)
  • Unary prefix or postfix: ++ (increment), -- (decrement)
• Bit manipulation:
  • Binary infix: & (bitwise AND), | (bitwise OR), ^ (bitwise XOR), << (bitwise left shift), >> (bitwise right shift), &= (bitwise AND and assign), |= (bitwise OR and assign), ^= (bitwise XOR and assign), <<= (bitwise left shift and assign), >>= (bitwise right shift and assign)
  • Unary prefix: ~ (bitwise NOT)
• Comparison and logic:
  • Binary infix: == (equals), != (does not equal), < (less than), > (greater than), <= (less than or equal), >= (greater than or equal), && (and), || (or), <=> (the "spaceship operator" for three-way comparison, since C++20)
  • Unary prefix: ! (not)
• Member access:
  • Binary infix: [] (subscript / array element), -> (member of pointer), ->* (pointer to member of pointer)
  • Unary prefix: * (pointer dereference), & (address of)
• Miscellaneous:
  • Binary infix: = (assign), , (comma expression)
  • N-ary infix: () (function call)

Infix means the operator comes between the two operands (e.g. x + y), prefix means the operator precedes the operand (e.g. -x), and postfix means the operator follows the operand (e.g. x++). Binary means there are two operands (e.g. x + y) and unary means there is one operand (e.g. -x).

The function call operator () is the only one that allows more than two operands, i.e. f(x, y, z, ...). Of course, it is possible to write something like x + y + z, but the + operator is still binary, since this expression will be evaluated as (x + y) + z, i.e. two binary operators evaluated one after the other.

Some of these operators have not been used so far in this course. Let us quickly explain what they do:

• The unary prefix + usually doesn't actually do anything; +x is equal to x.
• When ++ comes as a prefix, i.e. ++x, it is a "pre-increment" operator, which increments the variable and returns the incremented value. When ++ comes as a postfix, i.e. x++, it is a "post-increment" operator, which increments the variable but returns the original value. Same goes for --.
  • To remember which is which, notice that they are executed from left to right: ++x means "first increment, then return x" while x++ means "first return x, then increment". So int x = 1; y = ++x; will result in x = 2 and y = 2, but int x = 1; y = x++; will result in x = 2 and y = 1.
• We didn't mention the bit manipulation operators before because they are not used very often. They perform the usual bit operations AND, OR, XOR, and NOT bit-by-bit. The shift operators << and >> are respectively equivalent to multiplying and dividing by powers of 2. You can read more about them on Wikipedia.
  • Note that the most common use of << and >> in C++ is not for bit manipulation; instead, these operators are overloaded to deal with input/output streams. Whenever you write cout << or cin >>, you are using overloaded operators!
• The three-way comparison operator <=> was introduced in C++20. To use it, you need to enable C++20 support in the compiler (see above) and #include <compare> in your program. We will not discuss this operator in our course.
• The comma operator , is not the usual comma such as in a function call f(x, y), it is used to evaluate several expressions and keep only the result of the last one. For example, the statements int x = 0; cout << (++x, ++x); will output 2 since the first ++x increments x by 1 and gives the result 1 which is discarded, while the second ++x increments x by 1 and gives the result 2 which is then printed.
• We have seen above that the operator -> is used to access a member of a struct or class when the latter is given as a pointer. The expression x->y is equivalent to (*x).y. Similarly, for the operator ->*, the expression x->*y is equivalent to (*x).*y.

Note that the operators :: (scope resolution), . (member of object), .* (pointer to member of object), and ?: (ternary conditional operator) cannot be overloaded.

Operators cannot be overloaded for fundamental types; you cannot redefine how + works for int, for example. At least one of the operands must be a user-defined type, although it is possible to combine a user-defined type with a fundamental type - for example, we could overload * so that if it is used with one double and one user-defined matrix object, it multiplies the entire matrix by the number.

Apart from the overloaded operators << and >> that we discussed above, we already encountered another example of an overloaded operator when we talked about the C++ string class. To concatenate strings, we simple write string1 + string2; this works because the operator + has been overloaded with a function that performs concatenation of strings.

Overloaded operators retain their existing syntax and number of operands. For example, ! (not) must still act on one object and < (less than) must still compare two objects. The syntax for operator overloading for unary operators such as ! and ++, which act on one operand, is:

output_type operator@(input_type operand)
{
    // Function body
}

Here, @ should be replaced with the actual operator, e.g. operator! to replace the ! operator. For example, !x will call the function operator!(x).

The syntax for operator overloading for binary operators such as + and *, which act on two operands, is:

output_type operator@(input_type1 operand1, input_type2 operand2)
{
    // Function body
}

Again, @ should be replaced with the actual operator, e.g. operator+ to replace the + operator. For example, x + y will call the function operator+(x, y).

Here are some important rules of thumb for how to use operator overloading:

• The meaning of the operators should be retained when overloading. For example, if the class is a matrix, then + should be overloaded with matrix addition. If you overload + with matrix multiplication, your code will be very confusing.
• The usual behavior of the operators should be retained when overloading. For example, the user will expect that x + y - x should be equal to y. Similarly, the user will expect that if x < y and y < z, then x < z.
• If an operator is defined, then related operators should also be defined. For example, if you define + you should also define += and if you define < you should also define >.
  • Generally, in such cases, one operator will refer to the other. For example, it is customary to use += to define + (as we will do below), and to use < to define > (or vice versa).
• Overloaded operators should modify their operands if and only if the original operator does. For example, a + b is not expected to modify a or b, but a++ is expected to modify a.
• Operators should get their arguments by reference whenever possible. If the operator does not modify an operand, it should get it as a const reference, and if it does, it should get it as a non-const reference.
  • However, if a temporary copy must be created anyway, it is often convenient to get the operand by value, as that eliminates the need to manually create a copy. See below for examples.
• Only use overloaded operators when it makes sense to do so. For example, it makes sense to define a subtraction operator between two dates, which will give the time difference between them. However, adding or multiplying two dates doesn't make sense.

5.2.2 Overloading the << operator ^

Let us now consider a simple example. If we try to pass a vector to cout in order to print it, we will get an error:

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    const vector<double> a = {1, 2, 3};
    cout << a; // Error: no match for 'operator<<'
}

The compiler is telling is that there is no match for operator<< with the given operands, one of which is an ostream (that is the type of cout) and the other is a vector<double>. This operator is defined when the second operand is, for example, a number or a string, but there is no built-in way to print out vectors in C++. Therefore, we need to define this operator ourselves using operator overloading:

#include <iostream>
#include <vector>
using namespace std;

ostream& operator<<(ostream& out, const vector<double>& vec)
{
    out << '(';
    for (size_t i = 0; i < vec.size() - 1; ++i)
        out << vec[i] << ", ";
    out << vec[vec.size() - 1] << ')';
    return out;
}

int main()
{
    const vector<double> v = {1, 2, 3};
    cout << v; // (1, 2, 3)
}

Let us explain each piece of the line ostream& operator<<(ostream& out, const vector<double>& vec):

• ostream&: The function we are defining returns a reference to an ostream object.
• operator<<: This function will act whenever we use the operator <<.
• (ostream& out, const vector<double>& vec): This operator will have two operands: one is a reference to an ostream object and the other is a reference to a vector<double> object.
• The first argument is not const, because we want to change it. The second argument is a const, because we do not want to change it.

When we call cout << v, this a << operator with two operands. The first is cout, which is an ostream object. The second is v, which is a vector<double> object. The compiler looks for a suitable operator overload, and finds our function, which is executed.

Note that if the return type was void instead of ostream &, the statement cout << v would have still worked, but we would have not been able to chain the << operator - as in, for example, cout << v << v. Returning a reference to the stream out allows the same stream to be used again in a subsequent operation.

The function itself is pretty simple:

• We put a left parenthesis ( into out.
• We iterate over all the elements of the vector except the last one using a for loop, and print each one of them followed by a comma and a space.
• We output the last element of the vector followed by a right parenthesis ).

(If we didn't want the parentheses or the commas, we could have used a much more compact range-based for loop of the form for (const double& i : vec) out << i << ' '.)

In the following sections, we will make use of the << operator overload to print out vectors in order to demonstrate the other operator overloads we will create. To save space, I will create a header file vector_overloads.hpp which will include the above code except for the main() function, and include it in each example. Every time I define a new overload, I will add it to this header file as well, and in the end we will have one big header file with all of our overloads.

5.2.3 Overloading the == and != operators ^

The next operators we will overload are the comparison operators == and !=. Note that these operators are actually already overloaded in the standard library, but we will write our own overloads anyway, for pedagogical reasons.

Clearly, two vectors are equal to each other if all their elements are the same. Therefore, the comparison must involve comparing every single element of both vectors. However, we should first check if the vectors are the same size; if not, then they are clearly not equal, and we do not need to check any elements at all.

Furthermore, there is no point in defining two completely independent operators for == and !=; one can simply be written in terms of the other. In fact, in C++20, the compiler will generate the != operator automatically if the == operator is defined for the same operands, but we will write it explicitly anyway.

Here is the code:

#include "vector_overloads.hpp"

bool operator==(const vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        return false;
    for (size_t i = 0; i < lhs.size(); ++i)
        if (lhs[i] != rhs[i])
            return false;
    return true;
}

bool operator!=(const vector<double>& lhs, const vector<double>& rhs)
{
    return !(lhs == rhs);
}

int main()
{
    const vector<double> a = {1, 2, 3};
    const vector<double> b = {1, 2, 3};
    const vector<double> c = {1, 2, 3, 4};
    const vector<double> d = {5, 6, 7};
    cout << (a == a) << ' ' << (a != a) << '\n'; // 1 0
    cout << (a == b) << ' ' << (a != b) << '\n'; // 1 0
    cout << (a == c) << ' ' << (a != c) << '\n'; // 0 1
    cout << (a == d) << ' ' << (a != d) << '\n'; // 0 1
}

Notice that, of course, a == a. We could potentially include something like this in the beginning of operator==():

if (&lhs == &rhs)
    return true;

This will save us time if we compare a vector to itself, because we won't have to redundantly compare every single element to itself. However, comparing an object to itself is done very rarely if at all, and running this check every single time we're comparing any two vectors can have a detrimental effect on performance too, especially if we are comparing many different vectors.

Importantly, when overloading the == operator for any class T, the prototype must always be bool operator==(const T& lhs, const T& rhs), and similarly for !=. You can find the prototypes for other comparison operators here.

5.2.4 Overloading the + and += operators ^

Next, we would like to introduce vector addition using the operators + and +=. These operators will add two vectors element-by-element. The canonical way to implement addition or other arithmetic operators on any class is to first define += and then reuse it in +, similarly to how we first defined == and then reused it in !=. The reason we don't do it the opposite way - define + and then reuse it in += - will be explained shortly.

Obviously, we cannot add two vectors of different sizes. Therefore, our addition operation must throw an exception if the sizes of the vectors don't match. Here is the code:

#include "vector_overloads.hpp"
#include <stdexcept>

vector<double>& operator+=(vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        throw invalid_argument("Cannot add vectors of different sizes!");
    for (size_t i = 0; i < lhs.size(); ++i)
        lhs[i] += rhs[i];
    return lhs;
}

vector<double> operator+(vector<double> lhs, const vector<double>& rhs)
{
    lhs += rhs;
    return lhs;
}

int main()
{
    try
    {
        vector<double> a = {1, 2, 3};
        const vector<double> b = {4, 5, 6};
        const vector<double> c = {7, 8, 9};
        const vector<double> d = {1, 2, 3, 4};
        a += b;
        cout << a << '\n';         // (5, 7, 9)
        cout << b + c << '\n';     // (11, 13, 15)
        cout << a + b + c << '\n'; // (16, 20, 24)
        cout << a + d << '\n';     // Error: Cannot add vectors of different sizes!
    }
    catch (const invalid_argument& e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

Let's go over operator+=() line by line:

• The operator takes two arguments:
  1. vector<double>& lhs: The vector that we want to assign the sum to. Note that we must pass it by (non-const) reference so we can change it; if we passed it by value, we would only be changing a copy of it.
  2. const vector<double>& rhs: The vector that we want to add to lhs. We pass it by const reference because we don't want to change it (hence the const) but we also don't want to copy it, since that would be a waste of time (hence the reference).
• Importantly, when overloading the += operator for any class T, the prototype must always be T& operator+=(T& lhs, const T& rhs), and similarly for all other compound assignment operators. You can find the prototypes for other assignment operators here.
• First, we compare the sizes of the two vectors, and throw an exception if they don't match.
• Next, we go over each element of lhs and add the corresponding element of rhs, storing the result in lhs using the built-in += operator.
• Finally, we return a reference to lhs. Of course, we must return a reference, since we do not want to make a copy of it.

Next, operator+():

• The operator takes two arguments:
  1. vector<double> lhs: The first vector to add. Note that we pass it by value, even though the usual prototype for + is T operator+(const T& lhs, const T& rhs) (as you can see here). The reason is that in this case, we actually want to make a copy of lhs!
     • This is because we cannot change either of the two vectors; we just want to add their elements and return a new vector with the result. We could pass both vectors as const references and create a new temporary vector to store the result, but that requires allocating and initializing the temporary vector. It's more efficient to just let the compiler make the copy automatically by passing one of the vectors by value, and this also lets us reuse our += operator, making the + operator trivial.
  2. const vector<double>& rhs: The vector that we want to add to lhs, passed by const reference.
• In the body of the function we simply use the operator +=, which we already defined, to add lhs to rhs and store the result in lhs.
• The operator returns lhs by value. This has nothing to do with the original lhs, it is essentially a new vector containing the result of adding lhs and rhs. Returning it by value allows us to chain addition operations, as demonstrated in the example by a + b + c.

5.2.5 Overloading the - and -= operators ^

Since we defined addition, we should also define subtraction. Note that there are two different - operators: an unary and a binary one. The unary - is easy: it which simply returns a copy of the vector with all its elements replaced with their negatives. The binary - can be implemented in terms of -= just as we did for + and +=; in fact, we only need to replace the + with a -. Here is the result:

#include "vector_overloads.hpp"

vector<double>& operator-=(vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        throw invalid_argument("Cannot subtract vectors of different sizes!");
    for (size_t i = 0; i < lhs.size(); ++i)
        lhs[i] -= rhs[i];
    return lhs;
}

vector<double> operator-(vector<double> lhs, const vector<double>& rhs)
{
    lhs -= rhs;
    return lhs;
}

vector<double> operator-(vector<double> vec)
{
    for (size_t i = 0; i < vec.size(); ++i)
        vec[i] = -vec[i];
    return vec;
}

int main()
{
    try
    {
        vector<double> a = {1, 2, 3};
        const vector<double> b = {4, 5, 6};
        const vector<double> c = {7, 8, 9};
        const vector<double> d = {1, 2, 3, 4};
        a -= b;
        cout << a << '\n';         // (-3, -3, -3)
        cout << -a << '\n';        // (3, 3, 3)
        cout << b - c << '\n';     // (-3, -3, -3)
        cout << a + b - c << '\n'; // (-6, -6, -6)
        cout << a - d << '\n';     // Error: Cannot subtract vectors of different sizes!
    }
    catch (const invalid_argument& e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

Note that we could have just defined the binary - operator as return lhs + (-rhs), taking advantage of the fact that we already defined an unary - operator. Indeed, in linear algebra, subtraction of vectors is actually defined as adding the additive inverse of the second vector to the first. However, this would mean that the program must run two loops, one to calculate -rhs and another to calculate lhs + (-rhs). By writing a single subtraction loop explicitly, we essentially cut the time it would take to subtract vectors by half.

5.2.6 Overloading the * operator ^

The overload for multiplication should return the dot product of the two vectors. As with addition and subtraction, we cannot multiply vectors of different sizes, so we should throw an exception in that case. In addition, the return value of * should be a scalar, not a vector. Therefore, *= is not a valid operator, as it would assign a scalar to a vector. Note also that there is no division of vectors, so we will not overload the / operator. Here is the code:

#include "vector_overloads.hpp"

double operator*(const vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        throw invalid_argument("Cannot take the dot product of vectors of different sizes!");
    double result = 0;
    for (size_t i = 0; i < lhs.size(); ++i)
        result += lhs[i] * rhs[i];
    return result;
}

int main()
{
    try
    {
        const vector<double> a = {1, 2, 3};
        const vector<double> b = {4, 5, 6};
        const vector<double> c = {1, 2, 3, 4};
        cout << a * b << '\n';                        // 32
        cout << b * a << '\n';                        // 32 (the operation is commutative)
        cout << b * vector<double> {7, 8, 9} << '\n'; // 122 (used a literal vector)
        cout << (a - b) * a << '\n';                  // -18 (chained different operations)
        cout << a * c << '\n';                        // Error: Cannot take the dot product of vectors of different sizes!
    }
    catch (const invalid_argument& e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

Here we used vector<double> {7, 8, 9} as a literal vector. What we mean by that is that instead of first declaring, for example, vector<double> d = {7, 8, 9} and then writing cout << b * d, we wrote the vector directly. This is the same as writing the number 7 directly in a statement instead of first declaring int x = 7 and using x. If we're just going to use an object once, it's better to use it as a literal instead of declaring a specific symbol for it. Objects created in this way are called temporary objects; since we didn't give vector<double> {7, 8, 9} a name, it only exists temporary in that line, and then automatically discarded.

5.2.7 Combining fundamental and user-defined types ^

In addition to the dot product of two vectors, we should also define multiplication of a vector by a scalar. This means that we should overload * for the case where one operand is a double and the other is a vector<double>. Since the two operands are of different types, we will need to overload * twice: one overload for the case where the vector is on the left and another when it's on the right. Also, in this case it does make sense to overload *= too, meaning that we assign to the vector its product with the given scalar. Here are the new overloads:

#include "vector_overloads.hpp"

vector<double>& operator*=(vector<double>& lhs, const double rhs)
{
    for (size_t i = 0; i < lhs.size(); ++i)
        lhs[i] *= rhs;
    return lhs;
}

vector<double> operator*(vector<double> lhs, const double rhs)
{
    lhs *= rhs;
    return lhs;
}

vector<double> operator*(const double lhs, vector<double> rhs)
{
    rhs *= lhs;
    return rhs;
}

int main()
{
    vector<double> a = {1, 2, 3};
    cout << a * 3 << '\n'; // (3, 6, 9)
    cout << 4 * a << '\n'; // (4, 8, 12)
    a *= 5;
    cout << a << '\n'; // (5, 10, 15)
}

5.2.8 The complete vector overloads: a header-only library ^

The operator overloads that we defined above for vectors are very useful for doing linear algebra. Therefore, we should put them in portable form, so that they may be easily incorporated into different programs. In cases where there is not too much code to warrant a separate .cpp file (which will then need to be complied separately), C++ programmers often share code as a header-only library, meaning that the entire library of classes and/or functions is located in the header file itself. Then all one needs to do is to include that header file, and that's it.

The header file, vector_overloads.hpp, is as follows:

#include <iostream>
#include <stdexcept>
#include <vector>
using namespace std;

ostream& operator<<(ostream& out, const vector<double>& vec)
{
    out << '(';
    for (size_t i = 0; i < vec.size() - 1; ++i)
        out << vec[i] << ", ";
    out << vec[vec.size() - 1] << ')';
    return out;
}

bool operator==(const vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        return false;
    for (size_t i = 0; i < lhs.size(); ++i)
        if (lhs[i] != rhs[i])
            return false;
    return true;
}

bool operator!=(const vector<double>& lhs, const vector<double>& rhs)
{
    return !(lhs == rhs);
}

vector<double>& operator+=(vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        throw invalid_argument("Cannot add vectors of different sizes!");
    for (size_t i = 0; i < lhs.size(); ++i)
        lhs[i] += rhs[i];
    return lhs;
}

vector<double> operator+(vector<double> lhs, const vector<double>& rhs)
{
    lhs += rhs;
    return lhs;
}

vector<double>& operator-=(vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        throw invalid_argument("Cannot subtract vectors of different sizes!");
    for (size_t i = 0; i < lhs.size(); ++i)
        lhs[i] -= rhs[i];
    return lhs;
}

vector<double> operator-(vector<double> lhs, const vector<double>& rhs)
{
    lhs -= rhs;
    return lhs;
}

vector<double> operator-(vector<double> vec)
{
    for (size_t i = 0; i < vec.size(); ++i)
        vec[i] = -vec[i];
    return vec;
}

double operator*(const vector<double>& lhs, const vector<double>& rhs)
{
    if (lhs.size() != rhs.size())
        throw invalid_argument("Cannot take the dot product of vectors of different sizes!");
    double result = 0;
    for (size_t i = 0; i < lhs.size(); ++i)
        result += lhs[i] * rhs[i];
    return result;
}

vector<double>& operator*=(vector<double>& lhs, const double rhs)
{
    for (size_t i = 0; i < lhs.size(); ++i)
        lhs[i] *= rhs;
    return lhs;
}

vector<double> operator*(vector<double> lhs, const double rhs)
{
    lhs *= rhs;
    return lhs;
}

vector<double> operator*(const double lhs, vector<double> rhs)
{
    rhs *= lhs;
    return rhs;
}

We can now use these overloads in any program by including vector_overloads.hpp in the program. Here is an example of a main.cpp making use of our library:

#include "vector_overloads.hpp"
#include <iostream>
#include <stdexcept>
#include <vector>
using namespace std;

int main()
{
    try
    {
        vector<double> v = {1, 2, 3};
        vector<double> w = {4, 5, 6};
        vector<double> u = {1, 1, 1};
        cout << v + w << '\n'; // (5, 7, 9)
        cout << v * w << '\n'; // 32
        cout << -v << '\n';    // (-1, -2, -3)
        v += w;                //
        cout << v << '\n';     // (5, 7, 9)
        cout << v - w << '\n'; // (1, 2, 3)
        w -= u;                //
        cout << w << '\n';     // (3, 4, 5)
        cout << 2 * v << '\n'; // (10, 14, 18)
        cout << v * 3 << '\n'; // (15, 21, 27)
    }
    catch (const invalid_argument& e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

Note that, unlike with the triangle class, in this case there is no separate .cpp file; everything is in the header file vector_overloads.hpp. When you write #include "vector_overloads.hpp", what happens is simply that the compiler includes all the code in the header file as-is in your source code. There is no separate compilation or linking taking place. For compact and lightweight C++ packages, this is often the desired format, as you only need to worry about one extra file.

However, header-only libraries are only suitable for small code. Libraries which contain tens of thousands of lines of code are usually distributed as separate .hpp and .cpp files, and often, many such files. The reason is that compilation takes time, sometimes even several minutes or longer for large projects. By placing the library's code in a separate .cpp file, we only need to compile it once, and subsequently we can just link the already-compiled code. We will explain in more detail how that works later.

5.2.9 Summary: the matrix class ^

So far, we have overloaded all operators as non-member functions. However, for user-defined classes, it is also possible to overload operators using member functions. For a unary operator @, the non-member operator@(x) is equivalent to the member x.operator@(). For a binary operator @, the non-member operator@(x, y) is equivalent to the member x.operator@(y).

The operators =, (), [], and -> must be overloaded using member functions. On the other hand, if we are overloading a class written by someone else, such as when overloading << for ostream, it is more convenient to overload using non-member functions. In other cases, it's mostly a matter of taste whether to implement overloaded operators as member functions or not. (Personally, I think overloading operators as non-member functions produces clearer and more organized code.)

As an example, I will now define a class for matrices. Since in this case I am not just overloading operators for someone else's class (as in the vector overloads example), it makes sense to overload the compound assignment operators +=, -=, and *= (for multiplication by scalar) as member functions. This is because the matrix on the left is being assigned the result, so there is an asymmetry between the two operands. On the other hand, the binary operators +, -, and * themselves should still be implemented as non-member functions, as in this case there is a symmetry between the operands.

This class will also include an overloaded operator () used to access the matrix elements. Instead of m[x][y], which is what we would have if the matrix was a multi-dimensional array, I use the more convenient notation m(x, y). The operator () is overloaded using a member function.

Note that there will be two versions of the () overload: one is not a const and returns a non-const reference, and the other is a const and returns a const reference. The first version allows modification of the element being accessed. For example, m(0, 0) = 1 changes the top-left element to 1. This is possible because m(0, 0) is a reference to that element in memory, and this allows the user to access that element directly for both reading and writing.

On the other hand, when the second version is used, it returns a constant reference to the element, so the user cannot modify that element. (We could also have returned a copy, but as usual, returning a reference is faster since copying a large object takes time.)

Similarly, the member functions get_rows() and get_cols() allow the user to obtain the number of rows and columns, but not change it, therefore they are marked as const.

If you remove the const keyword from any of the constant member functions, the program will not compile, since the << operator overload takes a const matrix & argument, so it cannot call any member functions that are not const. This is exactly why we needed two versions of the () overload. The overloaded operator << accepts a const matrix &m, so it will call the second (const) version of the () overload. On the other hand, the main function calls the first (non-const) version.

I wrote this matrix class to illustrate everything we learned about C++ so far. We will further improve it later in the course. Please refer to the comments in the header file for more information.

matrix.hpp:

#include <initializer_list>
#include <iostream>
#include <stdexcept>
#include <vector>
using namespace std;

class matrix
{
public:
    // Constructor to create a zero matrix.
    // First argument: number of rows.
    // Second argument: number of columns.
    matrix(const size_t, const size_t);

    // Constructor to create a diagonal matrix from a vector.
    // Argument: a vector containing the elements on the diagonal.
    // Number of rows and columns is inferred automatically.
    matrix(const vector<double>&);

    // Constructor to create a diagonal matrix from an initializer_list.
    // Argument: an initializer_list containing the elements on the diagonal.
    // Number of rows and columns is inferred automatically.
    matrix(const initializer_list<double>&);

    // Constructor to create a matrix from a vector.
    // First argument: number of rows.
    // Second argument: number of columns.
    // Third argument: a vector containing the elements in row-major order.
    matrix(const size_t, const size_t, const vector<double>&);

    // Constructor to create a matrix from an initializer_list.
    // First argument: number of rows.
    // Second argument: number of columns.
    // Third argument: an initializer_list containing the elements in row-major order.
    matrix(const size_t, const size_t, const initializer_list<double>&);

    // Member function to obtain (but not modify) the number of rows in the matrix.
    size_t get_rows() const;

    // Member function to obtain (but not modify) the number of columns in the matrix.
    size_t get_cols() const;

    // Overloaded operator () to access matrix elements WITHOUT range checking.
    // The indices start from 0: m(0, 1) would be the element at row 1, column 2.
    // Non-const version: allows modification of the element.
    double& operator()(const size_t, const size_t);

    // Overloaded operator () to access matrix elements WITHOUT range checking.
    // The indices start from 0: m(0, 1) would be the element at row 1, column 2.
    // const version: does not allow modification of the element.
    const double& operator()(const size_t, const size_t) const;

    // Member function to access matrix elements WITH range checking.
    // The indices start from 0: m.at(0, 1) would be the element at row 1, column 2.
    // Non-const version: allows modification of the element.
    double& at(const size_t, const size_t);

    // Member function to access matrix elements WITH range checking.
    // The indices start from 0: m.at(0, 1) would be the element at row 1, column 2.
    // const version: does not allow modification of the element.
    const double& at(const size_t, const size_t) const;

    // Overloaded binary operator += to add another matrix to this matrix.
    matrix& operator+=(const matrix&);

    // Overloaded binary operator -= to subtract another matrix from this matrix.
    matrix& operator-=(const matrix&);

    // Overloaded binary operator *= to multiply this matrix by a scalar.
    matrix& operator*=(const double);

    // Exception to be thrown if the number of rows or columns given to the constructor is zero.
    inline static invalid_argument zero_size = invalid_argument("Matrix cannot have zero rows or columns!");

    // Exception to be thrown if the vector of elements provided to the constructor is of the wrong size.
    inline static invalid_argument initializer_wrong_size = invalid_argument("Initializer does not have the expected number of elements!");

    // Exception to be thrown if two matrices of different sizes are added or subtracted.
    inline static invalid_argument incompatible_sizes_add = invalid_argument("Cannot add or subtract two matrices of different dimensions!");

    // Exception to be thrown if two matrices of incompatible sizes are multiplied.
    inline static invalid_argument incompatible_sizes_multiply = invalid_argument("Two matrices can only be multiplied if the number of columns in the first matrix is equal to the number of rows in the second matrix!");

    // Exception to be thrown if trying to access an element out of range.
    inline static invalid_argument out_of_range = invalid_argument("Tried to access an element out of range!");

private:
    // The number of rows.
    size_t rows = 0;

    // The number of columns.
    size_t cols = 0;

    // A vector storing the elements of the matrix in flattened (1-dimensional) form.
    vector<double> elements;
};

// Overloaded binary operator << to easily print out a matrix to a stream.
ostream& operator<<(ostream&, const matrix&);

// Overloaded binary operator == to compare two matrices.
bool operator==(const matrix&, const matrix&);

// Overloaded binary operator != to compare two matrices.
bool operator!=(const matrix&, const matrix&);

// Overloaded binary operator + to add two matrices.
matrix operator+(matrix, const matrix&);

// Overloaded unary operator - to take the negative of a matrix.
matrix operator-(const matrix);

// Overloaded binary operator - to subtract two matrices.
matrix operator-(matrix, const matrix&);

// Overloaded binary operator * to multiply two matrices.
matrix operator*(const matrix&, const matrix&);

// Overloaded binary operator * to multiply a matrix on the left and a scalar on the right.
matrix operator*(matrix, const double);

// Overloaded binary operator * to multiply a scalar on the left and a matrix on the right.
matrix operator*(const double, matrix);

matrix.cpp:

#include "matrix.hpp"
#include <initializer_list>
#include <iostream>
#include <stdexcept>
#include <vector>
using namespace std;

matrix::matrix(const size_t rows_, const size_t cols_) : rows(rows_), cols(cols_)
{
    if (rows == 0 or cols == 0)
        throw zero_size;
    elements = vector<double>(rows * cols);
}

matrix::matrix(const vector<double>& diagonal_) : rows(diagonal_.size()), cols(diagonal_.size())
{
    if (rows == 0)
        throw zero_size;
    elements = vector<double>(rows * cols);
    for (size_t i = 0; i < rows; ++i)
        elements[(cols * i) + i] = diagonal_[i];
}

matrix::matrix(const initializer_list<double>& diagonal_) : matrix(vector<double>(diagonal_)) {}

matrix::matrix(const size_t rows_, const size_t cols_, const vector<double>& elements_) : rows(rows_), cols(cols_), elements(elements_)
{
    if (rows == 0 or cols == 0)
        throw zero_size;
    if (elements_.size() != rows * cols)
        throw initializer_wrong_size;
}

matrix::matrix(const size_t rows_, const size_t cols_, const initializer_list<double>& elements_) : matrix(rows_, cols_, vector<double>(elements_)) {}

size_t matrix::get_rows() const
{
    return rows;
}

size_t matrix::get_cols() const
{
    return cols;
}

double& matrix::operator()(const size_t row, const size_t col)
{
    return elements[(cols * row) + col];
}

const double& matrix::operator()(const size_t row, const size_t col) const
{
    return elements[(cols * row) + col];
}

double& matrix::at(const size_t row, const size_t col)
{
    if ((row > rows - 1) or (col > cols - 1))
        throw out_of_range;
    return elements[(cols * row) + col];
}

const double& matrix::at(const size_t row, const size_t col) const
{
    if ((row > rows - 1) or (col > cols - 1))
        throw out_of_range;
    return elements[(cols * row) + col];
}

matrix& matrix::operator+=(const matrix& other)
{
    if ((rows != other.rows) or (cols != other.cols))
        throw incompatible_sizes_add;
    for (size_t i = 0; i < rows * cols; ++i)
        elements[i] += other.elements[i];
    return *this;
}

matrix& matrix::operator-=(const matrix& other)
{
    if ((rows != other.rows) or (cols != other.cols))
        throw incompatible_sizes_add;
    for (size_t i = 0; i < rows * cols; ++i)
        elements[i] -= other.elements[i];
    return *this;
}

matrix& matrix::operator*=(const double scalar)
{
    for (size_t i = 0; i < rows * cols; ++i)
        elements[i] *= scalar;
    return *this;
}

ostream& operator<<(ostream& out, const matrix& mat)
{
    for (size_t i = 0; i < mat.get_rows(); ++i)
    {
        out << "( ";
        for (size_t j = 0; j < mat.get_cols(); ++j)
            out << mat(i, j) << '\t';
        out << ")\n";
    }
    return out;
}

bool operator==(const matrix& lhs, const matrix& rhs)
{
    if ((lhs.get_rows() != rhs.get_rows()) or (lhs.get_cols() != rhs.get_cols()))
        return false;
    for (size_t i = 0; i < lhs.get_rows(); ++i)
        for (size_t j = 0; j < lhs.get_cols(); ++j)
            if (lhs(i, j) != rhs(i, j))
                return false;
    return true;
}

bool operator!=(const matrix& lhs, const matrix& rhs)
{
    return !(lhs == rhs);
}

matrix operator+(matrix lhs, const matrix& rhs)
{
    lhs += rhs;
    return lhs;
}

matrix operator-(matrix mat)
{
    for (size_t i = 0; i < mat.get_rows(); ++i)
        for (size_t j = 0; j < mat.get_cols(); ++j)
            mat(i, j) = -mat(i, j);
    return mat;
}

matrix operator-(matrix lhs, const matrix& rhs)
{
    lhs -= rhs;
    return lhs;
}

matrix operator*(const matrix& lhs, const matrix& rhs)
{
    if (lhs.get_cols() != rhs.get_rows())
        throw matrix::incompatible_sizes_multiply;
    matrix c(lhs.get_rows(), rhs.get_cols());
    for (size_t i = 0; i < lhs.get_rows(); ++i)
        for (size_t j = 0; j < rhs.get_cols(); ++j)
            for (size_t k = 0; k < lhs.get_cols(); ++k)
                c(i, j) += lhs(i, k) * rhs(k, j);
    return c;
}

matrix operator*(matrix lhs, const double rhs)
{
    lhs *= rhs;
    return lhs;
}

matrix operator*(const double lhs, matrix rhs)
{
    rhs *= lhs;
    return rhs;
}

Sample main.cpp:

#include "matrix.hpp"
#include <exception>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    try
    {
        // Constructor with two integers: create a 3x4 matrix of zeros.
        matrix A(3, 4);
        cout << "A:\n" << A;
        // Constructor with one vector: create a 3x3 matrix with 1, 2, 3 on the diagonal.
        matrix B(vector<double>{1, 2, 3});
        cout << "B:\n" << B;
        // Constructor with one initializer_list: create a 4x4 matrix with 1, 2, 3, 4 on the diagonal.
        matrix C{1, 2, 3, 4};
        cout << "C:\n" << C;
        // Constructor with two integers and one vector: create a 2x3 matrix with the given elements in row-major order.
        matrix D(2, 3, vector<double>{1, 2, 3, 4, 5, 6});
        cout << "D:\n" << D;
        // Constructor with two integers and one initializer_list: create a 2x2 matrix with the given elements in row-major order.
        matrix E(2, 2, {1, 2, 3, 4});
        cout << "E:\n" << E;

        // Demonstration of some of the overloaded operators.
        D(0, 2) = 7;
        cout << "D after D(0, 2) = 7:\n" << D;
        matrix F = D * B;
        cout << "F = D * B:\n" << F;
        cout << "D + F:\n" << D + F;
        cout << "7 * B:\n" << 7 * B;
        matrix G(3, 3, {1, 0, 0, 0, 2, 0, 0, 0, 3});
        cout << "B == G: " << (B == G) << '\n';
        cout << "B == F: " << (B == F) << '\n';
        D *= 2;
        cout << "D after D *= 2:\n" << D;
        cout << "D * 3:\n" << D * 3;
        cout << "4 * D:\n" << 4 * D;

        // initializer_list constructor will be used: create a 2x2 diagonal matrix with 1, 2 on the diagonal.
        cout << "matrix{1, 2}:\n";
        cout << matrix{1, 2};
        // (size_t, size_t) constructor will be used: create a 1x2 zero matrix.
        cout << "matrix(1, 2):\n";
        cout << matrix(1, 2);

        // Demonstration of range checking; the range of D is 0-1 for rows and 0-2 for columns.
        cout << "Range checking:\n";
        cout << "D.at(0, 0): " << D.at(0, 0) << '\n';
        cout << "D.at(1, 0): " << D.at(1, 0) << '\n';
        cout << "D.at(2, 0): " << D.at(2, 0) << '\n'; // Error: Tried to access an element out of range!
    }
    catch (const exception& e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

Output:

A:
( 0     0       0       0       )
( 0     0       0       0       )
( 0     0       0       0       )
B:
( 1     0       0       )
( 0     2       0       )
( 0     0       3       )
C:
( 1     0       0       0       )
( 0     2       0       0       )
( 0     0       3       0       )
( 0     0       0       4       )
D:
( 1     2       3       )
( 4     5       6       )
E:
( 1     2       )
( 3     4       )
D after D(0, 2) = 7:
( 1     2       7       )
( 4     5       6       )
F = D * B:
( 1     4       21      )
( 4     10      18      )
D + F:
( 2     6       28      )
( 8     15      24      )
7 * B:
( 7     0       0       )
( 0     14      0       )
( 0     0       21      )
B == G: 1
B == F: 0
D after D *= 2:
( 2     4       14      )
( 8     10      12      )
D * 3:
( 6     12      42      )
( 24    30      36      )
4 * D:
( 8     16      56      )
( 32    40      48      )
matrix{1, 2}:
( 1     0       )
( 0     2       )
matrix(1, 2):
( 0     0       )
Range checking:
D.at(0, 0): 2
D.at(1, 0): 8
D.at(2, 0): Error: Tried to access an element out of range!

The two versions of the at() member function access the elements of the vector using its own pre-defined member function at(), which throws the exception std::out_of_range if the element being accessed is out of the range of the vector. We utilize this to indirectly implement range checking for matrix as well.

For the second and fourth constructors, we use initializer_list, which is defined in the header file <initializer_list>. An initializer_list object is simply a list of elements in the format used to initialize a C-style array, i.e. {element0, element1, ...}, with the addition of a few member functions such as size.

When we tell the constructor to take a const initializer_list<double>& as an argument, it will expect to take a list of this form, with the elements being of type double. It will then simply convert that list to a vector<double>, and delegate the construction of the matrix to the appropriate constructor that takes a vector<double> as an argument. Note the syntax for delegating constructors: there is a : followed by the appropriate constructor, followed by {} to indicate that the delegating constructor is an empty function.

Generally, an initializer_list should be used as input whenever you want to quickly create a new matrix with specific elements, since the syntax is shorter and more convenient. A vector should be used as input whenever you want to create a new matrix using elements you previously collected into a vector.

The initializer_list constructor takes precedence over any other constructor. Therefore, matrix{1, 2} will be a diagonal matrix with 1 and 2 on the diagonal, since the constructor matrix(const initializer_list<double>&) will be used, while matrix(1, 2) will be a 1x2 zero matrix, since the constructor matrix(const size_t, const size_t) will be used. This is illustrated at the end of the sample main.cpp.

For convenience, we defined some ready-made exceptions (all of type invalid_argument) as inline static elements of the matrix class. This also allows the user to know which exceptions to expect the class to throw. Recall that static means they are stored only once in the class itself, and not in individual objects, so this doesn't cause any waste of space. Also recall that inline simply means we can initialize the static element within the class definition.

Since matrix throws two types of exceptions, out_of_range and invalid_argument, we wrote catch (const exception& e) in order to catch any kind of exception (as long as it is derived from the standard exception class). We will explain how exactly this works later.

5.3 Input and output stream classes ^

5.3.1 Formatting output

In C++, you can still use printf if you want; it's in the header <cstdio>. However, using stream objects such as cout allows much more flexibility, especially because you do not have to worry about format placeholders matching the precise type of the argument. For example, to print an integer using printf you would need to specify %d if it's signed or %u if it's unsigned, and add l or ll according to its bit width. It is much easier to just insert it into cout with <<.

To format output when using cout and other streams, we can use the following member functions:

• precision(n) sets the maximum number of digits displayed for a floating point number, counting both the digits before and after the decimal point. precision() returns the current precision.
• width(n) sets the character width of the next output, padding with spaces if necessary. Note that it only works for one output, so it needs to be called every time you want to print a number with the desired width. width() returns the current width.

In addition, streams can be formatted using manipulators. These are simply objects that you insert into the stream with the usual << operator, which modify how the stream works for any subsequent objects inserted into it. Some useful manipulators include:

• boolalpha: Displays Boolean true and false values as text. noboolalpha returns the stream to the default setting, which displays true as 1 and false as 0.
• showpos: Displays the + sign on positive numbers. noshowpos returns the stream to the default setting, which only displays the - sign on negative numbers, with no sign for positive numbers.
• hex: Displays numbers in hexadecimal. dec returns the stream to the default setting, which displays numbers in decimal.
• fixed: Displays floating point numbers with a fixed number of digits as given by precision, adding zeros after the decimal if necessary. defaultfloat returns the stream to the default setting, which does not add zeros.
• scientific: Displays floating point numbers in scientific notation. defaultfloat returns the stream to the default setting.
• showpoint: Displays the decimal point for all floating point numbers, including whole numbers. It also adds trailing zeros to all numbers up to the number of digits given by precision. noshowpoint returns the stream to the default setting.
• uppercase: Displays the letters in hexadecimal numbers and scientific notation in uppercase. nouppercase returns the stream to the default setting, which displays these letters in lowercase.
• left: Adjusts the output to the left. right returns the stream to the default setting, which adjusts to the right. Used in conjunction with width.

The following program demonstrates formatting with streams:

#include <iostream>
using namespace std;

int main()
{
    cout << true << '\n' // 1
         << boolalpha
         << true << '\n' // true
         << noboolalpha << '\n';

    cout << 2 << ", " << -2 << '\n' // 2, -2
         << showpos
         << 2 << ", " << -2 << '\n' // +2, -2
         << noshowpos << '\n';

    cout << 2.0 << ", " << 2.1 << '\n' // 2, 2.1
         << showpoint
         << 2.0 << ", " << 2.1 << '\n' // 2.00000, 2.10000
         << noshowpoint << '\n';

    cout << 1234.56 << '\n' // 1234.56
         << fixed
         << 1234.56 << '\n' // 1234.560000
         << scientific
         << 1234.56 << '\n' // 1.234560e+03
         << uppercase
         << 1234.56 << '\n' // 1.234560E+03
         << nouppercase << defaultfloat << '\n';

    cout.precision(5);
    cout << 1.23456789 << '\n'; // 1.2346
    cout.precision(10);
    cout << 1.23456789 << '\n'; // 1.23456789
    cout.precision(20);
    cout << 1.23456789 << '\n'; // 1.2345678899999998901
    cout.precision(6);
    cout << '\n';

    cout << 255 << '\n' // 255
         << hex
         << 255 << '\n' // ff
         << uppercase
         << 255 << '\n' // FF
         << nouppercase << dec << '\n';

    cout << "| ";
    cout << 123 << " |" << '\n'; // | 123 |
    cout << "| ";
    cout.width(10);
    cout << 123 << " |" << '\n'; // |        123 |
    cout << "| ";
    cout << left;
    cout.width(10);
    cout << 123 << " |" << '\n' // | 123        |
         << right << '\n';
}

Note that the member function precision and width can be replaced with the manipulators setprecision and setw respectively, but only if you include the header file <iomanip>. This is especially useful for setting the width, since it allows you to do everything in one line. Here is an example:

#include <iomanip>
#include <iostream>
using namespace std;

int main()
{
    cout << setprecision(5)
         << 1.23456789 << '\n' // 1.2346
         << setprecision(10)
         << 1.23456789 << '\n' // 1.23456789
         << setprecision(20)
         << 1.23456789 << '\n' // 1.2345678899999998901
         << '\n';

    cout << "| " << 123 << " |" << '\n'                      // | 123 |
         << "| " << setw(10) << 123 << " |" << '\n'          // |        123 |
         << "| " << left << setw(10) << 123 << " |" << '\n'; // | 123        |
}

Finally, note that these manipulators also work for input; for example, sending hex into cin will instruct it to expect numbers to be input in hexadecimal.

5.3.2 I/O streams and files ^

In general, any type of input and output in C++ is done using streams. We have seen above that cout belongs to the class ostream (output stream). Similarly, cin belongs to the class istream (input stream). Both are defined in the header file <iostream>.

File input and output in C++ is also handled using streams: input using ifstream (input file stream), output using ofstream (output file stream), or both input and output using fstream. These are defined in the header file <fstream>.

To open a file, we create an object of the desired type and initialize it with the file name. For example:

ifstream input("input.txt");

or:

ofstream output("output.txt");

We can check if the file was opened correctly using the member function is_open():

ifstream input("input.txt");
if (!input.is_open())
    cout << "Error opening file!";

When the object goes out of scope, its destructor closes the file automatically. However, it is a good programming practice to close files manually nonetheless, using the member function close, e.g. input.close().

Once we opened a file as a stream, we can read and write to it using the << and >> operators, just as for cout and cin. For example:

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main()
{
    ifstream input("main.cpp");
    if (!input.is_open())
    {
        cout << "Error opening input file!";
        return -1;
    }

    ofstream output("out.txt");
    if (!output.is_open())
    {
        cout << "Error opening output file!";
        return -1;
    }

    string s;
    while (input >> s)
        output << s << '\n';

    output.close();
    input.close();
}

Note that in the while loop, input >> s will be false when we input something that is not a string, but that will only happen when we reach the end of the file, since anything can be a string. If the name of the source file for this program is main.cpp, then the file out.txt will contain the following output:

#include
<fstream>
#include
<iostream>
(etc...)

The reason is that strings are expected to be separated by whitespace characters, which include spaces, tabs, and newlines, so #include and <fstream> in the line #include <fstream> are actually considered to be separate strings. We can fix that in one of two ways:

1. Read individual characters using get.
2. Read individual lines using getline.

Here is a program that uses get (we now output to the terminal instead of a file, for simplicity):

#include <fstream>
#include <iostream>
using namespace std;

int main()
{
    ifstream input("main.cpp");
    if (!input.is_open())
    {
        cout << "Error opening file!";
        return -1;
    }

    char c;
    while (input.get(c))
        cout << c;

    input.close();
}

Note that you can't just write input >> c (as you would for the cin stream), because the >> operator reads formatted input, so it will automatically skip whitespace characters. Therefore, for example, #include <fstream> will become #include<fstream>. On the other hand, get reads unformatted input, so it treats all characters the same, including whitespace. We can similarly use put to put just one character to an output stream.

Using getline as a member function of an ifstream object is not recommended, since we have to specify a maximum number of characters to read, and then store them in an old-fashioned C-style string, i.e. an array of chars. That is, we need to replace the read loop by something like

char s[100];
while (input.getline(s, 100)) // Limited to reading strings of up to 100 characters!
    cout << s << '\n';

The problem is that if a line happens to have more than 100 characters, then getline will not read the entire line. This is a problem that we would have had to deal with in C; luckily, in C++ we have the modern string class, which makes everything much easier!

Instead of using getline as a member function of the class ifstream, we can use a different getline that is defined in the <string> header file. This function takes a stream as its first argument, and a string as its second argument. Here is the full code:

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main()
{
    ifstream input("main.cpp");
    if (!input.is_open())
    {
        cout << "Error opening file!";
        return -1;
    }

    string s;
    while (getline(input, s))
        cout << s << '\n';

    input.close();
}

5.3.3 File stream modes ^

The following modes can be specified as the second argument in the initialization list of a file stream:

• ios::in: Read.
• ios::out: Write.
• ios::app: Append.
• ios::ate: At end; opens the file and then seeks to the end of the file.
  • The difference between ios::app and ios::ate is that ios::app only allows you to write at the end of the file, while ios::ate allows you to seek to an earlier position; see below.
• ios::binary: Binary mode; see below.
• ios::trunc: Truncate the file to zero length.

These modes can be combined with the | (bitwise or) operator. For example, ios::in | ios::out indicates opening for both reading and writing.

• The default mode for ifstream is ios::in.
• The default mode for ofstream is ios::out | ios::trunc.
• The default mode for fstream is ios::in | ios::out.

The following program illustrates overwriting, truncating, and appending to a file:

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main()
{
    string filename = "out.txt";

    // ofstream default mode: Existing file contents will be overwritten and truncated (i.e. destroyed).
    ofstream output(filename);
    if (!output.is_open())
    {
        cout << "Error opening file " << filename << "!\n";
        return -1;
    }
    output << "12345";
    output.close();

    // ofstream with ios::app: Appends to what we wrote previously, without overwriting or truncating.
    // Note that the member function open() can be used to open another file with the same stream object.
    output.open(filename, ios::app);
    output << "67890";
    output.close();

    // fstream default mode: Existing file contents will be overwritten but NOT truncated.
    fstream inout(filename);
    if (!inout.is_open())
    {
        cout << "Error opening file " << filename << "!\n";
        return -1;
    }
    // The characters "123" will be overwritten, but the rest will remain untouched.
    inout << "ABC";
    inout.close();

    ifstream input(filename);
    if (!input.is_open())
    {
        cout << "Error opening file " << filename << "!\n";
        return -1;
    }
    string s;
    input >> s;
    cout << s; // Prints "ABC4567890"
    input.close();
}

5.3.4 Seeking ^

To seek to a different position in the file, we can use the member functions seekg (seek get) for input files or seekp (seek put) for output files. The syntax is:

file.seekg(offset, direction);

And similarly for seekp. direction specifies where the offset is calculated with respect to:

• ios::beg: The offset is the position relative to the beginning of the file. This is the default.
• ios::cur: The offset is the position relative to the current position.
• ios::end: The offset is the position relative to the end of the file.

Here is an example:

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

void print_current_char(ifstream &input)
{
    char c;
    input.get(c);
    cout << c;
}

int main()
{
    ifstream input("input.txt"); // Contents of input file: 1234567890ABCDEFGHIJ
    if (!input.is_open())
    {
        cout << "Error opening file!";
        return -1;
    }

    print_current_char(input); // Prints "1"
    print_current_char(input); // Prints "2"

    input.seekg(0);            // Seeks to the beginning of the file
    print_current_char(input); // Prints "1" again

    input.seekg(10);           // Seeks to position 10 from the beginning of the file
                               // Equivalent to input.seekg(10, ios::beg);
    print_current_char(input); // Prints "A"

    input.seekg(5, ios::cur);  // Seeks 5 characters ahead of the current position
    print_current_char(input); // Prints "G"

    input.seekg(-2, ios::end); // Seeks to 2 characters before the end of the file
    print_current_char(input); // Prints "I"

    input.close();
}

For ofstream we would use seekp instead. If a file is opened for both input and output with fstream, you can use either one.

5.3.5 String streams ^

We have seen two types of streams so far: the terminal or "standard" input/output (istream, ostream) and files (ifstream, ofstream). A string stream is a stream that allows you to read or write into a string stored in memory the same way you do with any other stream. String streams are defined in the header file <sstream> and correspond to the types istringstream for input, ostringstream for output, and stringstream for both input and output.

Essentially, you use string streams whenever you want to take advantage of the functionality of a stream. For example, streams have well-defined input >> and output << operators, and these operators work on string streams as well, which means we can use a string stream to write formatted data into a string. The actual string can then be accessed using the member function str. This is illustrated in the following program:

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main()
{
    ostringstream out;
    out << "Here are some numbers: " << 0.5 << ", " << 7 << ", " << hex << 255 << '\n';
    string s = out.str();
    cout << s; // Prints "Here are some numbers: 0.5, 7, ff"
}

This is especially convenient when we want to first process all the data in memory, and then output it all at once, either to the terminal or to a file.

Another convenient usage of string streams is for converting a list of numbers separated by spaces into a vector:

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

ostream &operator<<(ostream &out, const vector<double> &v)
{
    out << '(';
    for (uint64_t i = 0; i < v.size() - 1; i++)
        out << v[i] << ", ";
    out << v[v.size() - 1] << ')';
    return out;
}

vector<double> read_numbers(const string &in)
{
    vector<double> v;
    string s;
    istringstream string_stream(in);
    try
    {
        while (getline(string_stream, s, ' '))
            v.push_back(stod(s));
    }
    catch (const invalid_argument &e)
    {
        throw invalid_argument("Expected a number!");
    }
    catch (const out_of_range &e)
    {
        throw out_of_range("Number is out of range!");
    }
    return v;
}

int main()
{
    try
    {
        cout << read_numbers("1 5.7 3.2 18.99"); // Prints "(1, 5.7, 3.2, 18.99)"
    }
    catch (const exception &e)
    {
        cout << "Error: " << e.what() << '\n';
    }
}

The operator<< overload for vectors is the same one we used above. In the function read_numbers(), we used the fact that getline takes a delimiter character as its third argument; by default this argument is '\n', so it reads until it reaches the end of the line, but if we replace it with ' ' it will instead read until it reaches a space character. We loop on each substring read in this way until the end of the string stream is reached, and we convert each substring into a double with the function stod (string to double).

Of course, we need to validate the input string, as it may not be of the appropriate form. According to the C++ reference, stod can throw two exceptions: invalid_argument if it encountered something other than a number, or out_of_range if the value of out of the range of the double data type (as we found above, the range is roughly between 2.2e-308 and 1.8e+308).

We could catch these exceptions directly, but the problem is that the error messages obtained by what() are not very illuminating (on my computer the error is simply "stod".) Therefore, we catch these exceptions inside read_numbers(), and then throw the same exceptions with more informative error messages. You can test this by putting some letters inside the string (which will throw invalid_argument), or a large number such as 1e500 (which will throw out_of_range).

5.3.6 Buffered output ^

The computer's memory is usually much faster than any hard drives. Therefore, the data that is written to a file stream by the program will sometimes be automatically stored in a memory buffer before it is actually written to the disk. It is possible that data from many different write operations will be kept in the buffer. At some point the data will finally be written to the file, all at once. This is called flushing the buffer.

Although using a buffer improves performance, it also means that if the program crashes, the crash could happen before the buffer is flushed. In this case, the data that was supposed to be written to the file (including the results of your very complicated 20-hour calculation!) may be lost.

The buffer can be flushed manually, either by sending the manipulator flush to the output stream or by using the member function flush(). In addition, the manipulator endl can be used to send a newline character \n and then flush the buffer. However, endl should not be used every time you want to send a newline character; if you flush the buffer after every single line you write to the output stream, the program may run slower due to continuously accessing the disk. It's better to just use \n and, if desired, flush the buffer manually using flush.

Generally, you should let the buffer be flushed automatically to ensure maximum performance. However, to prevent data loss, it is a good idea to flush the buffer manually after writing important data such as the result of a long calculation.

5.3.7 I/O error handling ^

One example of an I/O error that you may encounter happens when your program expects to read data of one type, but gets another type instead. This is especially common when getting input from the user via the terminal. For example, the user may misunderstand the instructions and write letters when asked for a number.

However, as I stressed before, you should generally not get input from the terminal when you are doing scientific programming. All the input should be taken from files and/or from command line arguments, for two reasons:

1. If your program does calculations that take hours or even days, you can't expect the user to sit by the computer for the entire run time of the program in order to input data.
2. Your program will often be executed multiple times with different data each time. This can be automated using a script, but only if the program takes its data from a file; again, you can't expect the user to manually input different data each time the program runs.

However, even when reading data from a file, it is possible that the file will not be formatted correctly, especially if the file was manually written by the user (rather than being automatically generated by another program). C++ provides error handling for streams using the following member functions:

• good returns true if everything is okay.
• bad returns true if a fatal error has occurred. This includes, for example, the file no longer being accessible.
• fail returns true if a non-fatal error has occurred. This includes, for example, finding a letter when expecting a number. Note that bad implies fail, but not the other way around.
• eof returns true if the end of the file has been reached.
• clear restores to stream to a good state once the error has been handled by the program.

Here is an example of simple error checking:

#include <fstream>
#include <iostream>
using namespace std;

int main()
{
    ifstream input("input.txt");
    if (!input.is_open())
    {
        cout << "Error opening file!";
        return -1;
    }

    double n = 0;
    while (input >> n)
        cout << "Found a number: " << n << ".\n";

    if (input.eof())
        cout << "Reached end of file.\n";
    else if (input.fail())
        cout << "Encountered input that was not a number.\n";
}

If the file input.txt only contains numbers (separated by spaces or newlines), these numbers will be displayed on the screen until the input reaches the end of the file, in which case input.eof() will be true. However, if input.txt contains something that is not a number at some point, the while loop will terminate prematurely, and input.fail() will be true.

In addition, the C++ standard library offers the following character classification functions in the header file <cctype>, which return true if the input argument is a character of the indicated type:

• islower(): Lowercase letters abcdefghijklmnopqrstuvwxyz.
• isupper(): Uppercase letters ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• isdigit(): Digits 0123456789.
• isxdigit(): Hexadecimal digits 0123456789abcdefABCDEF.
• ispunct(): Punctuation characters !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~.
• isalpha(): Alphabet characters, which includes lowercase letters and uppercase letters.
• isalnum(): Alphanumeric characters, which includes lowercase letters, uppercase letters, and digits.
• isprint(): Any printable character, which includes lowercase letters, uppercase letters, digits, punctuation characters, and space ' '.
• isspace(): Whitespace characters, which includes space ' ', form feed '\f', new line '\n', carriage return '\r', horizontal tab '\t', and vertical tab '\v'.

As a side note, the same header file also provides the functions tolower() to convert a character to lowercase and toupper() to convert a character to uppercase.

Here is an example of a program that checks whether its input is a word (i.e. only composed of letters) or not:

#include <fstream>
#include <iostream>
#include <cctype>
#include <string>
using namespace std;

bool is_word(const string &s)
{
    for (const char &c : s)
        if (!isalpha(c))
            return false;
    return true;
}

int main()
{
    ifstream input("input.txt");
    if (!input.is_open())
    {
        cout << "Error opening file!";
        return -1;
    }

    string s;
    while (input >> s)
        if (is_word(s))
            cout << "Found a word: " << s << ".\n";
        else
            cout << "Not a word: " << s << ".\n";
}

So, what should your program do if invalid input was supplied by the user? In scientific programming, usually the best thing to do is to notify the user that the input is invalid, and then just terminate the program. Your program shouldn't try to guess what the user meant and fix their mistakes for them (like Google fixing your typos in searches), because that may lead to running the program with the wrong input. Scientific data analysis and calculations can sometimes run for days at a time, and you don't want to do that only to find out in the end that the user actually wanted to do something else.

5.3.8 Reading and writing binary files ^

Essentially, the only difference between binary mode ios::binary (see above) and the default file I/O mode, or text mode, is that binary mode treats all characters equally, while text mode treats newline characters (and only newline characters) in an OS-specific way, so if you write \n (newline) to a file, the program may actually end up writing \r (carriage return) or \r\n, depending on the operating system. This is the only difference as far as the C++ file stream modes are concerned.

Apart from that, there is a more fundamental difference in the way data is stored inside a file, which has nothing to do with ios::binary. Files are composed of bytes, which have 8 bits each. Each character in a string usually takes up one byte (it can take more than that if you are using wide character formats, which would happen, for example, if you use Unicode characters). The number of bytes taken up by other data types is equal to the bit width of the type, so for example, int32_t will take up 4 bytes while int64_t will take up 8 bytes.

When you write the 32-bit integer 1 as text, it will take up only 1 byte, because you just need to write the character 1. However, if you write it as binary, it will take up 4 bytes. On the other hand, the 32-bit integer 1234567890 will take up 10 bytes as text, one byte for each of the digits, but still only 4 bytes as binary.

Many file formats, such as image (e.g. PNG), audio (e.g. MP3), video (e.g. MP4), and so on, are binary formats. Such files have the benefit of being smaller in size, but they are not readable by humans. In scientific computing, we generally want files to be human-readable, so it is recommended to never use binary formats unless you really have to.

Generating large files is usually not a problem, since files can be easily compressed, for example using ZIP. (Of course, the ZIP file itself will be a binary file.) Furthermore, all modern operating systems can be configured to automatically store files in compressed format "behind the scenes", so that the file is human-readable when it is opened by any program, but actually takes up much less space on the disk.

If you want to get input from a specific type of binary file, then there are open-source C++ libraries that you can #include in your program and will take care of reading the file for you; you can easily find such libraries online. Generally, you don't need to write your own code to handle binary files, unless you are dealing with a binary format for which a C++ library does not already exist, or you want low-level access to the contents of the file.

As an example, let us consider how we might read and write a vector<double> to and from a file. C++ doesn't provide that functionality on its own, so we have to do it ourselves. We will first do this in text format, and then in binary format.

If we want to read and write vectors in human-readable format (which, again, is the preferred way in scientific programming!), then we can simply overload << and >> with the appropriate behavior:

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

ostream &operator<<(ostream &out, const vector<double> &v)
{
    for (const double &i : v)
        out << i << ' ';
    out << '\n';
    return out;
}

istream &operator>>(istream &in, vector<double> &v)
{
    string line, s;
    getline(in, line);
    istringstream st_stream(line);
    while (getline(st_stream, s, ' '))
        v.push_back(stod(s));
    return in;
}

int main()
{
    vector<double> v = {1.2, 3.4, 5.6, 7.8, 9.0};
    vector<double> w = {3, 5, 7, 9};
    cout << "v: " << v
         << "w: " << w;

    string filename = "vectors.txt";
    ofstream output(filename);
    if (!output.is_open())
    {
        cout << "Error opening file " << filename << " for output!";
        return -1;
    }
    output << v;
    output << w;
    output.close();

    vector<double> a, b;

    ifstream input(filename);
    if (!input.is_open())
    {
        cout << "Error opening file " << filename << " for input!";
        return -1;
    }
    input >> a;
    input >> b;
    input.close();

    cout << "a: " << a
         << "b: " << b;
}

Input and output of binary files in C++ is somewhat awkward. Here is one way to do it for vector<double>:

#include <fstream>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

ostream &operator<<(ostream &out, const vector<double> &v)
{
    for (const double &i : v)
        out << i << ' ';
    out << '\n';
    return out;
}

void write_binary_vector(ofstream &out, const vector<double> &v)
{
    uint64_t s = v.size();
    out.write(static_cast<char *>((void *)&s), sizeof(uint64_t));
    for (const double &i : v)
        out.write(static_cast<char *>((void *)&i), sizeof(double));
}

vector<double> read_binary_vector(ifstream &in)
{
    uint64_t s = 0;
    in.read(static_cast<char *>((void *)&s), sizeof(uint64_t));
    vector<double> v(s);
    for (uint64_t i = 0; i < s; i++)
        in.read(static_cast<char *>((void *)&v[i]), sizeof(double));
    return v;
}

int main()
{
    vector<double> v = {1.2, 3.4, 5.6, 7.8, 9.0};
    vector<double> w = {3, 5, 7, 9};
    cout << "v: " << v
         << "w: " << w;

    string filename = "vectors.bin";
    ofstream output(filename, ios::binary);
    if (!output.is_open())
    {
        cout << "Error opening file " << filename << " for output!";
        return -1;
    }
    write_binary_vector(output, v);
    write_binary_vector(output, w);
    output.close();

    vector<double> a, b;
    ifstream input(filename, ios::binary);
    if (!input.is_open())
    {
        cout << "Error opening file " << filename << " for input!";
        return -1;
    }
    a = read_binary_vector(input);
    b = read_binary_vector(input);
    input.close();

    cout << "a: " << a
         << "b: " << b;
}

In this program, we are using the fstream member functions read() and write() to read and write binary data. They take two arguments: the first is a pointer to a C-style string, i.e. an array of chars, and the second is the length of the string, i.e. the number of bytes it takes up in memory. They then read or write from the string into the file or vice versa.

Here we are using a trick: instead of the first argument being a pointer to a string, we give a pointer to the raw data we want to write, which we cast to look like a pointer to a string using static_cast. The syntax static_cast<new_type> expression casts expression into the data type new_type. So in the statement