Introduction to C++: Part 1

tutorial version 0.7

Research Computing Services

Getting started with the training room terminals

 Log on with your BU username

 If you don’t have a BU username:
 Username: Choose tutm1-tutm18, tutn1-tutn18
 Password: on the board.
SCC OnDemand

 Based on an NSF-funded open source project “Open OnDemand”,

developed by the Ohio Supercomputing Center (OSC) and fully
customized for the BU Shared Computing Cluster (SCC). Provides cluster
access entirely through a webbrowser.

 Provides:
 Easy file management
 Command-line shell access
 Graphical desktop environments and desktop applications
 Web-server based applications (e.g. RStudio, Jupyter, Tensorboard)
 Existing SCC Account Temporary Tutorial Account
1. Open a web browser 1. Open a web browser
2. Navigate to http://scc-ondemand.bu.edu 2. Navigate to http://scc-ondemand-2fa.bu.edu
3. Log in with your BU Kerberos Credentials 3. Log in with Tutorial Account
Click on Interactive Apps/Desktop
eclipse/2019-06

click
When your desktop is ready click Connect to Desktop
 Enter this command to create a
directory in your home folder and to
copy in tutorial files:
/net/scc2/scratch/intro_to_cpp.sh
Run the Eclipse software

 Enter this command to start up the Eclipse development

environment. eclipse &

 When this window appears just click the Launch button:

Run the Eclipse software

 When this window appears just leave it be for now.

Tutorial Outline: All 4 Parts

 Part 1:  Part 3:
 Intro to C++  Defining C++ classes
 Object oriented concepts  Look at the details of how they
 Write a first program work
 Part 2:  Part 4:
 Using C++ objects  Class inheritance
 Standard Template Library  Virtual methods
 Basic debugging  Available C++ tools on the
SCC
Tutorial Outline: Part 1

 Very brief history of C++

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

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

C++
 “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, compilers
are high quality.
 Object oriented
 With support for many programming styles (procedural, functional, etc.)
 No automatic memory management (mostly)
 The programmer is in control of memory usage
 When to choose C++
 Despite its many competitors C++ has remained popular for ~30 years and will
continue to be so in the foreseeable future.

 Why?
 Complex problems and programs can be effectively implemented
 OOP works in the real world.

 No other language quite matches C++’s combination of performance, libraries,

expressiveness, and ability to handle complex programs.
 “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++)

 Choose C++ when:

 Program performance matters
 Dealing with large amounts of data, multiple CPUs, complex algorithms, etc.

 Programmer productivity is less important

 You’ll get more code written in less time in a languages like Python, R, Matlab, etc.

 The programming language itself can help organize your code

 In C++ your objects can closely model elements of your problem
 Complex data structures can be implemented

 Access to a vast number of libraries

 Your group uses it already!
Eclipse https://www.eclipse.org
 In this tutorial we will use the Eclipse integrated development environment
(IDE) for writing and compiling C++

 About Eclipse
 Started in 2001 by IBM.
 The Eclipse Foundation (2004) is an independent, non-profit corporation that maintains and
promotes the Eclipse platform.
 Cross-platform: supported on Mac OSX, Linux, and Windows
 Supports numerous languages: C++, C, Fortran, Java, Python, and more.

 A complex tool that can be used by large software teams.

 IDE Advantages IDEs available on the SCC
 Eclipse (used here)
 Handles build process for you
 geany – a minimalist IDE, simple to use
 Syntax highlighting and live error detection
 Netbeans – used in past C++ tutorials.
 Code completion (fills in as you type) Simpler than Eclipse but still capable.
 Creation of files via templates  Spyder – Python only, part of Anaconda
 Built-in debugging  Emacs – The one and only.
 Code refactoring (ex. Change a variable
name everywhere in your code)
 Much higher productivity compared with
plain text editors!
 …once you learn how to use it. Some Others
 Xcode for Mac OSX
 Visual Studio for Windows
 Visual Studio Core plus plugins
 Code::Blocks (cross platform)
 A first program

 Click Create a new C++ project

in the Eclipse window.
 A first program
 For a project name use hello_world
 Choose a Hello World C++ Project
and the Linux GCC toolchain.

 This version of Eclipse is their “IDE

for Scientific Computing” package.

 Then click the Next button.

 A first program
 Add your name

 Everything else can stay the same.

 Click Next.
 A first program
 Last screen. Don’t change anything
here, just click Finish.
 A first program
 Now click the Workbench button in the welcome screen to go to the newly
created project.
 hello_world.cpp
has been auto-
generated.

 Under the Project

menu select the
Build Project
option.

 Then click the

Run button:
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 arguments to allow access to command
line arguments.

The two characters // together indicate a comment that is

ignored by the compiler.

The return statement 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++ (along with C) uses header files as to hold definitions for the compiler to use while
compiling.
 A source file (file.cpp) contains the code that is compiled into an object file (file.o).
 The header (file.h) is used to tell the compiler what to expect when it assembles the
program in the linking stage from the object files.

 Source files and header files can refer to any number of other header files.

 When compiling the linker connects all of the object (.o) files together into the
executable.
 Make some changes
 Let’s put the message into some variables #include <iostream>
using namespace std;
of type string and print some numbers.
 Things to note: int main() {
 Strings can be concatenated with a + operator. string hello = "Hello";
string world = "world!";
 No messing with null terminators or strcat() as in
string msg = hello + " " +
C
world ;
 Some string notes: cout << msg << endl;
 Access a string character by brackets or msg[0] = 'h';
function: cout << msg << endl;
 msg[0]  “H” or msg.at(0)  “H” return 0;
}
 C++ strings are mutable – they can be
changed in place.
 Re-run and check out the output.
A first C++ class: string
#include <iostream>
 string is not a basic type (more using namespace std;
on those later), it is a class.
int main() {
 string hello creates an string hello = "Hello";
instance of a string called hello. string world = "world!";
string msg = hello + " " +
 hello is an object. It is world ;
cout << msg << endl;
initialized to contain the string msg[0] = 'h';
“Hello”. cout << msg << endl;
return 0;
 A class defines some data and a }
set of functions (methods) that
operate on that data.
A first C++ class: string

 Update the code as you see #include <iostream>

using namespace std;
here.
int main() {
 After the last character is entered string hello = "Hello";
Eclipse will display a large string world = "world!";
number of methods defined for string msg = hello + " " + world ;
cout << msg << endl;
the msg object. msg[0] = 'h';
cout << msg << endl;
 If you click or type something
else just delete and re-type the msg.
trailing period.
return 0;
}
 A first C++ class: string

 Start typing the word size until

it appears in the menu.
 Hit the Enter key to accept it.

 Now hover your mouse cursor

over the msg.size() code and a
help window will pop up.
 #include <iostream>

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

int main()
 Tweak the code to print the number {
string hello = "Hello" ;
of characters in the string, build, and string world = "world!" ;
run it. string msg = hello + " " + world ;
cout << msg << endl ;
msg[0] = 'h';
cout << msg << endl ;
 size() is a public method, usable by
code that creates the object. cout << msg.size() << endl ;

return 0;
}
 The internal tracking of the size and
the storage itself is private, visible  cout prints integers
only inside the string class source without any modification!
code.
Break your code.

 Remove a semi-colon. Re-compile. What messages do you get from the

compiler and Eclipse?

 Fix that and break something else. Capitalize string  String

 C++ can have elaborate error messages when compiling. Experience is

the only way to learn to interpret them!

 Fix your code so it still compiles and then we’ll move on…
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;
float y;
 Variables are declared with a type and a name: vector<string> vec ;
// Sometimes types can be
// inferred in C++11
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.
Built-in (aka primitive or intrinsic) Types
 “primitive” or “intrinsic” means these types are not objects.
 They have no methods or internal hidden data.
 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/
 const float pi = 3.14 ;
Read-Only Types const string w = "Const String" ;

 The const keyword can be combined with any type declaration to make
read-only variables.

 Assignment can happen during a function call.

 The compiler will stop with an error if a const variable has a new value
assigned to it in your code.
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.
A pointer to the hello object string. hello_ptr
string *hello_ptr = &hello;
is assigned the memory address of object
string &hello_ref = hello; hello which is accessed with the “&” syntax.

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 later in the tutorial.
Type Casting
 C++ is strongly typed. It will auto-convert a variable of one type to another where it can.

short x = 1 ;
int y = x ; // OK
string z = y ; // NO

 Conversions that don’t change value work as expected:

 increasing precision (float  double) or integer  floating point of at least the same precision.

 Loss of precision usually works fine:

 64-bit double precision  32-bit single precision.
 But…be careful with this, if the larger precision value is too large the result might not be what you expect!
Type Casting
 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 when using C++ it’s best to stick with deliberate type casting using the 4 different
ways that are offered…
Type Casting double d = 1234.56 ;
float f = static_cast<float>(d) ;
// same as
float g = (float) d ;
 static_cast<new type>( expression ) // same as
float h = d ;
 This is exactly equivalent to the C style cast.
 This identifies a cast at compile time.
 This makes it clear to another programmer that you really intended a cast that
reduces precision (ex. double  float) even if it would happen automatically.
 ~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.
 Usually created automatically by the compiler where needed, rarely done by the
programmer.
 Type Casting – rarely used versions Danger!

 const_cast<new type>( expression )

 Variables labeled as const can’t have their value changed.
 const_cast lets the programmer remove or add const to reference or pointer type
variables.
 If you need to do this, you probably want to re-think your code! “unsafe”: the
compiler will not
 reinterpret_cast<new type>( expression ) protect you here!

 Takes the bits in the expression and re-uses them unconverted as a new type. Also The programmer
only works on reference or pointer type variables. must make sure
 Sometimes useful when reading or writing binary files or when dealing with hardware everything is
correct!
devices like serial or USB ports.
 The function arguments L and W
The return type is float. are sent as type float.
Functions float RectangleArea1(float L, float W) {
return L*W ;
 Open the project “FunctionExample” in } Product is computed and returned
the Part 1 Eclipse project file.
 Compile and run it!

 Open Functions.cpp float RectangleArea2(const float L, const float W) {

// L=2.0 ;
 4 function calls are listed. return L*W ;
 The 1st and 2nd functions are identical in }
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,
 The 3rd and 4th versions pass the float& area) {
arguments by reference with an added & area= L*W ;
}
 Organization of FunctionExample
 Functions.cpp
 Code that implements 4 functions.

 Functions.h
 Header file that declares the 4 functions.

 FunctionExample.cpp
 Contains the “main” routine.
 Includes the Functions.h file so the 4 functions can be called.

 FunctionExample.cpp and Functions.cpp are compiled separately.

 The header file insures the code being generated and being called is correct.

 The FunctionExample.o and Functions.o object files are linked to make the executable.
Using the Eclipse Debugger
 To show how these functions work we will use the Eclipse interactive debugger to step through the program
line-by-line to follow the function calls.
 Click the Debug button:
Add Breakpoints
 Breakpoints tell the debugger to halt at a
particular line so that the state of the
program can be inspected.
 Right-click over the line numbers, go to
Breakpoint Types and choose C/C++
Breakpoints
 Double click next to the line numbers in
the functions to add breakpoints.

 Click the green arrow in the toolbar to

resume the program.
 The debugger will pause the
program at the first
breakpoint.

 In the right hand window

you’ll see the argument
values. Click one for details.

 Let’s step through this: