1  a = 1
2  b = 2+a
3  c = 3+b
4
5  for i in range(b, 3+b):
6    a = a+1
7
8  print(c)

1  int a = 1;
2  int b = 2+a;
3  int c = 3+b;
4
5  for (int i=b; i<=3+b; i++)
6    a + a+1
7
8  printf("%d\n", c);

1  int a = 1;
2  int b = 2+a;
3  int c = 3+b;
4
5  for (int i=b; i<=3+b; i++)
6    a + a+1
7
8  printf("%d\n", c);

g++ -O0 --save-temps Hello.cxx -o Hello.exe

// The class. Recommendation: use // for single line comments
class MyFirstClass { // ... and also at the end of a code line             
};

int main() {
  /__
   * Recommendation: use this syntax for multiline comments
   * for multiline comments
   */
  MyFirstClass myObj;  // Create an object of MyFirstClass
  return 0;
}

// Include header file for standard input/output stream library
#include <iostream>

// The global main function that is the designated start of the program
int main(){
  /__
    * Write the string 'Hello world!' to the default output stream and
    * terminate with a new line (that is what std::endl does)
    */
  std::cout << "Hello world!" << std::endl; // or “Hello world!\n”;
  return 0; // Return code 0 to the operating system (=no error)
}

// HelloWorld class
class HelloWorld {
    public:
    void PrintHelloWorld() // public member function
    {
        std::cout << "Hello World!\n";
    }
};

int main(){
    HelloWorld hello; // create an object of HelloWorld
    hello.PrintHelloWorld(); // call member function
}

#include <headerfile>

double sum(const Vector& v) {
  double s = 0;
  for (auto i = 0; i < v.length; i++)
    s += v.array[i];
  return s; 
}

class Vector {
  public:
  double sum() {
    double s = 0;
    for (auto i=0; i&ltlength; i++) 
      s+=array[i];
    return s;
  }
}

int main() { body }

#include <iostream>

std::cout << "Hello world!" << std::endl;

Hello world!

std::cout << "Hello" << " " << "world!" << std::endl;

Hello world!

using namespace std;
cout << "Hello world!" << endl;

Hello world!

int a = 10; // create integer variable and initialize it to 10
a = 15;     // update the value of integer variable to 15

15

const int b = 20; // create integer constant and initialize it to 10

a = b;
b = a;

input_line_15:4:3: error: cannot assign to variable 'b' with const-qualified type 'const int'
b = a;
~ ^
input_line_15:2:12: note: variable 'b' declared const here
 const int b = 20; // create integer constant and initialize it to 10
 ~~~~~~~~~~^~~~~~

Interpreter Error:

const int c = 20;   // C-like initialization
const int d(20);    // constructor initialization
const int e = {20}; // uniform initialization, since C++11 
const int f{20};

int g = 10;   // C-like initialization
int h(20);    // constructor initialization
int i = {20}; // uniform initialization, since C++11
int j;        // only declaration (arbitrary value!)
j = 20;       // assignment of value

20

extern int f;

int main() {
    int a = 10;  // variable a is visible here
    
    {
      int b = a; // variable a is visible here
    }
    
    {
      int c = b; // variable a is visible here, b is not(!) visible here -> error
    }            
}

int main() {
    int a = 10;   // variable a is visible here
    
    {
      int a = 20; // new variable a only visible in blue
                  // scope, interrupts scope of red one
      std::cout << a << std::endl; // is 20
    }
    
    std::cout << a << std::endl;   // is 10
}

double d1 = 1.0;
double d2 = 1.;    // zero is added automatically
double d3 = 1e3;   // -> 1000
double d4 = 1.5E3; // -> 1500
double d5 = 15e-2; // -> 0.15

float f1 = 1.0f;   // or 1.0F suffix type specifier
float f2 = 1.0;    // works the same but does conversion
float f3 = 1.5e3F; // -> 1500

#include <typeinfo>

float f = 1.7f; double d = 0.7;
std::cout << typeid(f).name() << std::endl; // float
std::cout << typeid(d).name() << std::endl; // double

f
d

@0x7f128339fde0

std::cout << typeid(f + d).name() << std::endl; // double

d

@0x7f128339fde0

char  x = 'a'; 
float y = 1.7;
std::cout << typeid(x + y).name() << std::endl; // float???

f

@0x7f128339fde0

auto x = f + d;
std::cout << typeid(x).name() << std::endl; // double

d

@0x7f128339fde0

auto y = f + (float)d;
std::cout << typeid(y).name() << std::endl; // float
                
auto z = (int) (f + (float)d);
std::cout << typeid(z).name() << std::endl; // int

f
i

@0x7f128339fde0

float f1 = 0.67;

float f1 = 0.67;
std::cout << (f1 == 0.67); 
std::cout << (f1 == 0.67f);

01

int i = 10;

int  i = 10;
auto p = &i;
int  j = *p;

std::cout << i << std::endl;
std::cout << p << std::endl;

10
1

std::cout << typeid(i).name() << std::endl; // -> i
std::cout << typeid(p).name() << std::endl; // -> Pi

i
Pi

@0x7f128339fde0

std::cout <<  i << std::endl;
std::cout << *p << std::endl;

10
10

int  i =  10;
int* p = &i;

i = 20; 
std::cout << *p << std::endl; // *p is 20

20

@0x7f128339fde0

*p = 30; 
std::cout << i << std::endl; // i is 30

30

@0x7f128339fde0

p = p+1; 
std::cout <<  p << std::endl; //  p is 0x0008
std::cout << *p << std::endl; // *p is CRAP

1
0

@0x7f128339fde0

int* p;
std::cout <<  p << std::endl; // prints some memory address
std::cout << *p << std::endl; // prints some random content at that address

int * p = nullptr;
std::cout <<  p << std::endl; // is 0x0
std::cout << *p << std::endl; // yields Segmentation fault

0

input_line_64:4:15: warning: null passed to a callee that requires a non-null argument [-Wnonnull]
std::cout << *p << std::endl; // yields Segmentation fault
              ^

Interpreter Exception:

std::cout << (p ? *p : NULL) << std::endl;

#include <exception>

throw std::runtime_error("An error occured");

Standard Exception: An error occured

try 
{
    throw std::runtime_error("An error occured");
} 

catch (const std::exception& e) 
{
    std::cout << e.what() << std::endl; // or handle the exception
}

An error occured

#include <cassert>

float f1 = 0.67;
assert(f1 == 0.67);

#undef NDEBUG
#include <cassert>

float f1 = 0.67;
assert(f1 == 0.67);

#include <iostream>
#include <stdexcept>

// A function that might throw an exception
int divide(int numerator, int denominator) {
    if (denominator == 0) {
        throw std::invalid_argument("Denominator cannot be zero.");
    }
    return numerator / denominator;
}

try {
    int a = 10;
    int b = 0; // Intentionally set to zero to cause an exception
    int result = divide(a, b);
    std::cout << "Result is: " << result << std::endl;
} catch (const std::invalid_argument& e) {
    // Handle the exception here
    std::cerr << "Caught an exception: " << e.what() << std::endl;
}

int addOneByValue(int a) { return a + 1; }

int i = 1;
int j = addOneByValue(i);

int addOneByReference(int& a) { return a + 1; }

int i = 1;
int j = addOneByReference(i);

int addOneByReference1(int& a) { return a++; }

int i = 1;
int j = addOneByReference1(i);

int addOneByReference2(int& a) { return ++a; }

int i = 1;
int j = addOneByReference2(i);

int addOneByConstReference(int& a) { return a + 1; }

int i = 1;
int j = addOneByConstReference(i);

int addOne(const int& a) { return a+1; }

void addOne_Val(int  a) { a++; } // increment local copy
void addOne_Ref(int& a) { a++; } // increment a(~i)

int addOneByAddress(int* a) { return *a+1; }

int i = 1;
int j = addOneByAddress(&i);

double sum(const int* array, int length) {
    
    double s = 0;

    for (auto i=0; i<length; i++)
        s += array[i];

    return s;
}

int array[5] = { 1, 2, 3, 4, 5 };
std::cout << sum(array, 5) << std::endl;

15

int array[5];

for (auto i=0; i<5; i++)
    std::cout << array[i] << std::endl;

auto array = { 1, 2, 3, 4, 5 };

auto array{ 1, 2, 3, 4, 5 };

main(int argc, char* argv[]) {
     for (int i=0; i<argc; i++)
        std::cout << i << “-Argument is “ << argv[i] << “\n”;
}

int* array = new int[5];

int* array = new int[5]{ 1, 2, 3, 4, 5 };

for (auto i=0; i<5; i++)
    std::cout << array[i] << std::endl;

delete[] array;
array = nullptr;

int array[5];
constexpr int k=5; // constexpr tells the compiler that the 
int array[k];      // expression is available at compile time
int k=5;
int array[k];      // Gives a compiler error !!!

int k = std::atoi(argv[1]);
int* array = new int[k];

namespace tudelft {
    void hello() {
      std::cout << “Hello TU Delft\n”;
    }
}

namespace other {
    void hello() {
      std::cout << “Hello other\n”;
    }
}

tudelft::hello();
other::hello();

namespace tudelft {
    void hello() { std::cout << "Hello TU Delft\n"; }
    namespace eemcs {
      void hello() { std::cout << "Hello EEMCS\n"; }
    }
}

tudelft::hello();
tudelft::eemcs::hello();

namespace tudelft {
    void hello() { ::hello();
                   std::cout << "TU Delft\n"; }
    namespace eemcs {
      void hello() { ::hello();
  std::cout << "EEMCS at";
  ::tudelft::hello();
            }
    }
}

void hello() { std::cout << "Hello "; }

Matlab		Python
`A = [1 2; 3 4] size(A)`		`A = numpy.matrix([[1, 2], [3, 4]]) A.shape`
Here, `size()` is a standalone functions that is applied to the matrix A from outside. That means that `size()` must be able to deduce the matrix size. In other words, the matrix size is publicly visible.		Here, matrix A provides a member attribute to report its size from inside. The attribute is also publicly visible but offers more fine-grained control.

Group	Type name	Notes on size / precision
Character types	`char`	Exactly one byte in size. At least 8 bits.
	`char16_t`	Not smaller than char. At least 16 bits.
	`char32_t`	Not smaller than char16_t. At least 32 bits.
Integer types (signed and unsigned)	`(un)signed char`	Same size as char. At least 8 bits.
	`(un)signed short int`	Not smaller than char. At least 16 bits.
	`(un)signed int`	Not smaller than short. At least 16 bits.
	`(un)signed long int`	Not smaller than int. At least 32 bits.
	`(un)signed long long int`	Not smaller than long. At least 64 bits.
Floating-point type	`float`	Precision not less than float
	`double`	Precision not less than float
	`long double`	Precision not less than double
Boolean type	`bool`

A class is a blueprint, aka an instruction manual that tells you how to create something		An object is a living instance created (instantiated) from the class blueprint
	vs.

Object-oriented scientific programming with C++¶

What's this course about?¶

Object oriented programming¶

A first example of OOP concepts¶

Course information¶

After all formalities ...¶

Programming languages¶

Pros and Cons of interpreted languages¶

Pros and Cons of compiled languages¶

Example of a compiled language¶

Let’s get started¶

Class vs. Object¶

Hello World!¶

OOP style and member function¶

THE main function¶

Standard output¶

Variables and constants¶

Initialization of constants¶

Initialization of variables¶

Intermezzo: Terminology¶

Scope of variables/constants¶

C++ standard types¶

Examples of C++ types¶

Mixing and conversion of types¶

auto vs. explicit types¶

Use of suffix type specifiers¶

Address-of/dereference operators¶

Pointers and references¶

Pointer hazards¶

Error handling with exceptions¶

Error handling with assertion¶

Error handling best practices¶

Debug example: divide by zero¶

Argument passing – by value¶

Argument passing – by reference¶

Argument passing – by constant reference¶

C++ return value optimization (RVO)¶

Argument passing¶

Argument passing – by address¶

Example¶

Static arrays¶

Quiz: Static arrays¶

Quiz: char* argv[]¶

Dynamic arrays¶

Example of a dynamic array¶

Static vs. dynamic arrays¶

Namespaces¶

`auto` vs. explicit types¶