Templates

Iuliana
Bocicor

Code analysis

Templates Templates
C++
Standard
Template
Library
Iuliana Bocicor
[email protected]

Babes-Bolyai University

2025

1 / 26
 Overview

Templates

Iuliana
Bocicor

Code analysis

Templates 1 Code analysis

C++
Standard
Template
Library
2 Templates

3 C++ Standard Template Library

2 / 26
 Code analysis I

Templates

Iuliana Linter/Code analyser - an automated tool that analyses the

Bocicor
source code and signals programming errors, bugs, stylistic
Code analysis errors, suspicious code.
Templates

C++
Standard
They are used to help us improve our code.
Template
Library
Advantages:
Fewer errors in the final code (especially useful for industrial
applications, where fewer defects arrive in production).
Readable, maintainable, more consistent code, of better
quality.
Learning about best practices in writing modern C++ code.

For Visual Studio: Project → Properties → Code Analysis

→ Enable Code Analysis on Build
3 / 26
 Code analysis II

Templates
We can select the sets of rules to be verified: Project →
Iuliana
Bocicor Properties → Code Analysis → Microsoft → Choose multi-
Code analysis
ple rule set: select all sets of rules starting with ”C++ Core”
Templates (for rules from C++ core Guidelines: https://isocpp.
C++ github.io/CppCoreGuidelines/CppCoreGuidelines).
Standard
Template
Library Code analysis will be made at compilation, warnings will be
reported in case guideline rules are broken.

See also: https://docs.microsoft.com/en-us/cpp/code-

using-the-cpp-core-guidelines-checkers?view=msvc-

For other platforms, you may use clang-tidy: http://

clang.llvm.org/extra/clang-tidy/.

4 / 26
 Templates

Templates

Iuliana
Bocicor Generic programming - algorithms are written with generic
Code analysis
types, that are going to be specified later.
Templates

C++
Generic programming is supported by most modern pro-
Standard gramming languages.
Template
Library
In C++ templates allow working with generic types.

Provide a way to reuse source code. The code is written

once and can then be used with many types.

Allow defining a function or a class that operates on differ-

ent kinds of types (is parametrized with different types).

5 / 26
 Function templates I

Templates

Iuliana Declaration
Bocicor
template <typename identifier> function declaration;
Code analysis

Templates

C++
template <typename T>
Standard T add (T a , T b )
Template
Library {
return a + b ;
}

T is the template parameter, a type argument for the tem-

plate;
The template parameter can be introduced with any of the
two keywords: typename, class.

6 / 26
 Function templates II

Templates

Iuliana
Bocicor
The process of generating an actual function from a tem-
Code analysis
plate function is called instantiation:
Templates

C++
Standard
Template int r e s I n t = add<int >(3 , 4 ) ;
Library
double r e s D o u b l e = add<double >( −1.2 , 2 . 6 ) ;

DEMO
Function template. (Lecture 4 - FunctionTemplate.cpp).

7 / 26
 Class templates I

Templates

Iuliana
Bocicor
A template can be seen as a skeleton or macro.

Code analysis
When specific types are added to this skeleton (e.g. double), then
Templates
the result is an actual C++ class.
C++ When instantiating a template, the compiler creates a new class
Standard
Template with the given template argument.
Library
The compiler needs to have access to the implementation of the
methods, to instantiate them with the template argument.
Place the definition of a template in a header file.

DEMO
Template (Lecture4 - DynamicVector.h, DynamicVector demo.cpp).

8 / 26
 Class templates II

Templates

Iuliana Templates can be also defined for more types:

Bocicor

Code analysis template <typename T , typename U>

Templates class P a i r
C++ {
Standard
Template private :
Library
T first ;
U second ;
// ...
};

DEMO
Template (Lecture4 - Pair.h).

9 / 26
 Templates - differences from void* implementation

Templates

Iuliana
Bocicor

Code analysis

Templates void* Template

C++ A container with void* A container can hold any type
Standard elements can only hold addresses. (both addresses and simple objects).
Template
Library Casting to a specific pointer is required, No casting needed.
in certain situations.
Memory management is required. Memory management is required
only in certain situations.
The container may include pointers All elements will have the same type.
to different types.

10 / 26
 Templates - conclusions

Templates

Iuliana
Bocicor

Code analysis Templates are a compile-time mechanism.

Templates

C++
Standard
They are most commonly used in generic programming (im-
Template plementation of general algorithms).
Library

Useful for writing compact and efficient code.

The definition (not just the declaration) must be in scope

(usually in the header file).

11 / 26
 Standard Template Library (STL)

Templates

Iuliana
Bocicor
Is a software library for C++.
Code analysis

Templates
Is a generic library, meaning that its components are heav-
C++
Standard ily parametrized: almost every component in the STL is a
Template
Library template.

Is designed such that programmers create components that

can be composed easily without losing any performance.

The primary designer and implementer of STL is Alexander

Alexandrovich Stepanov.

12 / 26
 Containers in STL I

Templates

Iuliana
Bocicor
A container is a holder object that stores a collection of
Code analysis
other objects (its elements).
Templates

C++
Standard
Template
Containers are implemented as class templates.
Library

Containers:
manage the storage space for their elements;
provide member functions to access the elements, either
directly or through iterators (reference objects with similar
properties to pointers);
provide functions to modify the elements.

13 / 26
 Containers in STL II

Templates
Container class templates:
Iuliana
Bocicor
Sequence containers (elements are ordered in a linear se-
Code analysis quence):
Templates array<T>;
C++ vector<T>;
Standard
Template deque<T>;
Library forward list<T>;
list<T>.

Associative containers (elements are referenced by their

keys and not by their absolute positions in the container):
set<T, CompareT>;
multiset<T, CompareT>;
map<KeyT,ValueT,CompareT>;
multimap<KeyT, ValueT,CompareT>.

14 / 26
 Containers in STL III

Templates

Iuliana
Bocicor

Code analysis

Templates
Container adapters (created by limiting functionality in a
C++ pre-existing container):
Standard
Template
Library
stack<T, ContainerT>;
queue<T, ContainerT>;
priority queue<T,ContainerT, CompareT>.

15 / 26
 Iterators I

Templates

Iuliana
Bocicor
Provide a generic (abstract) way to access the elements of
Code analysis
a container.
Templates

C++
Standard
Allow access to the elements of a container without expos-
Template
Library
ing the internal representation (implementation hiding).

Make a separation between how data is stored and how we

operate on data.

An iterator will contain:

a reference to the current element;
a reference to the container.

16 / 26
 Iterators II

Templates

Iuliana
Bocicor
An iterator keeps track of a location within an associated STL
Code analysis container object, providing support for traversal (increment/decre-
Templates ment), dereferencing and container bounds detection.
C++
Standard
Template In C++, iterators are not pointers, but act similar to pointers
Library in certain situations (can be incremented with ++, dereferenced
with *, and compared against another iterator with !=).

Containers expose 2 member functions: begin() and end(), which

provide iterators towards the begin (first element) and the end
(past the last element) of the containers.

17 / 26
 std::vector

Templates

Iuliana
Bocicor Is a container that stores elements of the same type.
Code analysis Is a sequence container: its elements are ordered in a linear
Templates sequence.
C++
Standard
Resizes automatically when needed.
Template
Library Uses a dynamically allocated array to store the elements.
Is very efficient in terms of element accessing (constant
time).
Works with range-based for loop.

DEMO
std::vector (Lecture4 - stl demo.cpp).

18 / 26
 std::deque

Templates
Double ended queue, with dynamic size, that can be ex-
Iuliana
Bocicor panded or contracted at both ends.
Code analysis Elements are stored in chunks of storage, not in contiguous
Templates locations.
C++
Standard
Elements can be accessed through random access iterators.
Template
Library
Insertion and deletion of elements are efficient at both ends
(not just at the end, as in the case of vectors).
Deques are a little more complex internally than vectors, but
this allows them to grow more efficiently especially with very
long sequences, where re-allocations become more expen-
sive.

DEMO
std::vector (Lecture4 - stl demo.cpp).
19 / 26
 std::list

Templates

Iuliana
Bocicor Implemented as a doubly linked list.
Code analysis Has constant time for inserting and erasing elements on any
Templates position.
C++
Standard Can be iterated in both directions.
Template
Library Compared to vectors and deques, lists perform better in
inserting, extracting and moving elements on positions for
which an iterator has already been obtained (thus also for
sorting algorithms).

DEMO
std::vector (Lecture4 - stl demo.cpp).

20 / 26
 STL Algorithms I

Templates

Iuliana
Bocicor
Algorithms are function templates that can operate on ranges
Code analysis of elements, ranges defined by iterators.
Templates

C++
Standard
The iterators returned by the functions begin() and end()
Template of a container can be fed to an algorithm to enable using
Library
the algorithm with the container.

Iterators are the mechanism that make possible the decou-

pling of algorithms from containers.

Exempt us from writing the same functions (find, sort,

count) for different individual containers.

21 / 26
 STL Algorithms II

Templates

Iuliana
Bocicor

Code analysis
Headers: <algorithm>, <numeric> - define a collection of
Templates
functions especially designed to be used on ranges of ele-
C++
Standard ments.
Template
Library

DEMO
STL Algorithms (Lecture4 - stl demo.cpp).

22 / 26
 Lambda expressions I

Templates

Iuliana
Bocicor
Provide a mechanism to define anonymous functions (lo-
Code analysis
cally, within other functions).
Templates

C++
Standard The anonymous function is defined in the code where it is
Template
Library called.

Are very useful for certain algorithms of the STL (find if,
count if, transform, sort).

The return type of lambdas can be deduced, but it can also

be specified.

23 / 26
 Lambda expressions II

Templates

Iuliana
Bocicor Syntax
Code analysis [capture list] (parameter list) {function body}
Templates [capture list] (parameter list) → return type {function body}
C++
Standard
Template
Library
E.g.
// ...
v e c t o r <int> oddNumbers ( 5 ) ;
c o p y i f ( i n t e g e r s . b e g i n ( ) , i n t e g e r s . end ( ) ,
oddNumbers . b e g i n ( ) , [ ] ( int x ) { return x % 2
== 1 ; } ) ;

24 / 26
 Lambda expressions III

Templates

Iuliana
Bocicor
A lambda can store information about variables that are in
Code analysis the local block scope.
Templates

C++ The lambda function body can refer to those variables using
Standard
Template the same name as in the surrounding scope.
Library

This is possible using the capture list.

DEMO
STL Algorithms (Lecture4 - stl demo.cpp).

25 / 26
 Advantages of STL algorithms

Templates

Iuliana
Bocicor simplicity: use existing code instead of writing the code
Code analysis
from scratch;
Templates

C++
correctness: known to be correct, tested;
Standard
Template
Library performance: generally perform better than hand written
code;

clarity: you can immediately tell that a call to sort sorts

the elements in a range;

maintainability: code is clearer and more straightforward

⇒ easier to write, read, enhance and maintain.

26 / 26