Introduction to C++: Part 1

tutorial version 0.2

Brian Gregor
Research Computing Services
Getting started with the room B27 terminals

 Log on with your BU username

 On the desktop is a Training Files folder. Open it and go to the subfolder:

RCS_Tutorials\Tutorial Files\Introduction to C++

 Copy the CodeBlocks Projects folder to your desktop.

Getting started on the SCC

 If you prefer to work on the SCC and have your own account, login using
your account to the host scc2.bu.edu
 On the room terminals there is a MobaXterm link on the desktop

 Load the codeblocks module: module load gcc/5.3.0

module load hunspell/1.4.1
module load wxwidgets/2.8.12
module load gdb/7.11.1
module load codeblocks

 Make a folder in your home directory and copy in the files:

mkdir cpp_tutorial && cd !$
unzip /scratch/Intro_to_Cpp_Summer_2017_v0.2_Code_1-3.zip
Getting started with your own laptop
 Go to:
http://www.bu.edu/tech/support/research/training-consulting/live-tutorials/
and download the Powerpoint or PDF copy of the unified presentation.
 Easy way to get there: Google “bu rcs tutorials” and it’s the 1st or 2nd link.
 Also download the “Additional Materials” file and unzip it to a convenient folder on your laptop.
 Download the Code::Blocks development environment:
http://www.codeblocks.org/downloads/26
 Windows: get the codeblocks-16.01mingw-nosetup.zip file and unzip it to a convenient
folder.
 Linux: likely available from your Linux distro’s package management system
 Mac OSX: get the CodeBlocks-13.12-mac.zip file and unzip it to a convenient folder.
 Also you will need Apple’s Xcode software with the command line tools installed.
 See: http://www.dummies.com/programming/cpp/how-to-install-c-codeblocks-in-macintosh/
Tutorial Outline: Part 1

 Very brief history of C++

 Definition object-oriented programming
 When C++ is a good choice
 The Code::Blocks IDE
 Object-oriented concepts
 First program!
 Some C++ syntax
 Function calls
 Create a C++ class
Very brief history of C++

For details more check out A History of C++: 1979−1991

C++
 class GasMolecule

Object-oriented programming • Data:

• molecular weight, structure, common
names, etc.
 Object-oriented programming • Methods:
• IR(wavenumStart, wavenumEnd) :
(OOP) seeks to define a program in return IR emission spectrum in range

terms of the things in the problem (files,

molecules, buildings, cars, people,
Objects (instances of a class)
etc.), what they need, and what they
can do. GasMolecule ch4
GasMolecule co2
“pseudo-code”

spectrum = ch4.IR(1000,3500)
Name = co2.common_name
 “Class Car”
Object-oriented programming
 OOP defines classes to represent these
things. public interface
 Classes can contain data and methods
(internal functions).
 Classes control access to internal data
and methods. A public interface is used
by external code when using the class.
 This is a highly effective way of modeling
real world problems inside of a computer
program.

private data and methods

 “Actually I made up the term ‘object-oriented’, and I can tell you I did
Characteristics of C++ not have C++ in mind.”
– Alan Kay (helped invent OO programming, the Smalltalk language, and the GUI)

 C++ is…
 Compiled.
 A separate program, the compiler, is used to turn C++ source code into a form directly
executed by the CPU.
 Strongly typed and unsafe
 Conversions between variable types must be made by the programmer (strong typing) but can
be circumvented when needed (unsafe)
 C compatible
 call C libraries directly and C code is nearly 100% valid C++ code.
 Capable of very high performance
 The programmer has a very large amount of control over the program execution
 Object oriented
 With support for many programming styles (procedural, functional, etc.)
 No automatic memory management
 The programmer is in control of memory usage
 “If you’re not at all interested in performance,
shouldn’t you be in the Python room down the hall?”
When to choose C++ ― Scott Meyers (author of Effective Modern C++)

 Despite its many competitors C++ has  Choose C++ when:

remained popular for ~30 years and will  Program performance matters
continue to be so in the foreseeable  Dealing with large amounts of data, multiple
future. CPUs, complex algorithms, etc.
 Why?  Programmer productivity is less important
 It is faster to produce working code in
 Complex problems and programs can be
Python, R, Matlab or other scripting
effectively implemented languages!
 OOP works in the real world!  The programming language itself can help
 No other language quite matches C++’s organize your code
combination of performance,  Ex. In Matlab almost everything is a vector
expressiveness, and ability to handle or matrix.
complex programs.  Access to libraries that will help with your
problem
 Ex. Nvidia’s CUDA Thrust library for GPUs
 Your group uses it already!
Code::Blocks
 In this tutorial we will use the Code::Blocks integrated development
environment (IDE) for writing and compiling C++
 Run it right on the terminal or on the SCC (module load codeblocks)
 About C::B
 cross-platform: supported on Mac OSX, Linux, and Windows
 Oriented towards C, C++, and Fortran, supports others such as Python
 Short learning curve compared with other IDEs such as Eclipse or Visual Studio
 Has its own automated code building system, so we can concentrate on
C++
 It can convert its build system files to make and Makefiles so you are not tied to C::B
 Project homepage: http://www.codeblocks.org
 IDE Advantages IDEs available on the SCC
 Code::Blocks (used here)
 Handles build process for you
 geany – a minimalist IDE, simple to use
 Syntax highlighting and live error detection
 Eclipse – a highly configurable, adaptable
 Code completion (fills in as you type) IDE. Very powerful but with a long
 Creation of files via templates learning curve
 Built-in debugging  Spyder – Python only, part of Anaconda
 Code refactoring (ex. Change a variable
name everywhere in your code)
 Higher productivity
Some Others
 Xcode for Mac OSX
 Visual Studio for Windows
 NetBeans (cross platform)
Opening C::B

 The 1st time it is opened C::B will search for compilers it can use.
 A dialog that looks like this will open. Select GCC if there are multiple
options:

 And click OK.

Opening C::B and creating a 1st C++ project…
 Step 1. Create a project from the File menu or the Start Here tab:
 Step 2. Choose the Console category and then the Console application
and click Go.
 Step 3: Click Next on the “Welcome to the new console application
wizard!” screen.
 Step 4: Choose C++!
 …then click Next.
 Step 5. Enter a project title. Let C::B fill in the other fields for you. If you
like you can change the default folder to hold the project. Click Next.
 Step 6: Choose the compiler. For this tutorial, choose GNU GCC as the
compiler. Click Next.
Enable C++11 standard
 Step 7.l Right-click on your
project name and choose
Build options

 Check off the C++11 option. Click Release on the left and do the
same there as well.
 Do this anytime we create a project in C::B
 Step 8: Your project is now created! Click on Sources in the left column,
then double-click main.cpp.
 Click the icon in the toolbar or press F9 to compile and run the
program.
 Hello, World!
 Console window:

 Build and compile

messages
Behind the Scenes: The Compilation Process
Hello, World! explained

The main routine – the start of every C++ program! It

returns an integer value to the operating system and (in
this case) takes no arguments: main()

Statement that returns an integer value to the

operating system after completion. 0 means “no
error”. C++ programs must return an integer value.
 loads a header file containing function and class
definitions
Hello, World! explained
Loads a namespace called std. Namespaces are used to
separate sections of code for programmer convenience.
To save typing we’ll always use this line in this tutorial.

cout is the object that writes to the stdout device, i.e. the console window.
It is part of the C++ standard library. Without the “using namespace std;”
line this would have been called as std::cout. It is defined in the iostream
header file.
<< is the C++ insertion operator. It is used to pass characters from the
right to the object on the left. endl is the C++ newline character.
 Header Files C++ language headers aren’t referred
to with the .h suffix. <iostream>
provides definitions for I/O functions,
including the cout function.
 C++ (along with C) uses header files as to
hold definitions for the compiler to use
while compiling. #include <iostream>

 A source file (file.cpp) contains the code using namespace std;

that is compiled into an object file (file.o).
int main()
 The header (file.h) is used to tell the {
compiler what to expect when it string hello = "Hello";
assembles the program in the linking string world = "world!";
stage from the object files. string msg = hello + " " + world ;
cout << msg << endl;
 Source files and header files can refer to msg[0] = 'h';
any number of other header files. cout << msg << endl;
return 0;
}
 Slight change
#include <iostream>
 Let’s put the message into some variables
of type string and print some numbers. using namespace std;
 Things to note:
int main()
 Strings can be concatenated with a + operator.
{
 No messing with null terminators or strcat() as in string hello = "Hello";
C string world = "world!";
 Some string notes: string msg = hello + " " + world ;
 Access a string character by brackets or cout << msg << endl;
function: msg[0] = 'h';
cout << msg << endl;
 msg[0]  “H” or msg.at(0)  “H”
return 0;
 C++ strings are mutable – they can be }
changed in place.
 Press F9 to recompile & run.
A first C++ class: string
#include <iostream>
 string is not a basic type (more
on those later), it is a class. using namespace std;

 string hello creates an int main()

instance of a string called “hello”. {
string hello = "Hello";
 hello is an object. string world = "world!";
string msg = hello + " " + world ;
 Remember that a class defines cout << msg << endl;
some data and a set of functions msg[0] = 'h';
cout << msg << endl;
(methods) that operate on that return 0;
data. }

 Let’s use C::B to see what some

of these methods are….
A first C++ class: string
#include <iostream>
 Update the code as you see
here. using namespace std;

 After the last character is entered int main()

C::B will display some info about {
string hello = "Hello";
the string class. string world = "world!";
string msg = hello + " " + world ;
 If you click or type something cout << msg << endl;
else just delete and re-type the msg[0] = 'h';
cout << msg << endl;
last character.
msg

return 0;
}
A first C++ class: string

Shows this
function
(main) and the
List of string type of msg
methods (string)
List of other
string objects

 Next: let’s find the size() method without scrolling for it.
A first C++ class: string
 Start typing “msg.size()” until it appears in the list. Once it’s highlighted (or you
scroll to it) press the Tab key to auto-enter it.
 On the right you can click “Open declaration” to see how the C++ compiler defines
size(). This will open basic_string.h, a built-in file.
 #include <iostream>

A first C++ class: string using namespace std;

int main()
{
 Tweak the code to print the string hello = "Hello" ;
string world = "world!" ;
number of characters in the string msg = hello + " " + world ;
string, build, and run it. cout << msg << endl ;
msg[0] = 'h';
 From the point of view of main(), cout << msg << endl ;
the msg object has hidden away
cout << msg.size() << endl ;
its means of tracking and
retrieving the number of return 0;
}
characters stored.
 Note: while the string class has a
huge number of methods your  Note that cout prints integers
typical C++ class has far fewer! without any modification!
 More on this behavior later.
Basic Syntax
 C++ syntax is very similar to C, Java, or C#. Here’s a few things up front and we’ll cover
more as we go along.
 Curly braces are used to denote a code block (like the main() function):
{ … some code … }
 Statements end with a semicolon:
int a ;
a = 1 + 3 ;

 Comments are marked for a single line with a // or for multilines with a pair of /* and */ :
// this is a comment.
/* everything in here
is a comment */

void my_function() {
 Variables can be declared at any time in a code block. int a ;
a=1 ;
int b;
}
 Functions are sections of code that are called from other code. Functions always have a
return argument type, a function name, and then a list of arguments separated by
commas:

int add(int x, int y) { // No arguments? Still need ():

int z = x + y ; void my_function() {
return z ; /* do something...
} but a void value means the
return statement can be skipped.*/
}

 A void type means the function does not return a value.

// Specify the type

int x = 100;
 Variables are declared with a type and a name: float y;
vector<string> vec ;
// Sometimes types can be inferred
auto z = x;
 A sampling of arithmetic operators:
 Arithmetic: + - * / % ++ --
 Logical: && (AND) ||(OR) !(NOT)
 Comparison: == > < >= <= !=

 Sometimes these can have special meanings beyond arithmetic, for

example the “+” is used to concatenate strings.

 What happens when a syntax error is made?

 The compiler will complain and refuse to compile the file.
 The error message usually directs you to the error but sometimes the error occurs before the
compiler discovers syntax errors so you hunt a little bit.
 Take the working Hello World! main() and try messing with it: delete a “;”, then compile, see
the error. Put it back, then make another change. See what the compiler does!
Built-in (aka primitive or intrinsic) Types
 “primitive” or “intrinsic” means these types are not objects
 Here are the most commonly used types.
 Note: The exact bit ranges here are platform and compiler dependent!
 Typical usage with PCs, Macs, Linux, etc. use these values
 Variations from this table are found in specialized applications like embedded system processors.

Name Name Value Name Value

char unsigned char 8-bit integer float 32-bit floating point
short unsigned short 16-bit integer double 64-bit floating point
int unsigned int 32-bit integer long long 128-bit integer
long unsigned long 64-bit integer long double 128-bit floating point
bool true or false

http://www.cplusplus.com/doc/tutorial/variables/
Need to be sure of integer sizes?
 In the same spirit as using integer(kind=8) type notation in Fortran, there are type definitions that
exactly specify exactly the bits used. These were added in C++11.
 These can be useful if you are planning to port code across CPU architectures (ex. Intel 64-bit
CPUs to a 32-bit ARM on an embedded board) or when doing particular types of integer math.
 For a full list and description see: http://www.cplusplus.com/reference/cstdint/

#include <cstdint>
Name Name Value
int8_t uint8_t 8-bit integer
int16_t uint16_t 16-bit integer
int32_t uint32_t 32-bit integer
int64_t uint64_t 64-bit integer
Reference and Pointer Variables
The object hello
occupies some
string hello = "Hello"; computer memory.
The asterisk indicates that hello_ptr is a
string *hello_ptr = &hello;
pointer to a string. hello_ptr variable is
string &hello_ref = hello; assigned the memory address of object hello
which is accessed with the “&” syntax.

The & here indicates that hello_ref is a reference to a

string. The hello_ref variable is assigned the memory
address of object hello automatically.

 Variable and object values are stored in particular locations in the computer’s memory.
 Reference and pointer variables store the memory location of other variables.
 Pointers are found in C. References are a C++ variation that makes pointers easier and safer to
use.
 More on this topic in Part 2.
Type Casting
 C++ is strongly typed. It will auto-convert a variable of one type to another in a limited fashion: if it
will not change the value.
short x = 1 ;
int y = x ; // OK
short z = y ; // NO!

 Conversions that don’t change value: increasing precision (float  double) or integer  floating
point of at least the same precision.
 C++ allows for C-style type casting with the syntax: (new type) expression

double x = 1.0 ;
int y = (int) x ;
float z = (float) (x / y) ;

 But since we’re doing C++ we’ll look at the 4 ways of doing this in C++ next...
Type Casting

 static_cast<new type>( expression ) double d = 1234.56 ;

float f = static_cast<float>(d) ;
 This is exactly equivalent to the C style cast.
 This identifies a cast at compile time.
 This will allow casts that reduce precision (ex. double  float)
 >99% of all your casts in C++ will be of this type.

 dynamic_cast<new type>( expression)

 Special version where type casting is performed at runtime, only works on reference
or pointer type variables.
 Type Casting cont’d Danger!

 const_cast<new type>( expression )

 Variables labeled as const can’t have their value changed.
“unsafe”: the
 const_cast lets the programmer remove or add const to reference or pointer type compiler will
variables. not protect
 If you need to do this, you probably need to re-think your code. you here and
the
programmer
 reinterpret_cast<new type>( expression ) must make
 Takes the bits in the expression and re-uses them unconverted as a new type. Also sure
everything is
only works on reference or pointer type variables.
correct!
 Sometimes useful when reading in binary files and extracting parameters.
 The function arguments L and W
The return type is float. are sent as type float.
Functions
 Open the project “FunctionExample” in float RectangleArea1(float L, float W) {
return L*W ;
C::B files }
 Compile and run it! Product is computed
 Open main.cpp
 4 function calls are listed. float RectangleArea2(const float L, const float W) {
// L=2.0 ;
 The 1st and 2nd functions are identical in return L*W ;
}
their behavior.
 The values of L and W are sent to the function,
multiplied, and the product is returned.
float RectangleArea3(const float& L, const float& W) {
 RectangleArea2 uses const arguments return L*W ;
 The compiler will not let you modify their values in the }
function.
 Try it! Uncomment the line and see what happens
when you recompile.
void RectangleArea4(const float& L, const float& W, float& area) {
 The 3rd
and 4th
versions pass the area= L*W ;
}
arguments by reference with an added &
Using the C::B Debugger
 To show how this works we will use the C::B interactive debugger to step through the program line-by-line to
follow the function calls.
 Make sure you are running in Debug mode. This turns off compiler optimizations and has the compiler include
information in the compiled code for effective debugging.
Add a Breakpoint
 Breakpoints tell the debugger to halt at a
particular line so that the state of the
program can be inspected.
 In main.cpp, double click to the left of the
lines in the functions to set a pair of
breakpoints. A red dot will appear.
 Click the red arrow to start the code in
the debugger.
 The debugger will pause in
the first function at the
breakpoint.
 Click the Debug menu, go to Debugging
Windows, and choose Call Stack. Drag it to Watches shows the
the right, then go back and choose Watches. variables in use and
their values
Drag it to the right. Do the same for the
Breakpoints option. Your screen will look
something like this now…
 Controls (hover mouse over for help):

Call Stack shows the

Place the cursor in the function, functions being called,
click to run to the cursor newest on top.

Run the next line

Step into a function call

Breakpoints lists the
Step out of a function to breakpoints you’ve
the calling function. created.

Step by CPU instruction.

Less useful, generally.