TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI

KỸ THUẬT LẬP TRÌNH HỆ CƠ ĐIỆN TỬ

Programming Engineering in Mechatronics

Giảng viên: TS. Nguyễn Thành Hùng

Đơn vị: Bộ môn Cơ điện tử, Viện Cơ khí

Hà Nội, 2020 1
 Chapter II. Modular programming in C++

• Structured programming relies on top-down design.

• In C and C++ languages, the smallest structural unit having
independent functionality is called function.
• If functions or a group of functions belonging together are
put in a separate module (source file), modular
programming is realised.
• Structural programming also contributes to creating new
programs from achieved modules (components) by bottom-
up design.
• This chapter aims to introduce the modular and procedural
programming in C++.

2
 Chapter II. Modular programming in C++

❖ The basics of functions

❖ How to use functions on a more professional level?
❖ Namespaces and storage classes
❖ Preprocessor directives of C++

3
 Chapter II. Modular programming in C++

❖ The basics of functions

❖ How to use functions on a more professional level?
❖ Namespaces and storage classes
❖ Preprocessor directives of C++

4
 The basics of functions

❖ Defining, calling and declaring functions

❖ The return value of functions
❖ Parametrizing functions
❖ Programming with functions

5
 The basics of functions

• In C++, a function is a unit (a subprogram) that has a name and that can
be called from the other parts of a program as many times as it is
needed.
• In order to use a function efficiently, some of its inner variables
(parameters) are assigned a value when the function is called.
• When a function is called (activated), the values (arguments) to be
assigned to each parameter have to be passed in a similar way.
• The called function passes control back to the place where it was called
by a return statement.
• The value of the expression in the return statement is the return
value returned back by the function, which is the result of the function
call expression.

6
 The basics of functions

❖ Defining, calling and declaring functions

• C++ Standard Library provides us many useful predefined
functions.

function header file

sqrt() cmath
isalpha() cctype
atoi() cstdlib
rand() cstdlib
strlen() cstring
wcslen() cwchar

7
 The basics of functions

❖ Defining, calling and declaring functions

• The general form of a function definition is the following (the
signs 〈 〉 indicate optional parts):

Function definition

8
 The basics of functions

❖ Defining, calling and declaring functions

9
 The basics of functions

❖ Defining, calling and declaring functions

• The steps of calling a function
function_name (〈argument 1 , argument 2 , … argument n 〉)

Steps of calling a function

10
 The basics of functions

❖ Defining, calling and declaring functions

• C++ standards require that functions have to be declared before
they are called.
Function declaration

Function definition

11
 The basics of functions

❖ Defining, calling and declaring functions

• The complete declaration of a function (its prototype ):

return_value function_name(〈parameter declaration list〉);

return_value function_name(〈type_list〉);

declaration C interpretation C++ interpretation

type funct(); type funct(...); type funct(void);
type funct(...); type funct(...); type funct(...);
type funct(void); type funct(void); type funct(void);
12
 The basics of functions

❖ Defining, calling and declaring functions

• C++ makes it possible that a parameter list containing at least one parameter
should end with three dots (...).

• The transferring (throw) of exceptions to the caller function can be enabled or

disabled in function header
return_type function_name (〈parameterlist〉) 〈throw(〈type_list〉)〉
{
〈local definitions and declarations〉
〈statements〉
return 〈expression〉;
}

13
 The basics of functions

❖ The return value of functions

• The return_type figuring in the definition/declaration of a function
determines the return type of the function, which can be of any C++ type with
the exception of arrays and functions.

14
 The basics of functions

❖ The return value of functions

• By using the type void, we can create functions that do not
return any value.

15
 The basics of functions

❖ The return value of functions

• Functions can return pointers or references

16
 The basics of functions

❖ Parametrizing functions
• A parameter can be scalar (bool, char, wchar_t, short, int, long, long long,
float, double, enumeration, reference and pointer) or structure, union, class
or array.
The general form of polynomials:

Horner's scheme

17
 The basics of functions

❖ Parametrizing functions
▪ Parameter passing methods
• Passing parameters by value

18
 The basics of functions

❖ Parametrizing functions
▪ Parameter passing methods
• Passing parameters by value

19
 The basics of functions

❖ Parametrizing functions
▪ Parameter passing methods
• Passing parameters by reference

20
 The basics of functions

❖ Parametrizing functions
▪ Parameter passing methods
• Passing parameters by reference

21
 The basics of functions

❖ Parametrizing functions
▪ Parameter passing methods
• Passing parameters by reference

22
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Arithmetic type parameters

23
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Arithmetic type parameters

24
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• User-defined type parameters

25
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• User-defined type parameters

26
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Passing arrays to functions

27
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Passing arrays to functions

28
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Passing arrays to functions

29
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Passing arrays to functions

30
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Passing arrays to functions

31
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• String arguments

32
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• String arguments

33
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• String arguments

34
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• String arguments

35
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Functions as arguments

36
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Functions as arguments

37
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Default arguments

Parameters
Call
n d a0
SeqSum() 10 1 1
SeqSum(12) 12 1 1
SeqSum(12,3) 12 3 1
SeqSum(12, 3, 7) 12 3 7
38
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Variable length argument list

39
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Variable length argument list

40
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Parameters and return value of the main() function

41
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Parameters and return value of the main() function

Providing
command
line
arguments

42
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Parameters and return value of the main() function

In a console window In a development environment

C:\C++Book>command1 first 2nd third

C:\C++Book>command1 first 2nd third
number of arguments: 4
number of arguments: 4
0: C:\C++Book\command1.exe 1: first 2: 2nd
0: command1 1: first 2: 2nd 3: third
3: third
C:\C++Book>
C:\C++Book>

43
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Parameters and return value of the main() function

44
 The basics of functions

❖ Parametrizing functions
▪ Using parameters of different types
• Parameters and return value of the main() function

Wrong number of parameters: Correct number of parameters:

command2 command2 alfa beta
Wrong number of parameters! Correct number of parameters: 1.
Usage: command2 arg1 arg2 argument: alfa 2. argument: beta

45
 The basics of functions

❖ Defining, calling and declaring functions

❖ The return value of functions
❖ Parametrizing functions
❖ Programming with functions

46
 The basics of functions

❖ Programming with functions

▪ Exchanging data between functions using global variables

47
 The basics of functions

❖ Programming with functions

▪ Exchanging data between functions using global variables
• Solution for above example

48
 The basics of functions

❖ Programming with functions

▪ Exchanging data between functions using global variables
• Solution for above example

49
 The basics of functions

❖ Programming with functions

▪ Exchanging data between functions using parameters

50
 The basics of functions

❖ Programming with functions

▪ Exchanging data between functions using parameters

51
 The basics of functions

❖ Programming with functions

▪ Exchanging data between functions using parameters

52
 The basics of functions

❖ Programming with functions

▪ Implementing a simple menu driven program structure

53
 The basics of functions

❖ Programming with functions

▪ Recursive functions
• Factorial:

more efficient

54
 The basics of functions

❖ Programming with functions

▪ Recursive functions
• Fibonacci numbers:

more efficient

55
 The basics of functions

❖ Programming with functions

▪ Recursive functions
• greatest common divisor (gcd):

56
 The basics of functions

❖ Programming with functions

▪ Recursive functions
• binomial numbers:

57
 The basics of functions

❖ Programming with functions

▪ Recursive functions

58
 The basics of functions

❖ Programming with functions

▪ Recursive functions

59
 Chapter II. Modular programming in C++

❖ The basics of functions

❖ How to use functions on a more professional level?
❖ Namespaces and storage classes
❖ Preprocessor directives of C++

60
 How to use functions on a more professional level?

❖ Inline functions
❖ Overloading (redefining) function names
❖ Function templates

61
 How to use functions on a more professional level?

❖ Inline functions
• C++ compilers decrease the time spent on calling the functions
marked with the keyword inline.
• This solution is recommended to be used for small-sized and
frequently called functions.

62
 How to use functions on a more professional level?

❖ Inline functions

63
 How to use functions on a more professional level?

❖ Inline functions
❖ Overloading (redefining) function names
❖ Function templates

64
 How to use functions on a more professional level?

❖ Overloading (redefining) function names

• Different functions can be defined with the same name and
within the same scope but with a different parameter list.

65
 How to use functions on a more professional level?

❖ Overloading (redefining) function names

66
 How to use functions on a more professional level?

❖ Inline functions
❖ Overloading (redefining) function names
❖ Function templates

67
 How to use functions on a more professional level?

❖ Function templates
▪ Creating and using function templates
• A template declaration starts with the keyword template,
followed by the parameters of the template enclosed within the
signs < and >.

68
 How to use functions on a more professional level?

❖ Function templates
▪ Creating and using function templates

69
 How to use functions on a more professional level?

❖ Function templates
▪ Creating and using function templates

70
 How to use functions on a more professional level?

❖ Function templates
▪ Function template instantiation
• A function template can be instantiated in an explicit way as well
if concrete types are provided in the template line containing the
header of the function:

71
 How to use functions on a more professional level?

❖ Function templates
▪ Function template specialization

72
 How to use functions on a more professional level?

❖ Function templates
▪ Some further function template examples

73
 How to use functions on a more professional level?

❖ Function templates
▪ Some further function template examples

74
 How to use functions on a more professional level?

❖ Function templates
▪ Some further function template examples

75
 Chapter II. Modular programming in C++

❖ The basics of functions

❖ How to use functions on a more professional level?
❖ Namespaces and storage classes
❖ Preprocessor directives of C++

76
 Namespaces and storage classes

❖ Storage classes of variables

❖ Storage classes of functions
❖ Modular programs in C++
❖ Namespaces

77
 Namespaces and storage classes

❖ Storage classes of variables

▪ A storage class:
• defines the lifetime or storage duration of a variable,
• determines the place from where the name of a variable can be
accessed directly – visibility, scope – and also determines which
name designates which variable – linkage.

▪ A storage class (auto, register, static, extern) can be assigned to

variables when they are defined.

78
 Namespaces and storage classes

❖ Storage classes of variables

79
 Namespaces and storage classes

❖ Storage classes of variables

▪ Accessibility (scope) and linkage of variables
• In a C++ source code, variables can have one of the following scopes:
A variable of this type is only visible in the block (function block) where it has been
block defined so its accessibility is local.
level If a variable is defined on a block level without the storage classes extern and static,
it does not have any linkage.

A file level variable is only visible in the module containing its declaration.
Identifiers having file level scope are those that are declared outside the functions
file level
of the module and that are declared with internal linkage using the static storage
class.

A program level variable is accessible from the functions of all the modules (all
program compilation units) of a program.
level Global variables that are declared outside the functions of a module (that is
with external linkage) have program level scope. 80
Namespaces and storage classes

Variable scopes

81
 Namespaces and storage classes

❖ Storage classes of variables

▪ Lifetime of variables
• A lifetime is a period of program execution where the given
variable exists.

Identifiers having a static or extern storage class have a static

static lifetime
lifetime.

automatic Within blocks, variables defined without the static storage class and
lifetime the parameters of functions have automatic (local) lifetime.

Independently of their storage classes, memory blocks that are

dynamic
allocated by the operator new and deallocated by the
lifetime
operator delete have dynamic lifetime. 82
 Namespaces and storage classes

❖ Storage classes of variables

▪ Storage classes of block level variables
• Automatic variables: Automatic variables are created when
control is passed to their block and they are deleted when that
block is exited.

83
 Namespaces and storage classes

❖ Storage classes of variables

▪ Storage classes of block level variables
• The register storage class: The register storage class can only be
used for automatic local variables and function parameters.

84
 Namespaces and storage classes

❖ Storage classes of variables

▪ Storage classes of block level variables
• Local variables with static lifetime.

85
 Namespaces and storage classes

❖ Storage classes of variables

▪ Storage classes of file level variables

86
 Namespaces and storage classes

❖ Storage classes of variables

▪ Storage classes of program level variables

Same definitions (only one of them can

Declarations
be used)
double sum; extern double sum;
double sum = 0;
extern double sum = 0;
int vector[12]; extern int vector[];
extern int vector[12] = {0}; extern int vector[12];
extern const int size = 7; extern const int size;

87
 Namespaces and storage classes

❖ Storage classes of variables

❖ Storage classes of functions
❖ Modular programs in C++
❖ Namespaces

88
 Namespaces and storage classes

❖ Storage classes of functions

Definitions (only one of them can be used) Prototypes

double GeomMean(double a, double b) { double GeomMean(double, double);

return sqrt(a*b); }
extern double GeomMean(double a, extern double GeomMean(double,
double b) { return sqrt(a*b); } double);
static double GeomMean(double a, double static double GeomMean(double,
b) { return sqrt(a*b); } double);

89
 Namespaces and storage classes

❖ Storage classes of functions

90
 Namespaces and storage classes

❖ Storage classes of functions

• Accessing the compiled C functions from within C++ source: use
the extern "C" declaration.

91
 Namespaces and storage classes

❖ Storage classes of variables

❖ Storage classes of functions
❖ Modular programs in C++
❖ Namespaces

92
 Namespaces and storage classes

❖ Modular programs in C++

93
 Namespaces and storage classes

❖ Modular programs in C++

94
 Namespaces and storage classes

❖ Storage classes of variables

❖ Storage classes of functions
❖ Modular programs in C++
❖ Namespaces

95
 Namespaces and storage classes

❖ Namespaces
▪ The default namespaces of C++ and the scope operator
• C++ enclose Standard library elements in the namespace
called std.
• In order to be able to refer the elements of a namespace, we
have to know how to use the scope operator (::).
• With the help of :: operator, we can refer names having file and
program level scope (that is identifiers of the global namespace)
from any block of a program.

96
 Namespaces and storage classes

❖ Namespaces
▪ The default namespaces of C++ and the scope operator

97
 Namespaces and storage classes

❖ Namespaces
▪ Creating and using user-defined namespaces
• Creating namespaces

98
 Namespaces and storage classes

❖ Namespaces
▪ Creating and using user-defined namespaces
• Accessing the identifiers of a namespace
Directly by using the scope operator: Or by using the directive using namespace:

99
 Namespaces and storage classes

❖ Namespaces
▪ Creating and using user-defined namespaces
• Accessing the identifiers of a namespace
Or by providing using -declarations:

100
 Namespaces and storage classes

❖ Namespaces
▪ Creating and using user-defined namespaces
• Nested namespaces, namespace aliases:

101
 Namespaces and storage classes

❖ Namespaces
▪ Creating and using user-defined namespaces
• Nested namespaces, namespace aliases:

102
 Namespaces and storage classes

❖ Namespaces
▪ Creating and using user-defined namespaces
• Nested namespaces, namespace aliases:

103
 Namespaces and storage classes

• Anonymous namespaces:

104
 Chapter II. Modular programming in C++

❖ The basics of functions

❖ How to use functions on a more professional level?
❖ Namespaces and storage classes
❖ Preprocessor directives of C++

105
Preprocessor directives of C++

The compilation process in C++ 106

 Preprocessor directives of C++

❖ Including files
❖ Conditional compilation
❖ Using macros

107
 Preprocessor directives of C++

❖ Including files

The following table sums up the keywords and language elements that
can be used in header files:
C++ elements Example
Comments // comment
Conditional directives #ifdef MOTOROLA
Macro definitions #define INTEL
#include directives #include <string>
Enumerations enum response {no, yes, maybe};
Constant definitions const double pi=3.1415265; 108
 Preprocessor directives of C++

❖ Including files

C++ elements Example

Namespaces having an identifier namespace nsrand { }
Name declarations struct vector3D;
Type definitions struct complex {double re, im;};
Variable declarations extern double point[];
Function prototypes double Average(double, double);
inline function definitions inline int Sqr(int a) {return a*a;}
template declarations template <class T> T Sqr(T a);
template <class T> T Sqr(T a)
template definitions
{return a*a;}
109
 Preprocessor directives of C++

❖ Including files
The following elements should never be placed in include files:

• definitions of non-inline functions,

• variable definitions,
• definitions of anonymous namespaces.

110
 Preprocessor directives of C++

❖ Including files
➢ One part of the elements that can be placed in a header file have
to be included only once in a code.
➢ That is why, all header files have to have a special preprocessing
structure based on conditional directives:

111
 Preprocessor directives of C++

❖ Including files
❖ Conditional compilation
❖ Using macros

112
 Preprocessor directives of C++

❖ Conditional compilation
• The code parts to be compiled under conditions can be selected
in many ways, by using the following preprocessor directives:
#if, #ifdef, #ifndef, #elif, #else and #endif.

113
 Preprocessor directives of C++

❖ Conditional compilation
• Instead of the structure above, it is better to use a solution that
examines the definition of the symbol TEST.

114
 Preprocessor directives of C++

❖ Conditional compilation
• Each pair of the following checkings return the same results:

#if defined(TEST) #ifdef TEST

... // defined ... // defined
#endif #endif

#if !defined(TEST) #ifndef TEST

... // not defined ... // not defined
#endif #endif

115
 Preprocessor directives of C++

❖ Conditional compilation
• If the following structure is used, we can choose between two
code parts:

116
 Preprocessor directives of C++

❖ Conditional compilation
• The following example creates the two-dimensional array named
array depending on the value of the symbol SIZE:

117
 Preprocessor directives of C++

❖ Conditional compilation
• For more complex structures, it is recommended to use multi-
way branches.

118
 Preprocessor directives of C++

❖ Conditional compilation
• The following example integrates the declaration file on the basis
of the manufacturer:

119
 Preprocessor directives of C++

❖ Including files
❖ Conditional compilation
❖ Using macros

120
 Preprocessor directives of C++

❖ Using macros
▪ Symbolic constants
• Symbolic constants can be created by using the simple form of
the #define directive:

121
 Preprocessor directives of C++

❖ Using macros
▪ Symbolic constants

122
 Preprocessor directives of C++

❖ Using macros
▪ Parameterized macros
• The macros can be efficiently used in much more cases if they
are parameterized. The general form of a function-like
parameterized macro:

• Using (calling) a macro:

123
 Preprocessor directives of C++

❖ Using macros
▪ Parameterized macros

124
 Preprocessor directives of C++

❖ Using macros
▪ Parameterized macros
• All advantages of macros (type-independence, faster code) can
be achieved by using inline functions/function templates
(instead of macros) while keeping the C++ code legible:

125
 Preprocessor directives of C++

❖ Using macros
▪ Undefining a macro
• A macro can be undefined anytime and can be redefined again,
even with a different content. It can be undefined by using
the #undef directive.
Original source code Substituted code
int main() {
#define MACRO(x) (x) + 7
int main() {
int a = MACRO(12);
int a = (12) + 7;
#undef MACRO
a = MACRO(12);
a = MACRO(12);
a = 123
#define MACRO 123
}
a = MACRO
}
126
 Preprocessor directives of C++

❖ Using macros
▪ Macro operators
• If the # character is placed before the parameter in a macro, the
value of the parameter is replaced as enclosed within quotation
marks (i.e. as a string).

127
 Preprocessor directives of C++

❖ Using macros
▪ Macro operators
• By using the ## operator, two syntactic units (tokens) can be
concatenated.

128
 Preprocessor directives of C++

❖ Using macros
▪ Predefined macros
Macro Description Example
__DATE__ String constant containing the date of the compilation. "Oct 02 2013"

__TIME__ String constant containing the time of the compilation. "10:02:04"

__TIMESTAMP_ The date and time of the last modification of the source file "Mon Jul 29
_ in a string constant" 07:33:29 2013"
"c:\\preproc.cpp
__FILE__ String constant containing the name of the source file.
"
A numeric constant, containing the number of the actual
__LINE__ 1223
line of the source file (numbering starts from 1).
Its value is 1 if the compiler works as an ANSI C++,
__STDC__
otherwise it is not defined.
Its value is 1, if its value is tested in a C++ source file,
__cplusplus 129
otherwise it is not defined.
 Preprocessor directives of C++

❖ Using macros
▪ #line, #error and #pragma directives
• The #line directive forces C++ compilers not to signal the error
code in the C++ source text but in the original source file written
in another special language.

130
 Preprocessor directives of C++

❖ Using macros
▪ #line, #error and #pragma directives
• An #error directive can be used to print out a compilation error
message which contains the text provided in the statement:

#error error_message

131
 Preprocessor directives of C++

❖ Using macros
▪ #line, #error and #pragma directives
• #pragma directives are used to control the compilation process
in an implementation-dependent way.

• The empty directive (#) can also be used, but it does not affect
preprocessing.
132