Namespaces, Includes, and the Standard Library

This lesson is a quick introductory tour of functions within C++. It is not intended for those who are entirely new to programming. Rather, the people who may find it useful include:

• those who have completed our introductory course, but want a quick review
• those who are already familiar with programming in another language, but new to C++
• those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course. Anyone looking for more thorough explanations or additional context should consider Chapters 7 and 8 of that course.

Previous Course

Intro to Programming with C++

Starting from the fundamentals, become a C++ software engineer, step by step.

View Course

The #include Directive

The most typical way we import code defined in another file is through an #include directive:

1// Same Directory
2#include "math.cpp"
3
4// Child Directory
5#include "some-subfolder/math.cpp"
6
7// Parent Directory
8#include "../math.cpp"
9

The include directive performs a crude copy-and-paste operation on our code before it is compiled. Because of this, we can just use included code as if it were in the same file we’re working on:

1// math.cpp
2int add(int x, int y) {
3  return x + y;
4}
5

1// main.cpp
2#include "math.cpp"
3
4int main() {
5  Add(x+y);
6}
7

In a project with a more complicated web of include directives, this recursive copy-and-paste process is liable to attempt to include the same file twice:

1// geometry.cpp
2float Pi{3.14f};
3

1// math.cpp
2#include "geometry.cpp"
3

1// main.cpp
2#include "math.cpp"
3#include "geometry.cpp"
4

After resolving all the #include directives, main.cpp is including geometry.cpp and then indirectly including it again through math.cpp

This will result in a compilation error because we’re now defining a variable called Pi twice. To solve this, for any file that is intended to be included in other files, we should add the #pragma once directive to ensure it never gets included more than once:

1// geometry.cpp
2#pragma once
3
4float Pi{3.14f};
5

1// math.cpp
2#pragma once
3
4#include "geometry.cpp"
5

Namespaces

Namespaces are the primary way to organize code in large applications

1namespace Math {
2  int Add(int x, int y) {
3    return x + y;
4  }
5
6  // Namespaces can be nested
7  namespace Geometry {
8    float Pi{3.14f};
9  }
10}
11

Scope Resolution Operator ::

Access to namespaces, and different scopes in general, can be done using the scope resolution operator ::

1int Result{ Math::Add(1, 2)};
2float HalfPi{Math::Geometry::Pi / 2};
3

The Standard Library

C++ comes with a large standard library, which contains a large number of generally useful code. Standard library functionality is typically included using < and > as part of an #include directive.

One of the most common standard library features we will want is the ability to create strings:

1// The standard library's string implementation
2#include <string>
3

Strings, and most standard library types and functionality are available within the std namespace:

1#include <string>
2
3int main() {
4  std::string Greeting{"Hello"};
5}
6

std::cout

By including <iostream> we get access to some useful input and output functionality.

1// Ways to interact with input and output
2#include <iostream>
3

The std::cout object allows us to stream content to our terminal using the << operator, thereby letting us see program output:

1#include <string>
2#include <iostream>
3
4int main() {
5  std::string Greeting{"Hello"};
6  std::cout << Greeting;
7}
8

This program yields the following output:

1Hello
2

The << operator returns the reference to std::cout, so we can keep streaming content to it as a larger expression:

1#include <string>
2#include <iostream>
3
4int main() {
5  std::string Greeting{"Hello"};
6
7  // The << operator can be chained
8  std::cout << Greeting << " World";
9}
10

1Hello World
2

We can insert line breaks into our output using the \n sequence, or by streaming a std::endl object:

1#include <iostream>
2
3int main() {
4  std::cout << "After this, there is a break\n";
5  std::cout << "after this too!" << std::endl;
6  std::cout << "This will\nspan two lines";
7}
8

1After this, there is a break
2after this too!
3This will
4span two lines
5

using Statements

When we’re repeatedly going to be using a variable or function from a namespace, it can be helpful to add a using statement. This can be within the global scope, where it will apply to an entire file, or just within the scope of a specific block:

1void MyFunction() {
2  using std::cout, std::endl;
3
4  // In the rest of this function, we can now
5  // use cout and endl without needing to
6  // specify the std:: prefix
7  cout << "This works!" << endl;
8}
9

If we want to refer to a whole namespace without qualification, we can have a using namespace statement:

1void MyFunction() {
2  using namespace std;
3
4  // Now, anything in the std namespace can be
5  // used, without needing prefixed with std::
6  cout << "This works!" << endl;
7}
8

The using namespace statement should generally be restricted, as it bypasses the purpose of having a namespace in the first place. When files get more complex, it can be difficult to determine where functions and variables are coming from if omit namespace qualifiers.

If we do want to have using namespace statements, we should prefer using them just within the specific function we need them, rather than across an entire file.