Basic Elements of C++

Write and compile the following C++ program:

#include <iostream>

int main() {
    std::cout << "Hello world!" << std::endl;
}

It is good to start with examples. Let’s try a non-trivial program:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    int i;
    std::vector<int> A;
    while (std::cin >> i)
	A.push_back(i);

    std::sort(A.begin(), A.end());

    for (std::vector<int>::iterator itr = A.begin(); itr != A.end(); ++itr)
	std::cout << *itr << std::endl;
}

The above code examplifies many features of C++. We will examine many of these features in detail, but let’s just go through the code intuitively. Let’s start with the first three lines:

#include <iostream>
#include <vector>
#include <algorithm>

Including header files works like in C. The same is true for the preprocessor in general. Now, let’s look at the main function. As you can see, that is also similar to C. In fact, its general signature is also similar to C. For example, we could write the following code to print the command-line arguments:

#include <iostream>

int main(int argc, char * argv[]) {
    for (int i = l; i < argc; ++i)
	std::cout << argv[i] << std::endl;
}

Going back to the first example, in the second line of the body of the main function, we find a first truly new feature that distinguishes C++ from C:

std::vector<int> A;

This is a declaration of a vector of int objects. As one can intuitively figure out, a vector is a linear data structure (a sequence) that also supports access by index, just like an ordinary array in C—except that it is dynamic, meaning that it can grow and shrink as needed, as is done two lines down with A.push_back(i). And there is so much more in the declaration and use of this vector. We can not possibly cover those concepts and ideas in this introductory example, but we will return to them later.

Let’s now consider the head of the while loop:

while (std::cin >> i)

Intuitively, this means: read an integer from the standard “console” input stream std::cin and terminate the loop when the read operation fails. However, here too there is a lot to unpack. What is really going on with the right-shift (>>) operator? And how is it possible that the right-shift expression std::cin >> i would store a value into object i?

But let’s continue. After we fill the array with integer values read from the standard input, we call the sort function provided by the standard library:

std::sort(A.begin(), A.end());

As expected, this sorts the vector. Simple! Needless to say, there is a lot to unpack here, too. First, notice that the vector supports the two methods begin() and end(). In fact, C++ supports user-defined types, like vector, in the form of classes that define “objects” in the sense of object-oriented programming. So, a vector is an object that encapsulates some data, and that provides some associated methods. In particular, begin() and end() return a kind of pointer to the beginning and the end of the vector. These are called iterators, and again there is a lot to say about iterators, as we will see later.

The nice thing about this sort implementation, is that it is generic. In fact, a vector is also generic, and this form of generic programming is a fundamental and pervasive feature of C++ and its standard library. We will see about this later, but for now let’s see what it means for sort to be generic through another example. The code below shows how one can use the same sort on, say, an array of float objects:

float X[100];
for (int i = 0; i < 100; ++i)
    std::cin >> X[i];

std::sort(X, X + 100);

Here std::sort works on an array of floating-point numbers. This is a traditional C-style array, that is, a contiguous sequence of float objects in memory. In this case sort takes two pointers: X points to the first element of the array, and X+10 points to the element immediately after the last one. In the previous example, sort(A.begin(),A.end()), takes two user-defined pointer-like “iterators” whose semantics is the same as pointers to the first and one-past-last elements in the vector container, respectively. But still, it’s the same sort!

In fact, it isn’t just sort that is generic here. Notice that std::cin >> X[i] is also the same kind of expression to read a floating-point number as the previous std::cin >> i to read an integer. In C you would use scanf("%d",&i) to read an integer or scanf("%f",&x) to read a floating-point number. So you use the same function scanf but you need to specify whether you want to read an integer or a floating-point number, and you do that with the format strings "%d" or "%f". C++ is more direct, and less redundant and error-prone. The compiler knows that i is an integer, so the expression std::cin >> i reads an integer, similarly X[i] is a floating-point number, so std::cin >> X[i] just does the right thing and reads a floating-point number from the input. And you don’t have to bother adding a format string for any of that.

In the last part of the example, we print out the content of the vector, and by now you should intuitively figure out what is going on with the iteration.

for (std::vector<int>::iterator itr = A.begin(); itr != A.end(); ++itr)
    std::cout << *itr << std::endl;

Some might object that this code is complicated and clunky. Perhaps it is to some, but a good C++ developer would immediately recognize the pattern and would not be bothered by the apparent complexity. Still, if not complex, that is certainly a long instruction for a simple for-loop. But look, you can write the same loop more compactly:

for (auto itr = A.begin(); itr != A.end(); ++itr)
    std::cout << *itr << std::endl;

Or even more simply:

for (auto a : A)
    std::cout << a << std::endl;

In the same spirit of starting with intuitions, we list here a few differences between C and C++.

A reference is an alias to an existing object.

int i = 1;
int & ref = i;			// reference initialization

The code above declares ref as an alias of object i. Notice that the reference is not itself an object. In fact, in this case the compiler might implement the reference without allocating any memory, conceptually replacing every use of ref with i. Sometimes the compiler might need to store a reference, in which case the underlying implementation will probably consist of a pointer object.

Notice that there is a fundamental difference between the initialization and an assignment of a reference.

int i = 1;
int j = 2;
int & ref = i;			// reference initialization
ref = j;                        // assignment.  Of what object?
j = j + 1;
std::cout << ref << std::endl;

Since a reference is an alias and not an object, every reference must be immediately initialized.

int & ref;			// error: makes no sense

Also, again since a reference is not an object, it makes no sense to declare arrays of references, pointers to references, and references to references.

int i;				// i is the only object here
int & ref = i;			// ref is now an alias of i
int & * p;			// error: makes no sense
int & A[10];			// error: makes no sense
int & & double_ref;		// error: makes no sense

However, even though the reference itself is not an object, as an expression a reference does identify an object—that is, it’s an lvalue. So, among other things, you can take the address of a reference. And you get the address of the object that the reference refers to. Try the following code to see that yourself.

int i;
int & ref = i;
std::cout << "i is here: " << &i << "ref is here: " << &ref << std::endl;

Since references are lvalues (they identify an object), the initialization of a reference must evaluate to an lvalue.

int i;
int & r = i;			// okay
int & s = i + 1;		// Error!

However, the initialization of a const reference—meaning, a reference to a const object—does not have to be an l-value. Do you see why? Consider the following code as an example.

int sum(const int & a, const int & b) {
    return a + b;
}

int main() {
    int i = 7;
    int j = 2;
    std::cout << sum(i, j + 1) << std::endl;
}

We insist that a reference must be initialized with an lvalue, but that is only true for lvalue references, which are the references we have seen so far. There are also rvalue references, but we won’t talk about them here. Instead, let’s talk about using references. References can and are often used as formal function parameters. What is the output of the following program?

void swap(int & a, int & b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int i = 7;
    int j = 2;
    swap(i, j);
    std::cout << "i = " << i << std::endl << "j = " << j << std::endl;
}

One reason to use references is to obtain side-effects, as in the example above. Another reason is to avoid expensive copy operations when we pass complex objects as parameters.

void print_size_slow(vector<int> v) {
  std::cout << v.size() << std::endl;
}

void print_size_fast(vector<int> & v) {
  std::cout << v.size() << std::endl;
}

int main() {
    vector<int> A(1000);	// a vector of 1000 integers (all 0)

    print_size_slow(A);         // makes a copy of the entire vector
    print_size_fast(A);         // operates directly on A
}

In fact, the print functions in the example above do not need to change the input vector, so the best way to define them is as taking a constant reference (const vector<int> &) to the vector.

It is perhaps less intuitive but certainly equally important to return a reference from a function. This way, function calls can be used as lvalue expressions. As an example, consider a simplistic implementation of a matrix:

int M[2000];
int height = 40;
int width = 30;

int & m(int col, int row) {
  return M[col + row*width];
}

int main() {
    for (int i = 0; i < height; ++i)
	for (int j = 0; j < width; ++j)
	    std::cin >> m(i,j); // stores a value into M
    m(0,0) = 1;                 // stores a value into M
}

This feature is even more important in combination with another fundamental feature of C++, namely operator overloading.

C++ provides exceptions as a powerful error-handling mechanism. As in other languages, such as Java, the code that notices an error might raise an exception by throwing an exception object with a throw expression. The exception is then caught by the first matching catch block of a try block that directly or indirectly led to the execution of the throw clause. This means that the control flow goes back up through the execution stack. A matching catch block is one where the catch-clause matches the type of the exception object defined by the throw expression.

#include <iostream>
#include <new>

int * ramp(int n) {
    int * R = new int[n];
    for (int i = 0; i < n; ++i)
	R[i] = i;
    return R;
}

int main() {
    try {
	int * A = ramp(1000000);
	// ...
	delete [](A);
    } catch (const std::bad_alloc& e) {
	std::cout << "Allocation failed: " << e.what() << '\n';
    }
}

The exception object is usually derived from (subtype of) std::exception. However, any value can be thrown as an exception. For example:

#include <string>
#include <iostream>

const char * small_error = "okay";
const char * big_error = "not okay";
const char * nasty_error = "AAAHHhhhh!";

int f(int x) {
    if (x > 7)
	return x - 2;

    switch(x) {
    case 0: throw 10;
    case 1: throw 20;
    case 2: throw small_error;
    case 3: throw big_error;
    default: throw nasty_error;
    }
}

int main() {
    int i;
    std::cout << "Input: ";
    std::cin >> i;
    try {
	std::cout << "Output: " << f(i) << std::endl;
    } catch (int ex) {
	std::cout << "error number " << ex << std::endl;
    } catch (const char * error_msg) {
	std::cout << error_msg << std::endl;
    }
}

An exception specification for a function or method can limit the set of types of exception objects that that function may throw. For example, the function int f(int x) throw(int) defined in the example below may only throw exceptions of type int.

#include <string>
#include <iostream>
#include <exception>

const char * small_error = "okay";
const char * big_error = "not okay";
const char * nasty_error = "AAAHHhhhh!";

void abandon_ship() {
    std::cout << "Mayday mayday mayday!" << std::endl;
}

int f(int x) throw(int) {
    if (x > 7)
	return x - 2;
    switch(x) {
    case 0: throw 10;
    case 1: throw 20;
    case 2: throw small_error;
    case 3: throw big_error;
    default: throw nasty_error;
    }
}

int main() {
    std::set_unexpected(abandon_ship);
    int i;
    std::cout << "Input: ";
    std::cin >> i;
    try {
	std::cout << "Output: " << f(i) << std::endl;
    } catch (int ex) {
	std::cout << "error number " << ex << std::endl;
    } catch (const char * error_msg) {
	std::cout << error_msg << std::endl;
    }
}

By default, a function may throw any exception—except for destructors and other special default member functions, and deallocation functions that are non-throwing by default. You may declare that a function is non-throwing with the noexcept specifier. Destructors are noexcept by default.

#include <string>
#include <iostream>
#include <exception>

const char * small_error = "okay";
const char * big_error = "not okay";
const char * nasty_error = "AAAHHhhhh!";

void abandon_ship() {
    std::cout << "Mayday mayday mayday!" << std::endl;
}

void ciao() noexcept {
    std::cout << "ciao!" << std::endl;
}

void goodbye() {
    std::cout << "goodbye!" << std::endl;
}

int f(int x) throw(int) {
    if (x > 7)
	return x - 2;

    switch(x) {
    case 0: throw 10;
    case 1: throw 20;
    case 2: throw small_error;
    case 3: throw big_error;
    default: throw nasty_error;
    }
}

int main() {
    std::set_unexpected(abandon_ship);

    int i;
    std::cout << "Input: ";
    std::cin >> i;
    try {
	std::cout << "Output: " << f(i) << std::endl;
    } catch (int ex) {
	std::cout << "error number " << ex << std::endl;
    } catch (const char * error_msg) {
	std::cout << error_msg << std::endl;
    }
    try {
	ciao();                        // compiler can ignore the whole try-catch
    } catch (int ex) {
	// because this will never happen
	std::cout << "error number " << ex << std::endl;
    }
    try {
	goodbye();                        // compiler must deal with the try-catch blocks
    } catch (int ex) {
	std::cout << "error number " << ex << std::endl;
    }
}

Notice that the set of allowable exception types is not part of the function type and therefore it is not checked statically but rather dynamically. What this means is that the compiler does not prevent a function to directly or indirectly throw an exception that the function is not supposed to throw. However, if that happens, the function will not actually throw that exception. Instead, the exception causes the invocation of std::unexpected(), which in turn invokes a default or a user-defined handler of dynamic exception violations.

Imagine you are defining a matrix class to represent matrices in a mathematical library. In C you might do that as follows:

struct matrix {
    unsigned int cols;
    unsigned int rows;
    float * values;
};

You might then define and then use an addition operation as follows:

void matrix_add(struct matrix * A, const struct matrix * B) {
    /* computes A += B */
    if (A->cols != B->cols || A->rows != B->rows)
	return A;
    int * a = A->data;
    const int * a = B->data;
    for (unsigned int i = 0; i < A->rows; ++i)
	for (unsigned int j = 0; j < A->cols; ++j)
	    *a++ += *b++;
}

int main() {
    struct matrix A;
    struct matrix B;

    /* ... */
    matrix_add(&A, &B);
}

This solution would be pretty much identical in Java. However, in C++ you can more naturally define an addition operation by defining the += operator. You can do that on the same exact struct matrix defined above:

matrix & operator += (matrix & A, const matrix & B) {
    /* computes A += B and returns A */
    if (A.cols != B.cols || A.rows != B.rows)
	return A;
    int * a = A.data;
    const int * a = B.data;
    for (unsigned int i = 0; i < A.rows; ++i)
	for (unsigned int j = 0; j < A.cols; ++j)
	    *a++ += *b++;
    return A;
}

int main() {
    struct matrix A;
    struct matrix B;

    /* ... */
    A += B;
}

One of the great advantages of C++ over C is the utility of the container library. It is fair to say that the C standard library lacks even basic data structures and algorithms. On the contraty, the standard library of C++ is very rich and also versatile.

Let’s look at some basic library features. The library covers strings.

#include <string>
#include <iostream>

int main() {
    std::string s;
    while (std::cin >> s) {
	std::string::size_type pos = s.find("ciao");
	if (pos == std::string::npos) {
	    std::cout << s << " does not contains the string `ciao'." << std::endl;
	} else {
	    std::cout << s << " contains the string `ciao' at position " << pos << std::endl;
	}
    }
}

As it turns out, strings are a lot like a container of the container library of the C++ standard library. So, let’s look at perhaps the most basic container, namely the vector:

#include <vector>
#include <iostream>

int main() {
    std::vector<int> A;
    int x;

    while (std::cin >> x)
	A.push_back(x);

    std::cout << "I just read " << A.size() << " numbers:" << std::endl;
    for (std::vector<int>::iterator itr = A.begin(); itr != A.end(); ++i)
	std::cout << *itr << std::endl;
}

The vector class defines a generic vector. Generic here means with respect to the type of the elements in the vector, which in this example is int. Thus vector is a template class, just like practically all container classes of the C++ Standard library. We now look a the idea of a template container a bit more closely.

A template is code that is parameterized by a type. Or by two types, or by a value, or, or by a value and a type, or… But let’s keep things simple for now. Here the term “code” refers to class and function definitions. For example, a function template defines a family of functions, each specialized for a specific type. The following code defines a family of functions that returns the size of an array of elements of a given type.

template <typename T>
unsigned int array_size(unsigned int n) {
    return n * sizeof(T);
}

Notice that this definition per-se is what defines the family of functions, but does not in itself define any specific function within that family. The specific functions in the family are defined, implicitly or explicitly, by instantiating the template. For example:

std::cout << array_size<char>(100) << endl;

The compiler can also deduce the type parameter directly from an instantiation. For example:

#include <fstream>
#include <chrono>

template <typename T>
void log_message(const T & x) {
    std::ofstream log_stream("LOG.TXT", std::app);
    log_stream << std::chrono::system_clock::now() << ": " << x << std::endl;
}