Introduction To C++ - Day 3

Templates
Templates are mechanism to support the so-called generic programming. We can use templates when we
want to define a class or a function that can accept any/all types. A function or a class template prototype:
template <typename T>
// the rest of our function or class code
template <class T>

// the rest of our function or class code
Function templates
A function template definition. A function template instantiation.
#include <iostream> int main()
{
template <typename T> myFunction<int>(123);
void myFunction(T param) myFunction<double>(123.456);
{ myFunction<char>('A');
std::cout << param; }
}
72 Copyright © Slobodan Dmitrovic

Templates
Function templates
An example of a function template having multiple parameters.
#include <iostream>
template <typename T, typename U>

void myFunction(T t, U u)
{
std::cout << "The first parameter is: " << t << '\n';
std::cout << "The second parameter is: " << u << '\n';
}
int main()
{
int x = 123;
double d = 456.789;
myFunction<int, double>(x, d);
}

Templates
Class templates
We can have class templates allowing us to work with generic types in our class.
#include <iostream>

class MyClass {
private:
T x;
public:
MyClass(T argx) :x{ argx } {}
T getValue() { return x; }
};
int main()
{
MyClass<int> o{ 123 };
std::cout << "The value of x is: " << o.getValue() << '\n';
MyClass<double> o2{ 456.789 };
std::cout << "The value of x is: " << o2.getValue() << '\n';
} 74 Copyright © Slobodan Dmitrovic
Templates
Class templates
Defining class template member functions outside the class.
#include <iostream>

class MyClass {
public:
void someFunction();
T genericFunction();
};

void MyClass<T>::someFunction()
{
// ...
}
T MyClass<T>::genericFunction()
{
// ... 75 Copyright © Slobodan Dmitrovic
}
Templates
Template specialization
If we want our template to behave differently for a specific type, we provide the so-called template
specialization.
template <typename T> int main()
void myFunction(T arg) {
{ myFunction<char>('A');
std::cout << "The value is: " << arg myFunction<double>(345.678);
<< '\n'; myFunction<int>(123); // instantiates
} // specialized function template
// template specialization }
template <>
void myFunction(int arg)
{
std::cout << "This is a specialization
int. The value is: " << arg <<
'\n';
}

Enumerations
Enumerations are user-defined types whose values are constants with symbolic names.
Unscoped enumerations Scoped enumerations
Unscoped enums have underlying integral values Scoped enums do not leak their enumerators, and
and leak their enumerators into the surrounding we can specify the scoped enum's underlying type.
scope. We should prefer scoped enums in C++.
enum MyEnum enum class MyEnum
{ {
myfirstvalue = 10, myfirstvalue,
mysecondvalue, mysecondvalue,
mythirdvalue mythirdvalue
}; };
enum MyOtherEnum enum MyCharEnum : char // specify the type
{ {
myintvalue = 10 myintvalue = 'A'
}; };
int main() int main()
{ {
MyEnum myenum = myfirstvalue; MyEnum myenum = MyEnum::myfirstvalue;
myenum = mysecondvalue; }
Organizing code
Header and source files
We can split our C++ source code into multiple files. Header files are source code files that usually contain
declarations. Headers by convention have the .h or .hpp extension. Source files (.cpp, .cc,…) are files in
which we place our implementation C++ code as well as the function main. We include headers into our
source files using the #include directive. To include the standard library headers, we use the <> brackets.
#include <iostream>
#include <string>
// etc
To include user-defined header files, we use double quotes "".
#include "myheaderfile.h"
#include "otherheaderfile.h"
// etc
Header guards
Header guards prevent multiple inclusions of the same header file. They are placed inside a header file.
#ifndef MY_HEADER_H
#define MY_HEADER_H
// header file source code
#endif
Organizing code
Namespaces
A namespace is a scope with a name. We can logically group our source code into namespaces.
namespace MyNameSpace
{
}
We can place/declare names in a namespace. And access them using the fully qualified name.
namespace MyNameSpace int main()
{ {
int x; MyNameSpace::x = 123;
double d; MyNameSpace::d = 456.789;
} }
We can introduce the entire namespace into the current scope via the using directive.
using namespace MyNameSpace;
int main()
{
x = 123;
d = 456.789;
Conversions
Implicit conversions
Values of built-in types are implicitly convertible to values of other built-in types.
char mychar = 64; int arr[5] = { 1, 2, 3, 4, 5 };
int myint = 123; int* p = arr; // array to pointer conversion
double mydouble = 456.789;
bool myboolean = true;
myint = mychar; // char to int
mydouble = myint; // int to double
mychar = myboolean; // boolean to char
Explicit conversions
We can also explicitly convert one type to another using the built-in operators such as the static_cast.
auto myinteger = static_cast<int>(123.456); // double to int
There are other explicit conversion operators:
• dynamic_cast
• reinterpret_cast
• const_cast
Most of the time, the only cast we will be using is the static_cast.

Exceptions
If an error occurs in our program, we want to be able to handle it in a meaningful way. One way is through
exceptions. Exceptions are mechanisms that transfer the execution control from a try block to exception
handling catch block.
try
{
// our code here
// throw an exception if there is an error
}
catch (type_of_the_exception e)
{
// catch and handle the exception
}
We can throw and handle exceptions of any type.
try catch (int e) { /* catch and handle */ }
{ catch (double e) {/* … */}
throw 123; catch (const std::string& e) {/* … */}
throw 456.789; catch(...){ /* catch and handle all */ }
throw std::string{ "Error 123" };
}
Exceptions
Try-catch example
#include <iostream>
#include <string>
int main()
{
try
{
std::cout << "Executing a try block. " << '\n';
throw 123;
// the following will not execute, the control is moved to a catch clause
throw std::string{ "Some string error" };
}
catch (int e)
{
std::cout << "Integer exception raised! The value is " << e << '\n';
}
catch (const std::string& e)
{
std::cout << "String exception raised with a value of " << e << '\n';
}
}
Smart pointers
Smart pointers are pointers that own the object they point to and automatically destroy the object and
deallocate the memory once they go out of scope. Smart pointers are declared inside a <memory> header.
Unique pointer
A unique pointer std::unique_ptr is a pointer that owns an object it points to. The pointer can not be copied.
Once it goes out of scope, the unique pointer deletes the object and deallocates the memory.
#include <iostream>
#include <memory>
int main()
{
std::unique_ptr<int> up(new int{ 123 });
std::cout << *up;
}
Prefer initializing unique pointers through a std::make_unique function.
std::unique_ptr<int> up = std::make_unique<int>(123);
std::unique_ptr<double> up2 = std::make_unique<double>(456.789);
std::unique_ptr<MyClass> up3 = std::make_unique<MyClass>(arguments);

Smart pointers
Shared pointer
We can have multiple pointers pointing to a single object. We call them shared pointers. We say the object
has shared ownership. And only when the last of these shared pointers gets destroyed, our pointed-to
object gets deleted.
#include <memory>
int main()
{
std::shared_ptr<int> sp1 = std::make_shared<int>(123);
std::shared_ptr<int> sp2 = sp1;
std::shared_ptr<int> p3 = sp1;
} // they all go out of scope here and the object gets deleted
Shared pointers can be used to make graphs. Shared pointers can be copied, while the unique pointers
can only be moved from.

Input / output streams
We can convert objects to streams of bytes and vice-versa. The I/O stream library provides such
functionality. There are different kinds of I/O streams, and here we will explain two kinds: file streams and
string streams.
File streams
We can read from a file, and we can write to a file. The standard-library offers such functionality via file
streams. Those files streams are defined inside the <fstream> header, and they are:
• std::ifstream – read from a file
• std::ofstream – write to a file
• std::fstream – read from and write to a file
The std::fstream can both read from and write to a file, so let us use that one. To create an std::fstream
object, we use:
#include <fstream>
int main()
{
std::fstream fs{ "myfile.txt" };
}
This example creates a file stream called fs and associates it with a file name myfile.txt on our disk.
File streams
Example where we read from a file into a variable, one line of the text at the time using the std::getline
function.
#include <iostream>
#include <fstream>
#include <string>
int main()
{
std::string s;
while (fs)
{
std::getline(fs, s); // read each line into a string
std::cout << s << '\n';
}
}

File streams
To read from a file, one character at the time, we can use file stream’s >> operator:
#include <iostream>
#include <fstream>
int main()
{
char c;
while (fs >> c) // read from a file into a variable, one character at the time
{
std::cout << c;
}
}
To prevent skipping of white spaces, we add the std::noskipws manipulator:
while (fs >> std::noskipws >> c)

File streams
To write to a file, we use file stream's << operator:
#include <fstream>
int main()
{
std::fstream fs{ "myoutputfile.txt", std::ios::out };
fs << "First line of text." << '\n';
fs << "Second line of text" << '\n';
}
To append the text to an existing file, we include the std::ios::app flag.
#include <fstream>
int main()
{
std::fstream fs{ "myoutputfile.txt", std::ios::app };
fs << "This is an appended text" << '\n';
fs << "This is also an appended text." << '\n';
}
String streams
A string stream is a stream that allows us to read from and write to a string. It is defined
inside the <sstream> header, and there are three different string streams:
• std::istringstream - the stream to read from a string
• std::ostringstream - the stream to write to a string
• std::stringstream - the stream to both read from and write to a string
To create a simple string stream and initialize it with a string literal, we use:
#include <iostream>
#include <sstream>
int main()
{
std::stringstream ss{ "Hello world." };
std::cout << ss.str();
}
The .str() member function gets the string representation of the string stream.

String streams
To write the data to a string stream, we use the string stream's << operator:
#include <iostream>
#include <sstream>
int main()
{
char c = 'A';
int x = 123;
double d = 456.78;
std::stringstream ss;
ss << c << x << d;
std::cout << ss.str();
}

String streams
To read/extract the data from a string stream into our objects/variables, we use the >> operator:
#include <iostream>
#include <sstream>
#include <string>
int main()
{
std::string s = "A 123 456.78";
std::stringstream ss{ s };
char c;
int x;
double d;
ss >> c >> x >> d;
std::cout << c << ' ' << x << ' ' << d << '\n';
}

C++ Standard Library
C++ language is accompanied by a library called the C++ Standard Library. It is a collection of containers
and useful functions.
Containers
A container is an in-memory data structure where we store our objects. Containers are implemented as
class templates. Some of the container categories are:
• Sequence containers (std::vector, std::array, std::list, std::forward_list, std::deque) – store objects in a
sequence, one next to the other in memory
• Associative containers (std::set, std::map, std::multiset, std::multimap) – store sorted objects and
associate keys with values
std::vector
A vector is a sequence of contiguous elements To insert an element at the end of the vector, we
whose size can change during runtime. use the vector's .push_back() member function.
#include <vector> #include <vector>
int main() int main()
{ {
std::vector<int> v = { 1, 2, 3, 4 }; std::vector<int> v = { 1, 2, 3, 4 };
} v.push_back(10);
}
std::vector
Individual vector elements can be accessed via the subscript operator [ ], a member function .at() or an
iterator.
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v = { 1, 2, 3, 4, 5 };
std::cout << "The third element is:" << v[2] << '\n';
std::cout << "The fourth element is:" << v.at(3) << '\n';
std::cout << "The first element is: " << *v.begin() << '\n';
}
The vector’s size, as a number of elements, can be obtained through a .size() member function:
std::vector<int> v = { 1, 2, 3, 4, 5 };
std::cout << "The vector's size is: " << v.size();
We can traverse, insert to, delete from, sort, reverse a vector, search for an element inside a vector and
more. There is an iterator pointing at the vector's first element, called .begin(), and an iterator pointing at
one-past the last element called .end(). 93 Copyright © Slobodan Dmitrovic
std::array
The std::array is a thin wrapper around a C-style array. To use it, we must include the <array> header file.
#include <iostream>
#include <array>
int main()
{
std::array<int, 5> arr = { 1, 2, 3, 4, 5 };
for (auto el : arr)
{
std::cout << el << '\n';
}
}
The std::array size is fixed and once declared, it can not be changed. Raw arrays get converted to pointers
when used as function arguments, and we should prefer std::array or std::vector to old C-style arrays.

std::set
A set is a container that holds unique, sorted objects. It is implemented as a binary tree of sorted objects.
To use a set, we must include the <set> header.
#include <iostream>
#include <set>
int main()
{
std::set<int> myset = { 1, 2, 3, 4, 5 };
for (auto el : myset)
{
}
}

std::set
To insert an element into a set, we can use the set's .insert() member function. To insert two new elements,
we write:
#include <iostream>
#include <set>
int main()
{
std::set<int> myset = { 1, 2, 3, 4, 5 };
myset.insert(10);
myset.insert(42);
for (auto el : myset)
{
}
}
A set holds unique values, an attempt to insert duplicate values will not succeed.

std::map
The map is an associative container that holds key-value pairs. Keys are sorted and unique. The map is
declared inside the <map> header and has the std::map<type1, type2> declaration signature.
#include <iostream>
#include <map>
int main()
{
std::map<int, char> mymap = { {1, 'a'}, {2, 'b'}, {3,'c'} };
for (auto el : mymap)
{
std::cout << el.first << ' ' << el.second << '\n';
}
}
Every map element is a pair. The pair’s first element (the key) is accessed through a .first member
variable, the second element (the value) is accessed through a .second member variable.

std::map
If the key accessed through a map's subscript operator [ ] does not exist, the entire key-value pair gets
inserted into a map.
#include <iostream>
#include <map>
int main()
{
std::map<int, char> mymap;
mymap[1] = 'a';
mymap[2] = 'b';
for (auto el : mymap)
{
std::cout << el.first << ' ' << el.second << '\n';
}
}
To insert a key-value par into a map, we can use the map's .insert() member function:
mymap.insert({ 20, 'c' });
std::map
To search for a specific key inside a map, we can use the map’s .find(key_value) member function, which
returns an iterator to the element found or the value equal to .end() if the key was not found.
#include <iostream>
#include <map>
int main()
{
std::map<int, char> mymap = { {1, 'a'}, {2, 'b'}, {3,'c'} };
auto it = mymap.find(2);
if (it != mymap.end())
{
std::cout << "Found: " << it->first << " " << it->second << '\n';
}
else
{
std::cout << "Not found.";
}
}
std::pair
The std::pair class template is a wrapper that can represent a pair of values. To use the std::pair, we need
to include the <utility> header. To access the first value in a pair, we use the .first member variable. To
access the second value in a pair, we use the .second member variable.
#include <iostream>
#include <utility>
int main()
{
std::pair<int, double> mypair = { 123, 3.14 };
std::cout << "The first element is: " << mypair.first << '\n';
std::cout << "The second element is: " << mypair.second << '\n';
}
Another way to create a pair is through a std::make_pair function:
std::pair<int, double> mypair = std::make_pair(123, 456.789);

Range-based for loop
The range-based for loop is/performs a for loop over the elements of a range. It has the following
signature:
for (type_name element_name : container_name)
{
}
We read it as: for each element_name of type_name inside the container_name do something inside the
code block { }.
std::vector<int> v = { 1, 2, 3, 4, 5 };
for (int el : v)
{
}
The el name represents a copy of each of the container's elements. To operate on the actual container
elements, we use a reference type:
for (int& el : v)
{
Iterators
Containers have iterators. They are container's members that behave like pointers to container elements.
Iterator pointing at the first element of a vector is expressed through a .begin() member function. Iterator
pointing at the not the last but, one past the last element, is expressed through a .end() member function.
A .begin() and .end() iterator can also be obtained through a std::begin() and std::end() functions. Iterators
can be incremented and decremented.
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v = { 1, 2, 3, 4, 5 };
for (auto it = v.begin(); it != v.end(); it++)
{
std::cout << *it << '\n';
}
}
To access a container element pointed-to by an iterator, we dereference an iterator.
std::cout << *it << '\n';
std::sort
The std::sort function sorts the range of elements in a container. The function is declared inside an
<algorithm> header. To sort our vector in the ascending order, we use:
#include <iostream>
#include <vector>
#include <algorithm>
int main()
{
std::vector<int> v = { 1, 5, 2, 15, 3, 10 };
std::sort(v.begin(), v.end());
for (auto el : v)
{
}
}
To sort a container in descending order, we pass in an additional argument called a comparator.
std::sort(v.begin(), v.end(), std::greater<int>());
std::find
To find a certain element by value and return an iterator pointing at that element, we use the std::find
function. The function is declared inside the <algorithm> header. If the element is found, the function
returns an iterator to the first found element in the container, else it returns an .end() iterator.
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v = { 1, 5, 2, 15, 3, 10 };
auto result = std::find(v.begin(), v.end(), 5);
if (result != v.end())
{
std::cout << "Element found: " << *result;
}
else
{
std::cout << "Element not found.";
}
std::copy
The std::copy function copies the range of elements from one container to another. It can copy a range of
elements marked with [starting_poisition_iterator, ending_position_iterator) from the starting container to a
specific position marked with (destination_position_iterator) in the destination container. The function is
declared inside the <algorithm> header.
#include <iostream>
#include <vector>
int main()
{
std::vector<int> copy_from_v = { 1, 2, 3, 4, 5 };
std::vector<int> copy_to_v(5); // reserve the space for 5 elements
std::copy(copy_from_v.begin(), copy_from_v.end(), copy_to_v.begin());
for (auto el : copy_to_v)
{
}
}

Min and max elements
To find the greatest element in the container, we use the std::max_element function declared in the
<algorithm> header. This function returns an iterator to the max element in the container:
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v = { 1, 2, 3, 4, 5 };
auto it = std::max_element(std::begin(v), std::end(v));
std::cout << "The max element in the vector is: " << *it;
}
To find the smallest element in the container, we use the std::min_element function, which returns an
iterator to the min element in the container or a range:
auto it = std::min_element(std::begin(v), std::end(v))

Lambda Expressions
Lambda expressions, or lambdas for short, are the so-called anonymous function objects. Lambdas can
capture variables in a scope. The lambda expression signature is: [captures](parameters){lambda_body};
#include <iostream>
int main()
{
auto mylambda = []() { std::cout << "Hello from a lambda."; };
mylambda();
}
Capture local variables by copy:
int x = 123;
auto mylambda = [x]() { std::cout << "The value of x is: " << x; };
Capture local variables by reference:
int x = 123;
auto mylambda = [&x]() {
x++;
std::cout << "The value of x is: " << x;
};
Lambda Expressions
To capture more than one variable in a capture list, we use the comma operator:
int x = 123;
int y = 456;
auto mylambda = [x, y]() {std::cout << "x is: " << x << ", y is: " << y; };
mylambda();
Lambdas can have optional parameters inside the parenthesis: [](param1, param2) {}. Example:
auto mylambda = [](int x, int y) {std::cout << "X is: " << x << ", y is: " << y; };
mylambda(123, 456);
Lambdas are usually used as predicates inside the standard-library algorithm functions.
std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30 };
auto counteven = std::count_if(std::begin(v), std::end(v),
[](int x) {return x % 2 == 0; });
std::cout << "The number of even vector elements is: " << counteven;

Introduction To C++ - Day 3

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To C++ - Day 3

Uploaded by

Copyright:

Available Formats

Templates

template <class T>

72 Copyright © Slobodan Dmitrovic

template <typename T, typename U>

73 Copyright © Slobodan Dmitrovic

template <typename T>

template <typename T>

template <typename T>

76 Copyright © Slobodan Dmitrovic

80 Copyright © Slobodan Dmitrovic

83 Copyright © Slobodan Dmitrovic

84 Copyright © Slobodan Dmitrovic

86 Copyright © Slobodan Dmitrovic

87 Copyright © Slobodan Dmitrovic

89 Copyright © Slobodan Dmitrovic

90 Copyright © Slobodan Dmitrovic

91 Copyright © Slobodan Dmitrovic

94 Copyright © Slobodan Dmitrovic

95 Copyright © Slobodan Dmitrovic

96 Copyright © Slobodan Dmitrovic

97 Copyright © Slobodan Dmitrovic

100 Copyright © Slobodan Dmitrovic

106 Copyright © Slobodan Dmitrovic

107 Copyright © Slobodan Dmitrovic

109 Copyright © Slobodan Dmitrovic

You might also like