Standard Library Math Functions

Separate compilation divides code into files that are compiled independently, so user code can depend on an interface rather than an implementation. This article looks at the user side of that arrangement: a file that wants to use a class and some standard library functions, but does not contain the class's implementation. The example file is short, but it draws its names from three different places: a file written by someone else (Vector.h), a standard library header (cmath), and the std namespace that the standard library uses.

Before reading further, think about the file as a reader would. The function sqrt_sum needs to know what a Vector is and how to ask it for its size and its elements. It also calls sqrt. Which of the three include and using lines is responsible for each of those needs? And does the file need the code that implements Vector in order to be written and compiled, or does it only need something smaller? The rest of this article answers those questions by tracing the names in the file.

The body of sqrt_sum shows a standard library function used in ordinary code. The line sum += sqrt(v[i]); takes each element of the vector, computes its square root, and adds it to a running total. The source comment describes the loop as computing the sum of square roots. Written as a formula, the function returns the sum of the square roots of the elements, where $v_i$ stands for the element at index $i$ and $\sqrt{v_i}$ is its square root.

This fragment is an illustrative reconstruction of the lines the source quotes, not the full file. Notice that the function body combines three kinds of names: the size call and indexing operation belong to Vector, and sqrt belongs to the math library. Each one traces back to a specific line at the top of the file.

The first line of user.cpp, #include "Vector.h", is the link between the user file and the class. The source comment explains its purpose: it gets Vector's interface. The interface is the part of the class that other code is allowed to see and use. It tells the compiler what a Vector is and what operations exist on it, such as the size() call and the indexing operation v[i]. The user file does not need to see how those operations are carried out.

The implementation lives in a separate file, Vector.cpp, which is compiled on its own. The user file is compiled separately as well. A linker then combines the compiled pieces into one working program. The compiler reads user.cpp and reads the interface in Vector.h; the linker is what joins the separately compiled Vector implementation to the user's code.

This is why the design is useful. The file that uses Vector can be written, read, and compiled on its own. Its author depends on what the interface promises, not on the details inside it. If the implementation changes but the interface stays the same, the user file does not need to be rewritten.

A #include line copies the declarations from a header into the file that contains the line. The example uses two headers, and the Vector interface and the math library are included in different forms. The Vector interface is included as #include "Vector.h", with quotation marks. The math library is included as #include <cmath>, with angle brackets. The source does not explain the difference between these two forms, so this article only states what the example uses: Vector.h provides the Vector interface, and cmath provides the interface to the standard library math functions, including sqrt().

The include lines are therefore the first place to look when a name is unfamiliar. A name that comes from Vector.h is a member of the Vector interface, and a name that comes from cmath is a math library function. Neither include line by itself makes the names of the other file visible.

The line using namespace std; is a directive that makes the members of the std namespace visible in the file. The source comment states this purpose and points to a section of the text (§3.3) for more detail. Without this line, a standard library name such as sqrt would not be visible under its plain name. The same function can still be reached by writing the qualified name std::sqrt, which is the form that makes the namespace explicit at each use.

When you trace user code, read it from the top and record the first line where each name becomes known. A name can be used only after the line that introduces it, so the top of the file tells you what the rest of the file is allowed to refer to.