String and Character Literals: `''`, `""`, and `""s`

Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


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 are 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.  Those looking for more thorough explanations or additional context should consider completing _**Chapters 7 and 8**_ of that course.


</Excerpt>


<CoursePromo course="intro" />


## The `#include` Directive


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


```c++
// Same Directory
#include "math.cpp"

// Child Directory
#include "some-subfolder/math.cpp"

// Parent Directory
#include "../math.cpp"
```


<Aside>


A _**directive**_ is something we include in our code that will be detected and acted upon by the C++ preprocessor.


The _**preprocessor**_ is a tool that sits between our code and the compiler.  Based on any directives we have, the preprocessor modifies our source code before it is received by the compiler.  We cover the preprocessor in more detail later.


</Aside>


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:


```c++
// math.cpp
int add(int x, int y) {
  return x + y;
}
```


```c++
// main.cpp
#include "math.cpp"

int main() {
  Add(x+y);
}
```


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:


```c++
// geometry.cpp
float Pi{3.14f};
```


```c++
// math.cpp
#include "geometry.cpp"
```


```c++
// main.cpp
#include "geometry.cpp"
#include "math.cpp"
```


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:


```c++
// geometry.cpp
#pragma once

float Pi{3.14f};
```


```c++
// math.cpp
#pragma once

#include "geometry.cpp"
```


<Ad />


## Namespaces


Namespaces are the primary way to organize code in large applications.  We give our `namespace` a meaningful name, and then open a set of braces, thereby creating a new scope.


```c++
namespace Math {
  // new scope
}
```


Within these braces, we can create variables, functions, and other constructs in the usual way:


```c++
namespace Math {
  int Add(int x, int y) {
    return x + y;
  }

  // Namespaces can be nested
  namespace Geometry {
    float Pi{3.14f};
  }
}
```


## Scope Resolution Operator `::`


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


For example, to access a variable or function within the scope we called `Math`, we would prepend the identifier with `Math::`


```c++
Math::Add(1, 2);
```


Our `Math` namespace has a nested `Geometry` namespace, which we can access using multiple scope resolution operators:


```c++
Math::Geometry::Pi / 2;
```


## Shadowed Variables


Multiple variables with the same name can be accessible within the same scope.  In the following example, within the `Math` namespace, two variables identified by `x` are available:


```c++
int x{1};

namespace Math{
  int x{2};
}
```


We have the `x` defined within the global namespace, which has a value of `1`, and the `x` defined within the local namespace, which has a value of `2`


This is sometimes referred to as _**shadowed variables**_ or _**shadowed identifiers**_.  It is something we should try to avoid, as it can be confusing and cause bugs.


When resolving an identifier, the compiler will use the one in the scope that is _**most local**_ to the expression that is using the identifier.  As such, in the following example, `Math::Value` will be `2`:


```c++
int x{1};

namespace Math{
  int x{2};
  int Value{x}; // 2//<h>
}
```


Access to the global scope is available using the unary scope resolution operator.  That is, `::` without a left operand.  In the following example, `Math::Value` will now be `1`:


```c++
int x{1};

namespace Math{
  int x{2};
  int Value{::x}; // 1//<h>
}
```


<Ad />


## 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:


```c++
// The standard library's string implementation
#include <string>
```


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


```c++
#include <string>

int main() {
  std::string Greeting{"Hello"};
}
```


## `std::cout`


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


```c++
// Ways to interact with input and output
#include <iostream>
```


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


```c++
#include <string>
#include <iostream>

int main() {
  std::string Greeting{"Hello"};
  std::cout << Greeting;//<h>
}
```


This program yields the following output:


```c++
//<o>
Hello
```


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


```c++
#include <string>
#include <iostream>

int main() {
  std::string Greeting{"Hello"};

  // The << operator can be chained
  std::cout << Greeting << " World";
}
```


```c++
//<o>
Hello World
```


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


```c++
#include <iostream>

int main() {
  std::cout << "After this, there is a break\n";
  std::cout << "after this too!" << std::endl;
  std::cout << "This will\nspan two lines";
}
```


```c++
//<o>
After this, there is a break
after this too!
This will
span two lines
```


<Ad />


## `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:


```c++
void MyFunction() {
  using std::cout, std::endl;

  // In the rest of this function, we can now
  // use cout and endl without needing to
  // specify the std:: prefix
  cout << "This works!" << endl;
}
```


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


```c++
void MyFunction() {
  using namespace std;

  // Now, anything in the std namespace can be
  // used, without needing prefixed with std::
  cout << "This works!" << endl;
}
```


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 we 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.


This is particularly true when we’re writing code that we are going to `#include` in other files, because then our global `using` statement will affect those files, too.


## Literals in Namespaces


Another scenario where we may want to use a `using namespace` statement is to gain access to more literals.


Under the hood, literals are simply functions, and are typically defined within namespaces.  We’ll see examples of this later in the course, when we learn to create literals for our own custom types.


For now, we can see an example of this using a literal for creating `std::string`, which is available within the `std` namespace.


We gain access to it through an appropriate `using namespace` statement, such as:

- `using namespace std`
- `using namespace std::literals`
- or `using namespace std::string_literals`

In any scope where such a statement is in effect, we can use double-quotes with an `s` suffix, such as `"Hello"s` to create a `std::string`:


```c++
#include <string>

int main(){
  using namespace std::string_literals;//<h>

  // Creates a std::string
  auto MyString{"Hello World"s};//<h>
}
```


<Aside>


### String and Character Literals: `''`, `""`, and `""s`


When it comes to strings and characters, there are three main literals we’ll use in this course:

- Single quotes, such as `'H'` create a `char` - a built-in type that represents a single character
- Double quotes, such as `"Hello"` is an array of `char` objects.  This is a simple way of representing a string.
- Double quotes suffixed with an `s`, such as `"Hello"s` create a `std::string`.  This is a modern string type with many more capabilities than a simple character array.

The `std::string` type can be created from character arrays, so the simple `""` literal is often used even when the result is a `std::string`:


```c++
// Creating a std::string from a char array
std::string MyString{"Hello"};
```


We’ll explore characters and strings in much more detail throughout this course.


</Aside>


## Summary


In this lesson, we explored the basics of organizing code using namespaces. We also discovered how to use `#include` directives to use code from other files and libraries, and how to use the standard library to access powerful pre-built functionality.  Key takeaways:

- Namespaces help avoid naming conflicts and organize code logically.
- The `#include` directive allows reusing code from other files and libraries.
- The scope resolution operator `::` is used to access elements in a namespace.
- Shadowed variables occur when an identifier in an inner scope has the same name as an identifier in an outer scope.
- The standard library provides a rich set of pre-built functionality.
- `std::cout` and `std::endl` are used for console output.
- `using` statements allow using names from a namespace without explicit qualification.
- Literals for `std::string` are created using the `s` suffix - for example: `"Hello World"s`.

<FAQ>


```javascript
//<m>
{
  slug: 'why-use-namespaces',
  title: 'Why Use Namespaces in C++?',
  question: 'What are the benefits of using namespaces in C++? When should I use them in my code?',
}
```


Namespaces provide several benefits in C++:

1. They help avoid naming conflicts between identifiers (variables, functions, classes, etc.) defined in different parts of a program or different libraries.
2. They allow you to logically group related code elements together, making your code more organized and readable.
3. They provide a way to create separate scopes for identifiers, so you can use the same name for different things in different contexts.

You should use namespaces:

- When writing libraries or modules that will be used in other projects, to avoid potential naming clashes.
- To group related functionality together and make your code more modular.
- When working on large codebases, to minimize the risk of accidentally using the same identifier for different purposes.

For example:


```c++
namespace MyLibrary {
  void Foo() {
    // Function code
  }
}

namespace YourLibrary {
  // Different function with the same name
  void Foo() {  //<h>
    // Function code
  }
}

int main() {
  // Calls the Foo function from MyLibrary
  MyLibrary::Foo();

  // Calls the Foo function from YourLibrary
  YourLibrary::Foo();
}
```


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'multiple-using-statements',
  title: 'Multiple using Statements',
  question: 'Can I have multiple using statements for the same namespace in different scopes? What happens if I do?',
}
```


Yes, you can have multiple `using` statements for the same namespace in different scopes. The `using` statement only applies to the scope in which it appears and any nested scopes.


If you have multiple `using` statements for the same namespace in different scopes, each one will apply only to its own scope and any nested scopes.


For example:


```c++
#include <iostream>

namespace MyNamespace {
  void Foo() {
    std::cout << "MyNamespace::Foo()\n";
  }
}

void Function1() {
  using MyNamespace::Foo;//<h>

  // Calls MyNamespace::Foo()
  Foo();
}

void Function2() {
  // No using statement here
  // Explicit namespace qualifier needed
  MyNamespace::Foo();
}

int main() {
  using MyNamespace::Foo;//<h>
  Foo();// Calls MyNamespace::Foo()
  Function1();
  Function2();
}
```


```text
//<o>
MyNamespace::Foo()
MyNamespace::Foo()
MyNamespace::Foo()
```


The `using` statement in `Function1` applies only within that function, while the `using` statement in `main` applies to `main` and any functions called from `main` that don't have their own `using` statements.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'include-paths',
  title: 'Setting Include Paths',
  question: 'How do I set up my compiler to find header files in different directories?',
}
```


To set up your compiler to find header files in different directories, you need to specify the include paths using compiler flags. The exact flag depends on your compiler.

- For GCC and Clang, use the `I` flag followed by the directory path.
- For Microsoft Visual C++, use the `/I` flag followed by the directory path.

For example, if you have headers in a directory named "include" within your project directory, you would compile your code like this:


GCC/Clang:


```text
//<ti>
eg++ -I./include main.cpp
```


MSVC:


```text
//<ti>
cl /I.\include main.cpp
```


You can specify multiple include paths by using multiple `-I` or `/I` flags.


In your code, you can then use the `#include` directive with the header file name, without specifying the full path:


```c++
#include "myheader.h"
```


The compiler will search for `myheader.h` in the specified include directories.


Many IDEs and build systems (like CMake) provide ways to set include paths in their project settings, so you don't have to specify them manually on each compile.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'namespace-alias',
  title: 'Namespace Aliases',
  question: 'What is a namespace alias and when would I use one?',
}
```


A namespace alias is a way to give a shorter or more convenient name to a namespace. You create a namespace alias using the `namespace` keyword followed by the alias name and an `=` sign.


For example:


```c++
#include <iostream>

namespace VeryLongNamespace {
  void Foo() {
    std::cout << "VeryLongNamespace::Foo()\n";
  }
}

namespace VLN = VeryLongNamespace;  //<h>

int main() {
  VLN::Foo();  //<h>
}
```


```text
//<o>
VeryLongNamespace::Foo()
```


Here, `VLN` is an alias for `VeryLongNamespace`. We can use `VLN::Foo()` instead of `VeryLongNamespace::Foo()`.


You would use a namespace alias:

1. To make your code more readable by shortening long namespace names.
2. To avoid typing out long namespace names repeatedly.
3. To create a shorter name for a nested namespace.

For example:


```c++
namespace A::B::C {
  void Foo() {}
}

namespace ABC = A::B::C;//<h>

int main() {
  ABC::Foo();//<h>
}
```


</FAQ>


<FAQ>


```javascript
//<m>
{
slug: 'header-include-order',
title: 'Header Include Order',
question: 'Does the order of `#include` directives matter? If so, what\'s the correct order?',
}
```


The order of `#include` directives can matter in some cases, due to macro definitions, type definitions, or inline functions in headers.


The general rule is to include headers in the following order:

1. Related header: If a source file implements functions declared in a header file, include that header file first.
2. C system headers: Headers from the C standard library, such as `<cstdio>`.
3. C++ standard library headers: Such as `<iostream>` or `<vector>`.
4. Other libraries' headers: Headers from third-party libraries.
5. Your project's headers: Headers specific to your project.

Within each category, headers should be ordered alphabetically.


Here's an example:


```c++
// my_class.cpp

#include "my_class.h" // Related header

#include <cstdio> // C system header

#include <algorithm> // C++ standard library
#include <iostream> // C++ standard library
#include <vector> // C++ standard library

#include <some_lib.h> // Other library

#include "my_project.h" // Your project's header
#include "utils.h" // Your project's header
```


This order ensures that the related header is included before anything else, system headers come before user headers, and within each category, headers are ordered alphabetically for easy scanning.


However, in most cases, the order of `#include` directives doesn't matter as long as the required declarations are available when needed. Modern compilers are pretty good at handling include order.


</FAQ>


<FAQ>


```javascript
//<m>
{
slug: 'explicit-namespace-std',
title: 'Explicit std:: Namespace',
question: 'Why do you use explicit `std:: namespace` qualifiers in this lesson\'s code examples instead of \'using namespace std;\'?',
}
```


In this lesson, I use explicit `std::` namespace qualifiers for types and objects from the C++ Standard Library, like `std::cout` and `std::string`, instead of a `using namespace std;` statement. There are a few reasons for this:

1. It makes it clear that these types and objects are from the Standard Library and not from the current project or some other library.
2. It avoids potential naming conflicts. If your code defines a function or variable with the same name as something in the `std` namespace, and you have a `using namespace std;` statement, you'll get a naming conflict. Using explicit `std::` avoids this.
3. It's considered good practice in many codebases and style guides. While `using namespace std;` can be convenient for small examples or personal projects, it's often discouraged in larger codebases or when writing libraries.

For example, instead of:


```c++
#include <iostream>
using namespace std;

int main() {
  string message = "Hello, world!";
  cout << message << endl;
}
```


I would write:


```c++
#include <iostream>

int main() {
  std::string message = "Hello, world!";
  std::cout << message << std::endl;//<h>
}
```


The explicit `std::` makes it clear where `string`, `cout`, and `endl` are coming from.


There are situations where a `using` statement can be appropriate, like within a limited scope such as a function, but for clarity and to promote good habits, I generally avoid `using namespace std;` in examples.


</FAQ>



A quick introduction to namespaces in C++, alongside the standard library and how we can access it