C++ Basics for ROOT User

Why C++ Basics

• C++ is the implementation language of ROOT
• C++ knowledge is a prerequisite to understand most of the ROOT documentation.
• It is used for:
• the Command Line (ROOT commands are interpreted by CINT, a C++ interpreter)
• Macros (interpreted by CINT)
• to collect commands
• to extend ROOT with new functions
• to extend ROOT with new classes
• C++ Shared Libraries (compiled by a C++ compiler)
• to extend ROOT with new functions
• to extend ROOT with new classes
• C++ Applications (compiled by a C++ compiler)
• to use ROOT to built applications

ROOT as pocket calculator:

Variables, Arithmetic and Assignment Expressions, Simple Output

Example :

Explanation:

Comments:

• C++ is a strongly typed language, i.e. variables must be declared before usage
• Int_t is the ROOT type for integers
• Most C++ statements have a closing semicolon
• C++ formatted output looks very strange in the first place, but is easy to use (shift everything you want to output to cout).
• A variable name  consists of a sequence of letters, digits and underscores but may not start with a digit. C++ keywords are not allowed as variable name.
• We use simple one-letter names to keep the examples short and readable. In a program consisting of more than a few lines, names should be chosen to reflect their useage. In this way they serve as documentation, making the program more readable.

Example:

Explanation:

Comments:

• The most important data types for computation s are integer and floating point variables, in ROOT integers are repesented by the type Int_t, floating point numbers by Double_t
• CINT uses the usual rules to convert between integers and floating point numbers
• It is easy to send strings to the output stream

Example :

Explanation:

Comments:

• It is easy to use CINT as pocket calculator by omitting the semicolon after an expression
• CINT declares variables according to the righthand side of an expression. A compiler would flag undeclared variables as errors

Arithmetic and Assignment Operators

Comments:

• With the exception of the increment/decrement and the updating assignment operators the arithmetic is pretty much like in Fortran
• Preincrement/decrement means 1. add/subtract one 2. use the variable
• Postincrement/decrement means 1. use the variable 2. add/subtract one

try
int i;
i = 0;
cout << i++ << endl;
cout << i   << end;
cout << ++i << endl;
• Updating assignment i=i+x; could be written as
i += x;
• There is no exponentiation operator in C++, you have to use a function (CINT knows the Fortran exponentiation)

Example:

Explanation:

Comments:

• It is possible to declare more than one variable in a declaration.
• It is possible to initialize a variable in the declaration.
• ROOT provides a rich set of mathematical functions. See class TMath
• The notation TMath::function() will be explained later.

Program flow constructs:

Functions, Logical Values and Operators, Relational Operators, Control statements

Example:

Double_t mult(Double_t a, Double_t b) {
// multiply a and b
   return a*b;
}

root [0] .L mult.C
root [1] mult(3,4)
(Double_t)1.20000000000000000e+01

Explanation:

Example:

Double_t mult(Double_t a, Double_t b = 2) {
// multiply a and b
   return a*b;
}

Double_t mult() {
// prompt for two numbers and return the product
   Double_t a, b;
   cout << "enter a number:";        // output prompt string
   cin >> a;                         // read input
   cout << "enter a second number:"; // output prompt
   cin >> b;                         // read input
   return a*b;                       // return a*b
}
 

root [0] .L multimult.C
root [1] mult(3,4)
(Double_t)1.20000000000000000e+01
root [2] mult(3)
(Double_t)6.00000000000000000e+00
root [3] mult()
enter a number:4
enter a second number:8
(Double_t)3.20000000000000000e+01

Explanation:

[1]
Calls the mult function with two parameters
[2]
Calls the mult function with two parameters uses the default value
[3]
Calls the mult function without parameters

Comments:

• Overloaded functions are an important feature of C++. It is possible to define functions with the same name but different parameters.
• At least one parameter must be of different type. Two functions with the same parameter list but different return type are not possible.

Example:

void hello(char *name="") {
// print hello name
   cout << "hello " << name << endl;
}

root [0] .L hello.C
root [1] hello()
hello
root [2] hello("Peter")
hello Peter
 

Explanation:

Comments:

• If a function does not return a value it have to be declared with return value void.
• If a function has no parameters it have to be declared with empty parameter list.

Example:

Explanation:

Comments:

• ROOT has a rich set of mathematical functions, see the documentation for class TMATH
• These functions must be called whith the string TMath:: in front, the reason for that will become clear later (they are static member functions).

Logical Values and Operators, Relational Operators

Remarks:

• true and false are relatively new constructs in C++. For backward compatibility 0 means false and every nonzero value is treated as true
• every expression in C++ returns a value, even x = y (the value of x). This leads to a difficult to find bug if one writes if(x=y) instead of if(x==y)

 

Example:

Explanation:

Comments:

• Logical and relational operators are needed to create conditions for the use in control statements.
• 0 means false.
• Nonzero means true.
• C++ evaluates conditions to 0 or 1 ( false or true ).
• Programs are more readable if kTRUE/kFALSE (or true/false) are used instead of 1/0.

Control statements

if(condition) statement

if(condition) statement1
else statement2

while(condition) statement

do statement while(condition);

for(init_expression; cont_expression; incr_expression) statement

break;

continue;

Comments:

• Every time you need more than one statement where the syntax of C++ requires exactly one statement you can use a compound statement, i.e. a list of statements enclosed in curly brackets.
• Remember that every statement has a closing semicolon.
• Use compound statements for the bodies of control statements. The form

if(condition) statement should always be coded in one line.
• Select a code formatting style and use it consistently (throughout your collaboration)
• Use a while-loop when it is possible that the body should not be executed.
• Use a do-while loop when the body should be executed at least once.
• Use for-loops as counting loops.
• break ends the innermost loop
• continue ends the current iteration of the innermost loop

Example:

Explanation:

Comments:

• This is a very easy form to read an ascii file, but it works only if the data in the file matches the data you try to read. If the format does not match you may run into an endless loop.
• The syntax of the line root[1] will become clear later.
• while(kTRUE) ... is the while form of an endless loop. You need a break statement in the loop body to end it.

Example:

Double_t f(Double_t x) { return x*x; }

Double_t fprime(Double_t x) {return 2*x;}

Double_t minimize(Double_t initialGuess, Double_t desiredAccurancy) {
  Double_t x = initialGuess;
  Double_t dx;
  do {
    dx = f(x) / fprime(x);
    x -= dx;
  } while(TMath::Abs(dx) > desiredAccurancy);
  return x;
}

root [0] .L minimize.C
root [1] minimize(1,1e-10)
(Double_t)5.82076609134674070e-11
root [2] minimize(1,1e-100)
(Double_t)5.71493695641137490e-101
 

Explanation:

Comments:

• Later we will be able to provide the functions f(x) and fprime(x) as arguments to minimize.

Example:

Explanation:

Comments:

• The for loop is semantically equivalent to:

init_expression;
while (cont_expression) {
   statement
   incr_expression;
}

• all expressions in the for loop are optional, i.e

for(;;) { statements }
is an endless loop. It could be ended by a break statement.

Bitwise Operators

Comments:

• We will not use these operators in this introduction. They are included here just for reference.

Variables (Objects) and Types (Classes) in more detail

• a value (a state), a particular bit pattern, stored in it
• and a type (a class), which specifies how to interpret and manipulate the object

C++ Fundamental Types

Usage hints:

• Use the ROOT types
• Use Int_t and Double_t unless you have good reasons to use another type
• Do not use the unsigned types unless you have good reasons

Classes

In the following example we use the ROOT class TDatime. A short excerpt from the documentation:

TDatime()
Create a TDatime and set it to the current time.

Int_t GetDate()
Return date in form of 19971224 (i.e. 24/12/1997)

Int_t GetTime()
Return time in form of 123623 (i.e. 12:36:23)

void Print(Option_t *)
Print date and time.

void Set(Int_t date, Int_t time)
Set date and time. Data must be in format 980418 or 19980418 and time in
224512 (second precision). The date must
be >= 950101.
For years >= 2000, date can be given in the form 20001127 or 1001127
internally the date will be converted to 1001127

void Set(Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec)
Set date and time. Year may be xx where 95 <= xx <= 99.
The year must be >= 1995.
 

Example:

Explanation:

Comments:

• An object is an encapsulation of a state (internal data) and behavior (methods).
• The behavior of objects is dictated by the objects class.
• An object will exhibit its behavior by invoking a method (similar to executing a function).
• A declaration of an object calls its constructor, i.e. a method with the same name as the corresponding class.
• Method calls can be overloaded in the same way as ordinary functions. The function to call follows from the number and type of the parameters.

Example:

void timeForLoop(Int_t nMax = 1000000) {
// timing of nMax iterations of a for loop doing nothing

  TStopwatch timer;

  timer.Start();
  for(Int_t i=0; i<nMax; i++);
  timer.Stop();

  cout << " Cpu time for "<< nMax << " iterations " << timer.CpuTime() << endl;
}

root [0] .X timeForLoop.C(10000000)
 Cpu time for 10000000 iterations 7.9
 

Explanation:

Comments:

• TStopwatch is a more interesting class than TDatime in the previous example. The TDatime objects can be created and set to some date, but they are very static.
• TStopwatch objects change the internal state, they count the wallclock time and cpu time between Start() and Stop().

Derived Types

• A variable is an association between a name and an object.
• A reference is an alias for an object.
• A pointer is an object that refers to another object.
• An array is a linear sequence of objects of the same type

Example:

Explanation:

Comments:

• The most important use of reference types is in function arguments and will be explained later.

Example:

Explanation:

Comments:

• Pointers are objects that refer to other objects, i.e. hold the address of other objects.
• If you need an object a pointer is pointing to, you have to use the dereferencing operator *, *p means the object p is pointing to.
• If you need the the address of an object e.g. to initialize an pointer, you have to use the address operator &, &o means the address of object o.
• If you have a pointer to an object, you can use its methods via the -> operator.
• In CINT you may use the . or -> operator to select members, from object variables or from pointers - one of the CINT shortcuts.  C++ requires the form object.member() and objectpointer->member().
• During the inheritance section we will discuss an important difference between objects accessed by name or by pointer (. or ->)

Example:

Explanation:

Comments:

• Arrays elements in C++ are addressed via [ index]
• The first index of an array is 0.
• The last index of an arry with n elements is n-1

Example:

Explanation:

Comments:

• Now we understand the syntax of connecting a file, its just creating an object of class istream.
• istream is part of the C++ library, therfore we can not lookup its documentation on the ROOT page.
• Multidimensional arrays are arrays of arrays, the way to declare e.g. a two dimensional array is

Double_t x[10][20];

Example:

Explanation:

Comments:

• It is possible to declare constants, just put the keyword const in front of the declaration.
• Constants must be initialized in the declaration, it is not possible to set them later.
• Read declarations from the identfier name to the left:

const Int_t *p = &i; // p is pointer to Int_t which is const
Int_t * const p = &i; // p is a const pointer to Int_t
const Int_i * const p = &i; // p is const pointer to Int_t which is const
Int_t **p; // p is a pointer to a pointer to Int_t

Scope and lifetime

Scope: Where is an object known?

• Inside the block it is declared.
• Objects declared in an unnamed macro have global scope.
• Objects declared in a function have function scope.

Lifetime: During which time is an object alive?

• automatic:

from the execution of their declaration until the end of the block in which they are declared
• static:

from the execution of their declaration until the end of the program
• dynamic:

allocated and freed in arbitary order under programmer's control

• all objects we used up to now are automatic

Example:

Int_t countCalls() {
// return how often this function has been called
  static Int_t calls = 0;
  return ++calls;
}

root [0] .L countCalls.C
root [1] countCalls()
(Int_t)1
root [2] countCalls()
(Int_t)2
root [3] countCalls()
(Int_t)3
root [4] calls
Error: No symbol calls in current scope ...

Explanation:

Example:

Explanation:

Comments:

• new constructor(parameters); creates an anonymous object and returns a pointer to that object. Such objects are called dynamic because their lifetime in in the hand of the programmer. They are alive until they are deleted with a delete statement.
• delete pointer; deletes a dynamic objects the pointer points to
• An allocation (new) must be paired with one and only one deallocation (delete).
• Deallocating twice almost always causes your program to crash (CINT protects you agaist that, but if you compile your macro ...)
• Never deallocating can cause your program to use more and more memory if its run (that may be tolerable in a short ROOT session)

 Example:

Double_t * fillArray(Int_t n) {
// create a double array of length n,
// fill it with random numbers
// return a pointer to it
   Double_t *x = new Double_t[n];
   TRandom generator(0);
   for(Int_t i=0; i<n; i++) x[i] = generator.Rndm();
   return x;
}

root [0] .L fillArray.C
root [1] Double_t *y;
root [2] y = fillArray(5);
root [3] for(Int_t i=0; i<5; i++) cout << y[i] << endl;
0.663086
0.669237
0.563476
0.741082
0.788386
root [4] delete[] y;
root [5] y = fillArray(5);
root [6] for(Int_t i=0; i<5; i++) cout << y[i] << endl;
0.664211

Explanation:

[1]
Declare a pointer y to a Double_t array
[2]
Set the pointer y to the result of a call to fillArray(5)
[3]
Output the 5 elements of y
[4]
delete the array y is pointing to
[5][6]
see [2][3]

Comments:

• generator in file function fillArray is an automatic object, it will be deleted when the function returns
• x is a dynamic variable its lifetime is not bound to the function.
• The name x goes out of scope when the function returns, to use the array x its value has to be communicated
• Notice that an array has to be deleted by the operator delete[] instaed of delete as in the previous example
• Without the delete[] x; statement, the above command sequence would have created a memory leak.

Function Arguments

Example:

void swap0(Double_t x, Double_t y) {
  Double_t temp = x;
  x = y;
  y = temp;
}
void swap1(Double_t &x, Double_t &y) {
  Double_t temp = x;
  x = y;
  y = temp;
}
void swap2(Double_t *x, Double_t *y) {
  Double_t temp = *x;
  *x = *y;
  *y = temp;
}

root [0] .L swap.C
root [1] Double_t a = 1;
root [2] Double_t b = 2;
root [3] swap0(a,b);
root [4] cout << "a=" << a << " b="<< b << endl;
a=1 b=2
root [5] swap1(a,b);
root [6] cout << "a=" << a << " b="<< b << endl;
a=2 b=1
root [7] swap2(&a,&b);
root [8] cout << "a=" << a << " b="<< b << endl;
a=1 b=2

Explanation:

[swap1]
x is an alias for the first actual argument
y is an alias for the second actual argument
the values of x and y are swapped

[swap2]
x is a pointer to Double_t initialized with the value of the first actual argument
y is a pointer to Double_t initialized with the value of the second actual argument
the values of the Double_t objects x and y are pointing to are swapped

[3][4]
the function swap0 has no effect on its actual parameters

[5][6]
the function swap1 changes the value of a and b

[7][8]
the function swap2 is called with the addresses of a and b, it does not change its arguments (the addresses)but it changes the values of a and b

Comments:

• C++ passes arguments by value.
• To change the objects passed to a function they must be passed by reference or by pointer.
• Passing large objects by values introduces performance problems because large objects havt to be created as local variables. Passing arguments as reference or pointer does not introduce this performance penalty.
• Passing arguments by const reference cannot change the value of an argument but avoids the performance penalty introduced by creating large local objects.

Classes:

MyClass.h:

class MyClass {
public:
   MyClass();
   MyClass(int x);
   MyClass(char* text);
   int GetX()
   virtual void Draw();
protected:
   SetX(int x);
private:
   int x;
};
 

Inheritance

#include "MyClass.h"

class YourClass : public MyClass {
public:
   YourClass();
   YourClass(int x, int y);
   int GetY();
   virtual void Draw();
private:
   int y;
};
 

Remarks:

• Common implementation: It is easy to extend a class, to add some functionality without touching or copying the code of the base class. You need not to replicate the code of the base class. A lot of ROOT classes inherit from TNamed. Objects of all of these classes can have names and titles.
• Common behavior: Inheritance creates a "is-a" or better "is-usable-as" relationship. Objects of the derived class can be used everywhere where objects of the base class can be used. One can write functions with base class objects as arguments. Caution: this way of using inheritance works only
• if used via reference or pointer