
1
2
3
4
5
6#include <iostream>

int main() {
  std::cout << "Hello World!" << std::endl;
  return 0;
}


1
2
3
4
5
6
7#include <iostream>
using std::cout;
using std::endl;
int main () {
  cout << "Hello World!" << endl;
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <iostream>
using std::cout;
using std::endl;

int main(int argc, char* argv[]) {
  cout << "This is " << argv[0] << endl;
  cout << "got " << argc-1 << " inputs:" << endl;
  for (int j=1; j<argc; ++j) {
    cout << j << ": " << argv[j] << endl;
  }
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <iostream>
int main(){
    int x = 0;
    double y = 0;
    double z = 0;
    
    std::cout << "Please enter an integer value: ";
    std::cin >> x;
    std::cout << "Please enter two double values: ";
    std::cin >> y >> z;
    std::cout << x << " * " << y << " / " << z;
    std::cout << " = " << x*y/z << std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <iostream>

int main(){
    double var = 0.3;
    bool tmp = var;

    if (1) {
      std::cout << "1 is true\n";
    }
    if (var) {
      std::cout << var << " is true\n";
    }
    if (tmp == true) {
      std::cout << "equality is true\n";
    }
    if (0) {
      std::cout << "0 is true\n";
    }
    return 0;
}


1
2
3void f(int x, int y, int z = 0);
void g(int x, int y = 0, int z = 0);
void h(int x = 0, int y = 0, int z = 0);


1
2
3void f(int x = 0, int y = 0, int z); // syntax error
void g(int x, int y = 0, int z);     // syntax error
void h(int x = 0, int y, int z = 0); // syntax error


1
2
3
4void f(int x, int y = 0);
void f(int x, int y = 0) { //Fehler
    cout << "x=" << x << ", y=" << y << "\n";
}


1
2
3
4
5void f(char*);
double f(char*, double);
int f(char*, char*, int = 1);
int f(char*);                  // syntax error 
double f(char*, int = 0);      // syntax error


1
2
3
4
5
6
7
8#include <iostream>
void drive_default(int km=10,int h=0){
   std::cout << km << " km travelled";
  if (h > 0) {
    std::cout << " in " << h << " hour(s)";
  }
  std::cout << std::endl; 
}


1
2
3void drive_overload(){
    std::cout << "10 km travelled"<< std::endl;
}


1
2
3void drive_overload(int km){
    std::cout << km << " km travelled"<< std::endl;
}


1
2
3void drive_overload(int km, int h){
    std::cout << km << " km travelled in " << h << " hour(s)"<< std::endl;
}


1
2
3
4
5
6
7
8
9int main(){
    drive_default();
    drive_default(35);
    drive_default(35,1);
    drive_overload();
    drive_overload(35);
    drive_overload(35,1);
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13#include <iostream>
class Triangle {
private:
  double x[2]={0,0};
  double y[2]={0,0};
  double z[2]={0,0};

public:
  void setX(double, double);
  void setY(double, double);
  void setZ(double, double);
  double getArea();
};


1
2Triangle tri;
tri.x[0] = 1.0;

input_line_9:3:5: error: 'x' is a private member of '__cling_N52::Triangle'
tri.x[0] = 1.0;
    ^
input_line_8:3:10: note: declared private here
  double x[2]={0,0};
         ^

Interpreter Error:


1
2
3
4void Triangle::setX(double x0, double x1) {
  x[0] = x0;
  x[1] = x1;
}


1
2
3
4void Triangle::setY(double y0, double y1) {
  y[0] = y0;
  y[1] = y1;
}


1
2
3
4void Triangle::setZ(double z0, double z1) {
  z[0] = z0;
  z[1] = z1;
}


1
2
3
4
5double Triangle::getArea() {
  // use the 2x2 determinant formula to compute the area
  return 0.5*fabs( (y[0]-x[0])*(z[1]-x[1]) 
                   - (z[0]-x[0])*(y[1]-x[1]) );
}


1
2
3
4
5
6
7int main(){
    Triangle tri;
    tri.setX(0.0,0.0);
    tri.setY(1.0,0.0);
    tri.setZ(0.0,1.0);
    std::cout << "area = " << tri.getArea() << std::endl;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24class Triangle {
private:
  double x[2];
  double y[2];
  double z[2];

public:
  void setX(double x0, double x1) {
    x[0] = x0;
    x[1] = x1;
  }
  void setY(double y0, double y1) {
    y[0] = y0;
    y[1] = y1;
  }
  void setZ(double z0, double z1) {
    z[0] = z0;
    z[1] = z1;
  }
  double getArea() {
    return 0.5*fabs( (y[0]-x[0])*(z[1]-x[1])
                      - (z[0]-x[0])*(y[1]-x[1]) );
  }
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19#include <iostream>
struct MyStruct {
  double x[2];
  double y[2];
  double z[2];
};

class MyClass {
  double x[2];
  double y[2];
  double z[2];
};

class MyStructClass {
public:
  double x[2];
  double y[2];
  double z[2];
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main(){
    MyStruct var1;
    MyClass var2;
    MyStructClass var3;

    var1.x[0] = 0;
    var2.x[0] = 0; // syntax error: x is private in MyClass
    var3.x[0] = 0;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <iostream>
#include <string>
#include <cstdio>
int main(){
    std::string str1 = "Hello";
    std::string str2 = "World";
    std::string str3 = str1 + " " + str2;
    std::cout << str3 << "! ";
    str3.replace(6,5, "Peter");
    std::cout << str3 << "! ";
    printf("%s?\n",str3.c_str());
}


1
2
3
4
5
6
7try{
    //Code der ausgeführt werden soll
    throw errorID; //wenn Fehler auftritt, Abbruch und Fehlerbehandlung
}
catch(type errorID) {
    //Fehlerbehandlung
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <iostream>
#include <cassert>

class Fraction {
private:
  int numerator = 0;
  int denominator = 1;
public:
  int getNumerator();
  int getDenominator();
  void setNumerator(int n);
  void setDenominator(int n);
  void print();
};


1
2
3void Fraction::print() {
  std::cout << numerator << "/" << denominator << std::endl;
}


1
2
3int Fraction::getNumerator() {
  return numerator;
}


1
2
3void Fraction::setNumerator(int n) {
  numerator = n;
}


1
2
3int Fraction::getDenominator() {
  return denominator;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19void Fraction::setDenominator(int n) {
  
  try{
      // ensure that denominator is not 0
      if (n==0) {
          throw n;
      }
      // if n<0, store positive denominator and flip the sign of the numerator
      if (n > 0) {
        denominator = n;
      } else {
        denominator = -n;
        numerator = -numerator;
      }
  }
  catch(int n){
      std::cout << "Denominator must not be zero!" << std::endl;
  }
}


1
2
3
4
5
6
7
8int main(){
    Fraction x;
    x.setNumerator(1);
    x.setDenominator(3);
    x.print();
    x.setDenominator(0);
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <iostream>
#include <string>
using std::cout;
using std::string;

class Student {
private:
  string lastname;
  int student_id;
public:
  Student() {
    cout << "student registered\n";
  }
  Student(string name, int id) {
    lastname = name;
    student_id = id;
    cout << "student registered (" << lastname;
    cout << ", " << student_id << ")\n";
  }
};


1
2
3
4
5int main(){
    Student demo;
    Student var("Feischl", 123456);
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <iostream>
#include <string>
using std::cout;
using std::string;

class Student {
private:
  string lastname;
  int student_id;
public:
  Student() {
    cout << "student registered\n";
  }
  Student(string lastname, int student_id) {
    this->lastname = lastname;
    this->student_id = student_id;
    cout << "student registered (" << lastname;
    cout << ", " << student_id << ")\n";
  }
};


1
2
3
4
5int main(){
    Student demo;
    Student var("Feischl",12345678);
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <iostream>
#include <string>
using std::cout;
using std::string;

class Student {
private:
  string lastname;
  int student_id;
public:
  Student() {
    cout << "student registered\n";
  }
  Student(string lastname, int student_id) {
    this->lastname = lastname;
    this->student_id = student_id;
    cout << "student registered (" << lastname;
    cout << ", " << student_id << ")\n";
  }
  ~Student() {
    cout << "student deleted (" << lastname << ", ";
    cout << student_id << ")\n";
  }
};


1
2
3
4int main(){
    Student var("Feischl",12345678);
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <iostream>
#include <string>
using std::cout;
using std::string;

class Student {
private:
  string lastname;
  int student_id;
public:
  Student() : lastname("nobody"), student_id(0) {
    cout << "student registered\n";
  }
  Student(string name, int id) :
    lastname(name), student_id(id) {
      cout << "student registered (" << lastname;
      cout << ", " << student_id << ")\n";
  }
  ~Student() {
    cout << "student deleted (" << lastname << ", ";
    cout << student_id << ")\n";
  }
};


1
2
3
4int main(){
    Student test;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18#include <iostream>
#include <string>
using std::cout;
using std::string;

class Test {
private:
  string name;
public:
  void print() {
    cout << "name " << name << "\n";
  }
  Test() : name("Default") { print(); }
  Test(string n) : name(n)  { print(); }
  ~Test() {
    cout << "delete " << name << "\n";
  }
};


1
2
3
4
5
6
7
8
9int main(){
  Test t1("Object1");
  {
    Test t2;
    Test t3("Object3");
  }
  cout << "end of block" << "\n";
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17#include <iostream>
using std::cout;
using std::endl;

class Class1 {
public:
  Class1() { cout << "constr Class1" << endl; }
  ~Class1() { cout << "destr Class1" << endl; }
};

class Class2 {
private:
   Class1 obj1;
public:
   Class2() { cout << "constr Class2" << endl; }
   ~Class2() { cout << "destr Class2" << endl; }
};


1
2
3
4int main(){
    Class2 obj2;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25int max(int a, int b) {
  if (a < b) {
    return b;
  }
  else {
    return a;
  }
}

double max(double a, double b) {
  if (a < b) {
    return b;
  }
  else {
    return a;
  }
}

int square(int a) {
  return a*a;
}

double square(double a) {
  return a*a;
}


1
2
3
4
5#include <iostream>
template <typename Type>
Type square(const Type t) {
  return t*t;
}


1
2
3
4
5int main() {
  std::cout << square<double>(1.5) << std::endl;
  std::cout << square(1.5) << std::endl;
  std::cout << square<int>(1.5) << std::endl;
}

input_line_9:4:28: warning: implicit conversion from 'double' to 'int' changes value from 1.5 to 1 [-Wliteral-conversion]
  std::cout << square<int>(1.5) << std::endl;
               ~~~~~~      ^~~


1
2
3
4int x = 2;
double y = 4.7;
std::cout << square(x) << std::endl;
std::cout << square(y) << std::endl;

4
22.09


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <iostream>
template <typename Type>
class ClassName {
private:
  Type memberVar;

public:
  void set(Type memberVar){
      this->memberVar=memberVar;
  }
  Type get(){
      return memberVar;
  }
};


1
2
3
4
5
6int main(){
    ClassName<double> var;
    var.set(3.4);
    std::cout << var.get() <<std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <iostream>
#include <string>
#include <vector>
using std::vector;
using std::string;

class Entry {
public:
  string firstname;
  string lastname;
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11int main(){
  vector<Entry> telephoneBook(2);
  telephoneBook[0].firstname = "Peter";
  telephoneBook[0].lastname = "Pan";
  telephoneBook[1].firstname = "Wolverine";
  telephoneBook[1].lastname = "";
  for(int i=0;i<2;++i){
      std::cout << telephoneBook[i].firstname << " " << telephoneBook[i].lastname <<std::endl;
  }
  return 0;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28int main(){
    vector<double> test(10,3);
    vector<double> var;
    vector<int> a(5,1);
    vector<int> b(10,2);
    std::cout << "test[3] = " << test[3] <<std::endl;
    test[4]=10;
    std::cout<< "length of test: " << test.size()<<std::endl;
    test.resize(20,4);
    std::cout << "test[13] = " << test[13] <<std::endl;
    std::cout<< "length of test: " << test.size()<<std::endl;
    
    var = test;
    var[13]=0;
    std::cout << "var[13] = " << var[13] <<std::endl;
    std::cout << "test[13] = " << test[13] <<std::endl;
    
    a.swap(b);
    for(int i=0;i<a.size();++i){
        std::cout << a[i] << " ";
    }
    std::cout << std::endl;
    for(int i=0;i<b.size();++i){
        std::cout << b[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18int main(){
    vector<double> test(1,1);
    test.push_back(2);
    test.push_back(1);
    test.push_back(3);
    for(int i=0;i<test.size();++i){
        std::cout << test[i] << " ";
    }
    std::cout << std::endl;
    test.pop_back();
    for(int i=0;i<test.size();++i){
        std::cout << test[i] << " ";
    }
    std::cout << std::endl;
    test.clear();
    std::cout << "Length of test: " << test.size() << std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17#include <iostream>
#include <vector>
#include <cmath>

using std::vector;

class Vector {
private:
  vector<double> coeff;
  
public:
  Vector(int dim=0, double init=0);
  double get(int k);
  void set(int k, double val);
  int size();
  double norm();
};


1Vector::Vector(int dim, double init) : coeff(dim,init) {}


1
2
3int Vector::size(){
  return coeff.size();
}


1
2
3
4
5
6
7double Vector::norm(){
  double sum = 0;
  for (int j=0; j<size(); ++j) {
    sum = sum + coeff[j]*coeff[j];
  }
  return sqrt(sum);
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14double Vector::get(int k) {
    double tmp;
    try{
      if(k<0 || k>coeff.size()){       
          throw k;
      }else{
          return coeff[k];
      }
    }
    catch(int n){
        std::cout << "Warning: accessing out of bounds element (" << n <<"), returning zero" << std::endl;
        return 0;
    }    
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13void Vector::set(int k, double val) {
    double tmp;
    try{
      if(k<0 || k>coeff.size()){       
          throw k;
      }else{
          coeff[k] = val;
      }
    }
    catch(int n){
        std::cout << "Warning: accessing out of bounds element (" << n <<"), no assignement" << std::endl;
    }    
}


1
2
3
4
5
6
7int main(){
    Vector vec(5,1);
    vec.set(3,3);
    std::cout << vec.get(3);
    std::cout << vec.norm();
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17#include <iostream>
#include <vector>
#include <cmath>

using std::vector;
class Matrix {
private:
  vector<vector<double> > coeff;
  
public:
  Matrix(int n=0, int m=0, double init=0);
  double get(int i, int j);
  void set(int i, int j, double val);
  int getN();
  int getM();
  double frobeniusNorm();
};


1Matrix::Matrix(int n, int m, double init) : coeff(n,vector<double>(m, init)) {}


1
2
3int Matrix::getN(){
  return coeff.size();
}


1
2
3
4
5
6int Matrix::getM(){
    if(getN()==0){
        return 0;
    }
    return coeff[0].size();
}


1
2
3
4
5
6
7
8
9double Matrix::frobeniusNorm(){
  double sum = 0;
  for (int i=0; i<getN(); ++i) {
      for(int j=0;j<getM(); ++j){
        sum = sum + coeff[i][j]*coeff[i][j];
      }
  }
  return sqrt(sum);
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14double Matrix::get(int i,int j) {
    double tmp;
    try{
      if(i<0 || i>getN() || j<0 || j>getM()){       
          throw i;
      }else{
          return coeff[i][j];
      }
    }
    catch(int n){
        std::cout << "Warning: accessing out of bounds element, returning zero" << std::endl;
        return 0;
    }    
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13void Matrix::set(int i, int j, double val) {
    double tmp;
    try{
      if(i<0 || i>getN() || j<0 || j>getM()){       
          throw i;
      }else{
          coeff[i][j] = val;
      }
    }
    catch(int n){
        std::cout << "Warning: accessing out of bounds element, no assignement" << std::endl;
    }    
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11Vector matrixVectorProd(Matrix M, Vector x){
    Vector result(M.getN(),0);
    for(int i=0; i<M.getN(); ++i){
        double tmp=0;
        for(int j=0; j<M.getM(); ++j){
            tmp += M.get(i,j)*x.get(j);
        }
        result.set(i,tmp);
    }
    return result;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14int main(){
    Matrix M(4,5,1);
    Vector x(5,1);
    Vector y = matrixVectorProd(M,x);
    M.set(3,3,10);
    std::cout << "M(3,3) = " << M.get(3,3) << ", M(3,4) = " << M.get(3,4) <<std::endl;
    std::cout << "||M||_F = "<< M.frobeniusNorm() << std::endl;
    std::cout << "M*x = (";
    for(int i=0;i<y.size();++i){
        std::cout << y.get(i) << " ";
    }
    std::cout << ")" << std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13#include <iostream>
int main() {
  int var = 5; 
  int& ref = var;

  std::cout << "var = " << var << std::endl;
  std::cout << "ref = " << ref << std::endl;
  ref = 7;
  std::cout << "var = " << var << std::endl;
  std::cout << "ref = " << ref << std::endl;
    
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <iostream>
int main() {
  int var = 5;
  int& ref = var;

  std::cout << "var = " << var << std::endl;
  std::cout << "ref = " << ref << std::endl;
  printf("address of var = %p\n",&var);
  printf("address of var = %p\n",&ref);
    
  return 0;
}


1
2
3
4
5
6#include <iostream>
void swap(int* px, int* py) {
  int tmp = *px;
  *px = *py;
  *py = tmp;
}


1
2
3
4
5
6
7
8int main() {
  int x = 5;
  int y = 10;
  std::cout << "x = " << x << ", y = " << y << std::endl;
  swap(&x, &y);
  std::cout << "x = " << x << ", y = " << y << std::endl;
  return 0;
}


1
2
3
4
5
6#include <iostream>
void swap(int& rx, int& ry) {
  int tmp = rx;
  rx = ry;
  ry = tmp;
}


1
2
3
4
5
6
7
8int main() {
  int x = 5;
  int y = 10;
  std::cout << "x = " << x << ", y = " << y << std::endl;
  swap(x, y);
  std::cout << "x = " << x << ", y = " << y << std::endl;
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11Vector matrixVectorProd(Matrix& M, Vector& x){
    Vector result(M.getN(),0);
    for(int i=0; i<M.getN(); ++i){
        double tmp=0;
        for(int j=0; j<M.getM(); ++j){
            tmp += M.get(i,j)*x.get(j);
        }
        result.set(i,tmp);
    }
    return result;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


1
2
3
4
5
6
7int main(){
    vector<double> vec(10,3);
    for(double x : vec){
        std::cout << x <<" ";
    }
    std::cout << std::endl;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main(){
    vector<double> vec(10,3);
    for(double& x : vec){
        x = x*x+10;
    }
    for(double x : vec){
        std::cout << x <<" ";
    }
    std::cout << std::endl;
}


1
2
3#include <iostream>
#include <string>
using std::string;


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12int main(){
    string name = "Michael Feischl";
    double x[5] = {1,2,3,4,5};
    for(char c : name){
        std::cout << c << "_";
    }    
    std::cout<<std::endl;
    for(double y : x){
        std::cout << y << "_";
    }
    return 0;
}


1
2
3
4
5
6#include <iostream>

int& fct() {
  int x = 4711;
  return x;
}

input_line_57:3:10: warning: reference to stack memory associated with local variable 'x' returned [-Wreturn-stack-address]
  return x;
         ^


1
2
3
4
5int main() {
  int& var = fct();
  std::cout << "var = " << var << std::endl;
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18#include <iostream>
#include <vector>
#include <cmath>

using std::vector;
using std::cout;
using std::ostream;

class Vector {
private:
  vector<double> coeff;
  
public:
  Vector(int dim=0, double init=0);
  double& get(int k);
  int size();
  double norm();
};


1Vector::Vector(int dim, double init) : coeff(dim,init) {}


1
2
3int Vector::size(){
  return coeff.size();
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13double& Vector::get(int k) {
    double tmp;
    try{
      if(k<0 || k>coeff.size()){       
          throw k;
      }else{
          return coeff[k];
      }
    } catch(int n){
        std::cout << "Accessing out of bounds element, abort!" <<std::endl;
        std::abort();  //terminate program
    }  
}


1
2
3
4
5
6
7int main(){
    Vector x(10,1);
    std::cout << x.get(3) << std::endl;
    x.get(3)=5;
    std::cout << x.get(3) << std::endl;
    return 0;
}


1
2
3
4
5int main() {
  const double var = 5;
  var = 7;
  return 0;
}

input_line_13:3:7: error: cannot assign to variable 'var' with const-qualified type 'const double'
  var = 7;
  ~~~ ^
input_line_13:2:16: note: variable 'var' declared const here
  const double var = 5;
  ~~~~~~~~~~~~~^~~~~~~

Interpreter Error:


1
2
3
4
5
6
7
8int main() {
  const double var = 5;
  double tmp  = 0;
  double* const ptr = &var;
  ptr = &tmp;
  *ptr = 7;
  return 0;
}

input_line_15:4:17: error: cannot initialize a variable of type 'double *const' with an rvalue of type 'const double *'
  double* const ptr = &var;
                ^     ~~~~

Interpreter Error:


1
2
3
4
5
6
7
8int main() {
  const double var = 5;
  double tmp  = 0;
  const double* const ptr = &var;
  ptr = &tmp;
  *ptr = 7;
  return 0;
}

input_line_17:5:7: error: cannot assign to variable 'ptr' with const-qualified type 'const double *const'
  ptr = &tmp;
  ~~~ ^
input_line_17:4:23: note: variable 'ptr' declared const here
  const double* const ptr = &var;
  ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~
input_line_17:6:8: error: read-only variable is not assignable
  *ptr = 7;
  ~~~~ ^

Interpreter Error:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <iostream>
int main() {
  double var = 5;
  double& ref = var;
  const double& cref = var;
  std::cout << "var = " << var << ", ";
  std::cout << "ref = " << ref << ", ";
  std::cout << "cref = " << cref << std::endl;
  ref = 7;
  std::cout << "var = " << var << ", ";
  std::cout << "ref = " << ref << ", ";
  std::cout << "cref = " << cref << std::endl;
  // cref = 9;
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <iostream>
#include <vector>
#include <cmath>


class Matrix {
private:
  std::vector<std::vector<double> > coeff;
  
public:
  Matrix(int n=0, int m=0, double init=0);
  const std::vector<double>& getRow(int i);
  std::vector<double>& getRowNonConst(int i);
  double get(int i, int j);
};


1Matrix::Matrix(int n, int m, double init) : coeff(n,std::vector<double>(m, init)) {}


1
2
3const std::vector<double>& Matrix::getRow(int i){
    return coeff[i];
}


1
2
3std::vector<double>& Matrix::getRowNonConst(int i){
    return coeff[i];
}


1
2
3double Matrix::get(int i,int j) {
    return coeff[i][j];
}


1
2
3
4
5
6
7
8int main(){
    Matrix M(4,4,0);
    //const std::vector<double>& row = M.getRow(0);
    std::vector<double>& row = M.getRowNonConst(0);
    
    row[2]=5; //Ungewollter Zugriff auf private member coeff. Liefert Syntax Fehler bei Read-Only Reference
    std::cout << M.get(0,2) << std::endl;
}


1
2
3
4
5int main(){
    Matrix M(4,4,0);
    std::vector<double>& row = M.getRow(0); //Fehler, da const auf non-const gecasted werden soll
    const std::vector<double>& row = M.getRowNonConst(0); //Okay, da non-const auf const gecasted wird
}


1
2
3
4
5#include <iostream>

double square(double& x) {
  return x*x;
}


1
2
3
4
5
6int main() {
  const double var = 5;
  std::cout << "var = " << var << ", ";
  std::cout << "var*var = " << square(var) << std::endl;
  return 0;
}

input_line_9:4:32: error: no matching function for call to 'square'
  std::cout << "var*var = " << square(var) << std::endl;
                               ^~~~~~
input_line_8:1:8: note: candidate function not viable: 1st argument ('const double') would lose const qualifier
double square(double& x) {
       ^

Interpreter Error:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <iostream>

class Complex {
private:
  double real;
  double imag;
  
public:
  Complex(double real, double imag);
  Complex(const Complex& input); //Copy-constructor
};


1
2
3
4Complex::Complex(double real, double imag){
    this->real = real;
    this->imag = imag;
}


1
2
3
4
5Complex::Complex(const Complex& input){
    real = input.real;
    imag = input.imag;
    std::cout << "Copy-Constructor" << std::endl;
}


1
2
3
4Complex doNothing(Complex c){
    std::cout << "inside function" << std::endl;
    return c;
}


1
2
3
4
5
6
7int main(){
    Complex a(1,2);
    Complex b(0,0);
    std::cout << "function call" << std::endl;
    b = doNothing(a);
    return 0;
}


1
2
3
4
5
6ClassName& ClassName::operator=(const ClassName& input) {
  if (this != &input) {
    ...
  }
  return *this;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <iostream>
class Complex {
private:
  double real;
  double imag;
  
public:
  Complex(double real, double imag);
  Complex(const Complex& input);
  Complex& operator=(const Complex& input);
};


1Complex::Complex(double real, double imag): real(real), imag(imag){}


1
2
3
4
5Complex::Complex(const Complex& input){
    real = input.real;
    imag = input.imag;
    std::cout << "Copy-Constructor" << std::endl;
}


1
2
3
4
5
6
7
8Complex& Complex::operator=(const Complex& input){
if (this != &input) {
    real = input.real;
    imag = input.imag;
    std::cout << "assignement operator" << std::endl;
  }
  return *this;    
}


1
2
3
4Complex doNothing(Complex c){
    std::cout << "inside function" << std::endl;
    return c;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11int main(){
    Complex a(1,2);
    Complex b(0,0);
    std::cout << "assignement" << std::endl;
    a=b;
    std::cout << "self assignement" << std::endl;
    a=a;
    std::cout << "function call" << std::endl;
    b = doNothing(a);
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16#include <iostream>
#include <vector>
#include <cmath>

using std::vector;

class Vector {
private:
  vector<double> coeff;
  
public:
  Vector(int dim=0, double init=0);
  double& get(int k);
  int size();
  double norm();
};


1
2
3double& Vector::get(int k){
    return coeff[k];
}


1
2
3int Vector::size(){
    return coeff.size();
}


1
2
3
4
5
6
7double scalarProd(const Vector& x, const Vector& y){
    double tmp=0;
    for(int i=0;i<x.size();++i){
        tmp += x.get(i)*y.get(i);
    }
    return tmp;
}

input_line_11:3:19: error: member function 'size' not viable: 'this' argument has type 'const Vector', but function is not marked const
    for(int i=0;i<x.size();++i){
                  ^
input_line_10:1:13: note: 'size' declared here
int Vector::size(){
            ^
input_line_11:4:16: error: member function 'get' not viable: 'this' argument has type 'const Vector', but function is not marked const
        tmp += x.get(i)*y.get(i);
               ^
input_line_9:1:17: note: 'get' declared here
double& Vector::get(int k){
                ^
input_line_11:4:25: error: member function 'get' not viable: 'this' argument has type 'const Vector', but function is not marked const
        tmp += x.get(i)*y.get(i);
                        ^
input_line_9:1:17: note: 'get' declared here
double& Vector::get(int k){
                ^

Interpreter Error:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16#include <iostream>
#include <vector>
#include <cmath>

using std::vector;

class Vector {
private:
  vector<double> coeff;
  
public:
  Vector(int dim=0, double init=0);
  double get(int k) const;
  int size() const;
  double norm() const;
};


1Vector::Vector(int dim, double init): coeff(dim,init){}


1
2
3double Vector::get(int k) const{
    return coeff[k];
}


1
2
3int Vector::size() const{
    return coeff.size();
}


1
2
3
4
5
6
7double scalarProd(const Vector& x, const Vector& y){
    double tmp=0;
    for(int i=0;i<x.size();++i){
        tmp += x.get(i)*y.get(i);
    }
    return tmp;
}


1
2
3
4
5int main(){
    Vector x(5,1);
    Vector y(5,3);
    std::cout << "x*y = " << scalarProd(x,y) << std::endl;
}


1
2void f(int x) { cout << "int\n"; };
void f(const int x) { cout << "const int\n"; }; //Syntax Fehler


1
2void f(int& x) { cout << "int\n"; };
void f(const int& x) { cout << "const int\n"; }; // OK da Call-by-Reference


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <iostream>
#include <vector>
using std::vector;
class Vector {
private:
  vector<double> coeff;
  
public:
  Vector(int dim=0, double init=0);
  double& get(int k);
  double get(int k) const;
  int size() const;
  double norm() const;
};


1Vector::Vector(int dim, double init): coeff(dim,init){}


1
2
3double Vector::get(int k) const{
    return coeff[k];
}


1
2
3double& Vector::get(int k){
    return coeff[k];
}


1
2
3
4
5
6
7int main(){
    Vector x(5,1);
    const Vector y(5,1);
    x.get(3)=4; //non-const Version of get(), can be used for write access
    std::cout << y.get(3); //const Version of get(), only usable for read access
    return 0;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


1
2
3
4
5
6
7double operator*(const std::vector<double>& x, const std::vector<double>& y){
    double tmp = 0;
    for(int i=0;i<x.size();++i){
        tmp +=x[i]*y[i];
    }
    return tmp;
}


1
2
3
4
5int main(){
    vector<double> x(10,1);
    vector<double> y(10,2);
    std::cout << "x*y = " << x*y << std::endl;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


1
2
3
4
5
6
7double operator*(const std::vector<double>& x, const std::vector<double>& y){
    double tmp = 0;
    for(int i=0;i<x.size();++i){
        tmp +=x[i]*y[i];
    }
    return tmp;
}


1
2
3
4
5
6
7std::vector<double> operator*(double lambda, const std::vector<double>& x){
    vector<double> result(x.size());
    for(int i=0;i<x.size();++i){
        result[i] = x[i]*lambda;
    }
    return result;
}


1
2
3
4
5
6
7std::vector<double> operator*(const std::vector<double>& x, double lambda){
vector<double> result(x.size());
    for(int i=0;i<x.size();++i){
        result[i] = x[i]*lambda;
    }
    return result;
}


1
2
3
4
5
6
7int main(){
    vector<double> x(5,1);
    vector<double> y(5,1);
    y = 3.14*x*10;
    std::cout << "(3.14*x*10)*x = " << x*y << std::endl;
    return 0;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


1
2
3
4
5
6
7std::vector<double> operator+(const std::vector<double>& x, const std::vector<double>& y){
    std::vector<double> result(x.size());
    for(int i=0;i<x.size();++i){
        result[i]=x[i]+y[i];
    }
    return result;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main(){
    vector<double> x(10,1);
    vector<double> y(10,2);
    x = x + y;
    std::cout << "x = (";
    for(int i =0; i<x.size();++i){
        std::cout<< x[i] << " ";
    }
    std::cout << ")" << std::endl;
}


1
2
3#include <iostream>
#include <vector>
using std::vector;


1
2
3
4
5
6
7std::vector<double> operator-(const std::vector<double>& x) {
    std::vector<double> result(x.size());
    for(int i=0;i<x.size();++i){
        result[i]=-x[i];
    }
    return result;
}


1
2
3
4
5
6
7std::vector<double> operator-(const std::vector<double>& x, const std::vector<double>& y){
    std::vector<double> result(x.size());
    for(int i=0;i<x.size();++i){
        result[i]=x[i]-y[i];
    }
    return result;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11int main(){
    vector<double> x(10,1);
    vector<double> y(10,2);
    x = x - y;
    x = - x;
    std::cout << "x = (";
    for(int i =0; i<x.size();++i){
        std::cout<< x[i] << " ";
    }
    std::cout << ")" << std::endl;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <iostream>
#include <vector>
using std::vector;
class Vector {
private:
  vector<double> coeff;
  
public:
  Vector(int dim=0, double init=0);
  Vector operator-() const;
  double& operator[](int i);
  double operator[](int i) const;
  int size() const;
};


1Vector::Vector(int dim, double init): coeff(dim,init){}


1
2
3int Vector::size() const{
    return coeff.size();
}


1
2
3double& Vector::operator[](int i){
    return coeff[i];
}


1
2
3double Vector::operator[](int i) const{ 
    return coeff[i];
}


1
2
3
4
5
6
7
8Vector Vector::operator-() const {
    int dim = coeff.size();
    Vector result(dim);
    for(int i=0;i<dim;++i){
        result[i]=-coeff[i];
    }
    return result;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11int main(){
    Vector x(10,1); 
    const Vector y(10,2);
    std::cout << "y[3] = " << y[3] << std::endl;  //Would not work without const-Version of operator[]
    x = - x;
    std::cout << "x = (";
    for(int i =0; i<x.size();++i){
        std::cout<< x[i] << " ";
    }
    std::cout << ")" << std::endl;
}


1
2
3
4
5
6
7
8
9std::ostream& operator<<(std::ostream& output,
                         const Vector& x) {
    output << "(";
    for(int i=0;i<x.size()-1;++i){
        output << x[i] << ", ";
    }
    output << x[x.size()-1] << ")";
    return output;
}


1
2
3
4
5
6
7int main(){
    Vector x(10,1); 
    const Vector y(10,2);
    std::cout << "y[3] = " << y[3] << std::endl;  //Would not work without const-Version of operator[]
    x = - x;
    std::cout << "x = " << x << std::endl;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <iostream>
#include <vector>

using std::vector;
class Vector {
private:
  vector<double> coeff;

public:
  Vector(double init=0, int dim=1);
  operator double() const;
};


1Vector::Vector(double init, int dim): coeff(dim,init){}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12Vector::operator double() const {
    try{
        if(coeff.size()==1){
            return coeff[0];
        }
        throw coeff.size();
    }
    catch(int n){
        std::cout << "Vectors of length " << n << " can't be converted to double" << std::endl;
        std::abort();
    }
}


1
2
3
4
5
6int main(){
        Vector v = 4.13;
        double x = v;
        std::cout << "x = " << x;
        return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <iostream>
class Vector {
    private:
     double* coeff;
     int dim;
    public:
     Vector(){
         coeff= (double*)0;
         dim = 0;
     }
     Vector(int dim, double init);
     Vector(const Vector& input);
     Vector& tmp(const Vector& input);
     ~Vector();
     double& get(int j){
         return coeff[j];
     }
     double get(int j) const{
         return coeff[j];
     }
     int size() const{
         return dim;
     }
};


1
2
3
4
5
6
7
8Vector::Vector(int dim, double init){
         std::cout << "Constructor" << std::endl;
         coeff = new double[dim];
         this->dim = dim;
         for(int i=0;i<dim;++i){
             coeff[i]=init;
         }
}


1
2
3
4
5
6
7
8Vector(const Vector& input){
         std::cout << "Copy-Constructor" << std::endl;
         coeff = new double[input.size()];
         for(int i=0;i<input.size();++i){
             coeff[i]=input.get(i);
         }
         dim = input.size();
     }


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14Vector& operator=(const Vector& input) {
      std::cout << "Assignement Operator" << std::endl;   
      if (this != &input) {
         if(coeff!=(double*)0){
             delete[] coeff;
         }
         coeff = new double[input.size()];
         dim = input.size();
         for(int i=0;i<input.size();++i){
             coeff[i]=input.get(i);
         }
      }
      return *this;
     }


1
2
3
4
5
6~Vector(){
        std::cout << "Destructor" << std::endl;   
        if(coeff!=(double*)0){
            delete[] coeff;
        }
     }


1
2
3
4
5
6
7int main(){
    Vector x(3,2);
    Vector y = x;
    y.get(2) = 0;
    x=y;
    return 0;   
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10#include <iostream>
using std::cout;

class Parent {
private:
  double x;
public:
  double getX() const { return x; }
  void setX(double input) { x = input; }
};


1
2
3
4
5
6
7class Child : public Parent {
private:
  double y;
public:
  double getY() const { return y; }
  void setY(double input) { y = input; }
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13int main() {
  Parent var1;
  Child var2;

  var1.setX(5);
  cout << "var1.x = " << var1.getX() << "\n";
    
  var2.setX(1);
  var2.setY(2);
  cout << "var2.x = " << var2.getX() << "\n";
  cout << "var2.y = " << var2.getY() << "\n";
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <iostream>
using std::cout;

class Parent {
private:
  double x;
public:
  Parent() { x = 0; }
  Parent(double inx) { x = inx; }
  double getX() const { return x; }
  void setX(double inx) { x = inx; }
};


1
2
3
4
5
6
7
8
9class Child : public Parent {
private:
  double y;
public:
  Child() { x = 0; y = 0; };
  Child(double inx, double iny) { x = inx; y = iny; };
  double getY() const { return y; }
  void setY(double iny) { y = iny; }
};

input_line_9:5:13: error: 'x' is a private member of 'Parent'
  Child() { x = 0; y = 0; };
            ^
input_line_8:5:10: note: declared private here
  double x;
         ^
input_line_9:6:35: error: 'x' is a private member of 'Parent'
  Child(double inx, double iny) { x = inx; y = iny; };
                                  ^
input_line_8:5:10: note: declared private here
  double x;
         ^

Interpreter Error:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <iostream>
using std::cout;

class Parent {
private:
  double x;
public:
  Parent() { x = 0; }
  Parent(double inx) { x = inx; }
  double getX() const { return x; }
  void setX(double inx) { x = inx; }
};


1
2
3
4
5
6
7
8
9class Child : public Parent {
private:
  double y;
public:
  Child() { setX(0); y = 0; };
  Child(double inx, double iny) {setX(inx); y = iny;};
  double getY() const { return y; }
  void setY(double iny) { y = iny; }
};


1
2
3
4
5
6
7
8int main() {
  Parent var1(5);
  Child var2(1,2);
  cout << "var1.x = " << var1.getX() << ", ";
  cout << "var2.x = " << var2.getX() << ", ";
  cout << "var2.y = " << var2.getY() << "\n";
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21#include <iostream>
using std::cout;

class Parent {
private:
  double x;
public:
  Parent() {
    cout << "Parent()\n";
    x = 0;
  }
  Parent(double inx) {
    cout << "Parent(" << inx << ")\n";
    x = inx;
  }
  ~Parent() {
    cout << "~Parent()\n";
  }
  double getX() const { return x; }
  void setX(double inx) { x = inx; }
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20class Child : public Parent {
private:
  double y;
public:
  Child() {
    cout << "Child()\n";
    setX(0);
    y = 0;
  };
  Child(double inx, double iny) {
    cout << "Child(" << inx << "," << iny << ")\n";
    setX(inx);
    y = iny;
  };
  ~Child() {
    cout << "~Child()\n";
  }
  double getY() const { return y; }
  void setY(double iny) { y = iny; }
};


1
2
3
4
5
6
7
8int main() {
  Parent var1(5);
  Child var2(1,2);
  cout << "var1.x = " << var1.getX() << ", ";
  cout << "var2.x = " << var2.getX() << ", ";
  cout << "var2.y = " << var2.getY() << "\n";
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21#include <iostream>
using std::cout;

class Parent {
private:
  double x;
public:
  Parent() {
    cout << "Parent()\n";
    x = 0;
  }
  Parent(double inx) {
    cout << "Parent(" << inx << ")\n";
    x = inx;
  }
  ~Parent() {
    cout << "~Parent()\n";
  }
  double getX() const { return x; }
  void setX(double inx) { x = inx; }
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19class Child : public Parent {
private:
  double y;
public:
  Child() {
    cout << "Child()\n";
    setX(0);
    y = 0;
  };
  Child(double inx, double iny) : Parent(inx) {
    cout << "Child(" << inx << "," << iny << ")\n";
    y = iny;
  };
  ~Child() {
    cout << "~Child()\n";
  }
  double getY() const { return y; }
  void setY(double iny) { y = iny; }
};


1
2
3
4
5
6
7
8int main() {
  Parent var1(5);
  Child var2(1,2);
  cout << "var1.x = " << var1.getX() << ", ";
  cout << "var2.x = " << var2.getX() << ", ";
  cout << "var2.y = " << var2.getY() << "\n";
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13#include <iostream>
#include <vector>
#include <cmath>
using std::vector;
class Polygon {
    private:
        vector<vector<double> > nodes;
    public:
        Polygon(int n=0);
        int size(){ return nodes.size();};
        double length();
        vector<double>& getNode(int j);
};


1Polygon::Polygon(int n): nodes(n,vector<double>(2,0)){}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12double Polygon::length(){
    double tmp=0, dx, dy;
    for(int i=0;i<size()-1;++i){
        dx = nodes[i+1][0]-nodes[i][0];
        dy = nodes[i+1][1]-nodes[i][1];
        tmp += sqrt(dx*dx + dy*dy);
    }
    dx = nodes[0][0]-nodes[size()-1][0];
    dy = nodes[0][1]-nodes[size()-1][1];
    tmp += sqrt(dx*dx + dy*dy);
    return tmp;
}


1
2
3vector<double>&  Polygon::getNode(int j){
    return nodes[j];
}


1
2
3
4
5
6
7int main(){
    Polygon P(3);
    P.getNode(0) = vector<double>{0,0};
    P.getNode(1) = vector<double>{1,0};
    P.getNode(2) = vector<double>{0,1};
    std::cout << "Length = " << P.length();
}


1
2
3
4
5class Triangle: public Polygon {
    public:
        Triangle();
        double area();
};


1Triangle::Triangle(): Polygon(3){}


1
2
3
4
5
6
7double Triangle::area(){
    double ax = getNode(1)[0]-getNode(0)[0];
    double ay = getNode(1)[1]-getNode(0)[1];
    double bx = getNode(2)[0]-getNode(0)[0];
    double by = getNode(2)[1]-getNode(0)[1];
    return 0.5*fabs(ax*by - ay*bx);
}


1
2
3
4
5
6
7
8int main(){
    Triangle T;
    T.getNode(0) = vector<double>{0,0};
    T.getNode(1) = vector<double>{1,0};
    T.getNode(2) = vector<double>{0,1};
    std::cout << "Length = " << T.length() << ", Area = " << T.area() << std::endl;
    return 0;
}


1
2
3
4
5
6
7
8#include <iostream>
using std::cout;

class Parent {
public:
  void print() { cout << "no input\n"; }
  void print(int x) { cout << "input = " << x << "\n"; }
};


1
2
3
4class Child : public Parent {
public:
  void print() { cout << "Child: no input\n"; }
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main() {
  Parent var1;
  Child var2;

  var1.print();
  var1.print(1);
  var2.print();
  var2.print(2);
  return 0;
}

input_line_10:7:8: error: too many arguments to function call, expected 0, have 1; did you mean 'Parent::print'?
  var2.print(2);
       ^~~~~
       Parent::print
input_line_8:6:8: note: 'Parent::print' declared here
  void print(int x) { cout << "input = " << x << "\n"; }
       ^

Interpreter Error:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main() {
  Parent var1;
  Child var2;
    
  var1.print();
  var1.print(1);
  var2.print();
  var2.Parent::print(2); // only change in this line
  return 0;
}


1
2
3
4
5
6
7class Quad: public Polygon {
    public:
        Quad();
        double area();
        double length();
        vector<Triangle> decompose();
};


1Quad::Quad(): Polygon(2){}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12vector<Triangle> Quad::decompose(){
    vector<Triangle> ret(2);
    ret[0].getNode(0) = getNode(0);
    ret[0].getNode(2) = getNode(1);
    ret[0].getNode(1)[0] = getNode(0)[0];
    ret[0].getNode(1)[1] = getNode(1)[1];
    ret[1].getNode(0) = getNode(0);
    ret[1].getNode(2) = getNode(1);
    ret[1].getNode(1)[0] = getNode(1)[0];
    ret[1].getNode(1)[1] = getNode(0)[1];
    return ret;   
}


1
2
3
4double Quad::area(){
    vector<Triangle> Ts  = decompose();
    return Ts[0].area()+ Ts[1].area();
}


1
2
3double Quad::length(){
    return 2*(getNode(1)[0]-getNode(0)[0]) + 2*(getNode(1)[1]-getNode(0)[1]);
}


1
2
3
4
5
6
7
8
9int main(){
    Quad Q;
    Q.getNode(0) = vector<double>{0,0};
    Q.getNode(1) = vector<double>{1,1};
    
    std::cout << "Length = " << Q.length() << ", Area = " << Q.area() << std::endl;
    std::cout << "Polygon::length() = " << Q.Polygon::length() << std::endl;
    return 0;
}


1
2
3
4
5
6
7
8
9#include <iostream>
class Parent {
private:
  int a;
protected:
  int b;
public:
  int c;
};


1
2
3
4
5
6
7
8class Child : public Parent {
public:
  void method() {
    a = 10; // not OK as a is hidden
    b = 10; // OK as b is protected
    c = 10; // OK as c is public
  }
};

input_line_31:4:5: error: 'a' is a private member of '__cling_N523::Parent'
    a = 10; // not OK as a is hidden
    ^
input_line_30:3:7: note: declared private here
  int a;
      ^

Interpreter Error:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13int main() {
  Parent parent;
  parent.a = 10; // not OK as a is private
  parent.b = 10; // not Ok as b is protected
  parent.c = 10; // OK as c is public

  Child child;
  child.a = 10; // not OK as a is hidden
  child.b = 10; // not OK as b is protected
  child.c = 10; // OK as c is public

  return 0;
}

input_line_32:3:10: error: 'a' is a private member of '__cling_N523::Parent'
  parent.a = 10; // not OK as a is private
         ^
input_line_30:3:7: note: declared private here
  int a;
      ^
input_line_32:4:10: error: 'b' is a protected member of '__cling_N523::Parent'
  parent.b = 10; // not Ok as b is protected
         ^
input_line_30:5:7: note: declared protected here
  int b;
      ^
input_line_32:6:3: error: unknown type name 'Child'
  Child child;
  ^

Interpreter Error:


1
2
3
4
5
6
7#include <iostream>
using std::cout;

class Parent {
public:
  void print() {cout << "Parent\n";}
};


1
2
3
4class Child : public Parent {
public:
  void print() {cout << "Child\n";}
};


1
2
3
4
5
6
7
8int main() {
  Child a;
  Child* pA = &a;
  Parent* pB = &a;
  pA->print();
  pB->print();
  return 0;
}


1
2
3
4
5
6
7#include <iostream>
using std::cout;

class Parent {
public:
  virtual void print() {cout << "Parent\n";}
};


1
2
3
4class Child : public Parent {
public:
  void print() {cout << "Child\n";}
};


1
2
3
4
5
6
7
8int main() {
  Child a;
  Child* pA = &a;
  Parent* pB = &a;
  pA->print();
  pB->print();
  return 0;
}


1
2
3
4class Child1 : public Parent {
public:
  void print() {cout << "Child1\n";}
};


1
2
3
4class Child2 : public Parent {
public:
  void print() {cout << "Child2\n";}
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main() {
  Parent* var[2];
  var[0] =  new Child1;
  var[1] =  new Child2;

  for (int j=0; j<2; ++j) {
    var[j]->print();
  }
  return 0;
}


1
2
3
4
5
6
7
8
9#include <iostream>
using std::cout;

class Parent {
public:
  ~Parent() {
    cout << "~Parent()\n";
  }
};


1
2
3
4
5
6class Child : public Parent {
public:
  ~Child() {
    cout << "~Child()\n";
  }
};


1
2
3
4
5int main() {
  Parent* var = new Child;
  delete var;
  return 0;
}


1
2
3
4
5
6
7
8
9#include <iostream>
using std::cout;

class Parent {
public:
  virtual ~Parent() {
    cout << "~Parent()\n";
  }
};


1
2
3
4
5
6class Child : public Parent {
public:
  ~Child() {
    cout << "~Child()\n";
  }
};


1
2
3
4
5int main() {
  Parent* var = new Child;
  delete var;
  return 0;
}


1
2
3
4
5
6
7
8#include <iostream>
using std::cout;

class Parent {
public:
  void ego() { cout << "Parent\n"; }
  void print() { cout << "I am "; ego(); }
};


1
2
3
4class Child1: public Parent {
public:
  void ego() { cout << "Child1\n"; }
};


1class Child2: public Parent {};


1
2
3
4
5
6
7
8
9int main() {
  Parent var0;
  Child1 var1;
  Child2 var2;
  var0.print();
  var1.print();
  var2.print();
  return 0;
}


1
2
3
4
5
6
7
8#include <iostream>
using std::cout;

class Parent {
public:
  virtual void ego() { cout << "Parent\n"; }
  void print() { cout << "I am "; ego(); }
};


1
2
3
4class Child1: public Parent {
public:
  void ego() { cout << "Child1\n"; }
};


1class Child2: public Parent {};


1
2
3
4
5
6
7
8
9int main() {
  Parent var0;
  Child1 var1;
  Child2 var2;
  var0.print();
  var1.print();
  var2.print();
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13#include <iostream>
#include <vector>
#include <cmath>
using std::vector;
class Polygon {
    private:
        vector<vector<double> > nodes;
    public:
        Polygon(int n=0);
        int size(){ return nodes.size();};
        virtual double length();
        vector<double>& getNode(int j);
};


1Polygon::Polygon(int n): nodes(n,vector<double>(2,0)){}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12double Polygon::length(){
    double tmp=0, dx, dy;
    for(int i=0;i<size()-1;++i){
        dx = nodes[i+1][0]-nodes[i][0];
        dy = nodes[i+1][1]-nodes[i][1];
        tmp += sqrt(dx*dx + dy*dy);
    }
    dx = nodes[0][0]-nodes[size()-1][0];
    dy = nodes[0][1]-nodes[size()-1][1];
    tmp += sqrt(dx*dx + dy*dy);
    return tmp;
}


1
2
3vector<double>& Polygon::getNode(int j){
    return nodes[j];
}


1
2
3
4
5class Triangle: public Polygon {
    public:
        Triangle();
        double area();
};


1Triangle::Triangle(): Polygon(3){}


1
2
3
4
5
6
7double Triangle::area(){
    double ax = getNode(1)[0]-getNode(0)[0];
    double ay = getNode(1)[1]-getNode(0)[1];
    double bx = getNode(2)[0]-getNode(0)[0];
    double by = getNode(2)[1]-getNode(0)[1];
    return 0.5*fabs(ax*by - ay*bx);
}


1
2
3
4
5
6class Quad: public Polygon {
    public:
        Quad();
        double area();
        double length();      
};


1Quad::Quad(): Polygon(2){}


1
2
3
4
5double Quad::area(){
    double dx = getNode(1)[0]-getNode(0)[0];
    double dy = getNode(1)[1]-getNode(0)[1];
    return dx*dy;
}


1
2
3double Quad::length(){
    return 2*(getNode(1)[0]-getNode(0)[0]) + 2*(getNode(1)[1]-getNode(0)[1]);
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16int main(){
    vector<Polygon*> mesh(2);
    mesh[0] = new Quad();
    mesh[0]->getNode(0)=vector<double>{0,0};
    mesh[0]->getNode(1)=vector<double>{1,1};
    
    mesh[1] = new Triangle();
    mesh[1]->getNode(0)=vector<double>{1,0};
    mesh[1]->getNode(1)=vector<double>{1,1};
    mesh[1]->getNode(2)=vector<double>{2,1};
    
    std::cout << "Length mesh[0] = " << mesh[0]->length() << std::endl;
    std::cout << "Length mesh[1] = " << mesh[1]->length() << std::endl;
    return 0;
    
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <iostream>
#include <vector>
#include <cmath>
using std::vector;
class Solver {
    private:
        double (*fct)(double);
    protected:        
        double a;
        double b;
        double tol;
        vector<vector<double> > solutions;
        double bisection(double a, double b, double rhs, bool& error);
        double lookup(double rhs, bool& notfound);
        void addSol(double sol, double rhs);
    public:
        Solver(double (*fct)(double) = NULL, double a=0, double b=0, double tol=1e-13);
        void setDomain(double a, double b);
        void setTol(double tol);
        void setFct(double (*fct)(double));
        virtual double eval(double x);
        double solve(double rhs);    
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13void Solver::setDomain(double a, double b){
    try{
        if(a>b){
            throw a;
        }
        this->a=a;
        this->b=b;
    }
    catch(double x){
        std::cout << "Domain boundary invalid" << std::endl;
        std::abort();
    }
}


1
2
3
4void Solver::setFct(double (*fct)(double)){
    this->fct=fct;
    solutions.clear();
}


1
2
3void Solver::setTol(double tol){
    this->tol = tol;
}


1
2Solver::Solver(double (*fct)(double), double a, double b, double tol): 
    fct(fct), solutions(0), a(a), b(b), tol(tol){}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13double Solver::eval(double x){
    try{
        if(x>b || x<a){
            throw x;
        }
        return fct(x);
    }
    catch(double x){
        std::cout << "Evaluation point outside of domain" << std::endl;
        std::abort();
       
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25double Solver::bisection(double a, double b, double rhs, bool& error){
    std::cout << "running bisection algorithm...";
    int counter = 0;
    double m = 0, fm=0;
    double fa = eval(a)-rhs;
    if(fa*(fct(b)-rhs)>0){
        error = true;
        return 0;
    }        
    while(b-a>2*tol){
        counter++;
        m = (a+b)/2;
        fm = eval(m)-rhs;
        if(fa*fm<=0){
            b=m;
        }else{
            a=m;
            fa=fm;
        }
    }
    std::cout << "finished after " << counter << " steps" << std::endl;
    error = false;
    return m;
    
}


1
2
3void Solver::addSol(double sol, double rhs){
    solutions.push_back(vector<double>{sol,rhs});
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10double Solver::lookup(double rhs, bool& notfound){
    for(vector<double> sol : solutions){
        if(fabs(rhs-sol[1])< tol*(1+fabs(sol[1]))){
            notfound = false;
            return sol[0];
        }
    }
    notfound = true;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19double Solver::solve(double rhs){
    bool error;
    double tmp = lookup(rhs,error);
    try{
        if(error){        
            tmp = bisection(a,b,rhs,error);
            if(error){
                throw rhs;
            }
            addSol(tmp,rhs);
        
        }
        return tmp;
    }
    catch(double rhs){
        std::cout << "Can't find solution for given rhs = " << rhs << std::endl;
        std::abort();        
    }
}


1
2
3double f(double x){
    return exp(x)-3;
}


1
2
3
4
5
6
7
8
9int main(){
    Solver S(f,0,5,1e-12);
    double tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12class Solver_Diff : public Solver{
    private:
        double (*deriv)(double);
    protected:
        double newton(double rhs, double x, bool& error);
    public:
        Solver_Diff(double (*fct)(double) = NULL,double (*deriv)(double) = NULL, double a=0, 
                    double b=0, double tol=1e-13);
        void setDeriv(double (*deriv)(double));        
        virtual double evalDeriv(double x);
        double solve(double rhs); 
};


1
2
3
4void Solver_Diff::setDeriv(double (*deriv)(double)){
    this->deriv=deriv;
    solutions.clear();
}


1
2Solver_Diff::Solver_Diff(double (*fct)(double),double (*deriv)(double), double a, double b, double tol) :
Solver(fct,a,b,tol), deriv(deriv){}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12double Solver_Diff::evalDeriv(double x){
    try{
        if(x>b || x<a){
            throw x;
        }
        return deriv(x);
    }
    catch(double x){
        std::cout << "Evaluation point outside of domain" << std::endl;
        std::abort();
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22double Solver_Diff::newton(double rhs, double x0, bool& error){
    std::cout << "running Newton algorithm...";
    double fx0,dfx0,x;
    int counter  = 0;
    while(1){        
        counter++;
        fx0 = eval(x0)-rhs;
        if(fabs(fx0)<tol){
            std::cout << "finished after " << counter << " steps" << std::endl;
            error =false;
            return x0;
        }
        dfx0 = evalDeriv(x0);
        x = x0 - fx0/dfx0;
        if(fabs(dfx0)<tol*fabs(fx0) || fabs(x-x0)<tol*fabs(fx0) || x<a || x>b){
            std::cout << "failed! " << std::endl;
            error = true;
            return 0;
        }
        x0=x;       
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21double Solver_Diff::solve(double rhs){
    bool error;
    double tmp = lookup(rhs,error);
    try{
        if(error){        
            tmp = newton(rhs,0.5*(a+b),error);
            if(error){
                tmp = bisection(a,b,rhs,error);
                if(error){
                    throw rhs;
                }
            }
            addSol(tmp,rhs);
        }
        return tmp;
    }
    catch(double rhs){
        std::cout << "Can't find solution for given rhs = " << rhs << std::endl;
        std::abort();
    }
}


1
2
3double fprime(double x){
    return exp(x);
}


1
2
3double g(double x){
    return atan(x);
}


1
2
3double gprime(double x){
    return 1.0/(1+x*x);
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20int main(){
    Solver_Diff S(f,fprime,-1,5,1e-12);
    std::cout << "** f(x) = exp(x)-3" << std::endl;
    double tmp = S.solve(0);    
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
    std::cout << "** f(x) = atan(x)" << std::endl;
    S.setFct(g);
    S.setDeriv(gprime);
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11class Solver_Poly : public Solver_Diff{
    private:
        vector<double>coeff;
        void setDeriv();
    public:
    
        Solver_Poly(vector<double> coeff = vector<double>(0), double a=0, double b=0, double tol=1e-13);
        void setFct(vector<double> coeff);
        double eval(double x);
        double evalDeriv(double x);
};


1
2Solver_Poly::Solver_Poly(vector<double> coeff , double a, double b, double tol): 
            Solver_Diff(NULL,NULL,a,b,tol), coeff(coeff){}


1
2
3
4void Solver_Poly::setFct(vector<double> coeff){
    this->coeff = coeff;    
    solutions.clear();
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11double Solver_Poly::eval(double x){
    int n = coeff.size();
    if(n==0){
        return 0;
    }
    double tmp = coeff[n-1];
    for(int i=n-2;i>=0;--i){
        tmp = tmp*x + coeff[i]; 
    }
    return tmp;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11double Solver_Poly::evalDeriv(double x){
    int n = coeff.size();
    if(n<=1){
        return 0;
    }
    double tmp = (n-1)*coeff[n-1];
    for(int i=n-2;i>=1;--i){
        tmp = tmp*x + i*coeff[i]; 
    }
    return tmp;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20int main(){
    Solver_Poly S(vector<double>{0.5,0,0,1},-3,5,1e-12);
    
    std::cout << "** f(x) = x^3+0.5" << std::endl;
    double tmp = S.solve(0);    
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
    std::cout << "** f(x) = x^2-4" << std::endl;
    S.setFct(vector<double>{-4,0,1});
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
    return 0;
}


1
2
3#include <iostream>
#include <functional>
using namespace std::placeholders;


1
2
3double add(double a, double b){
    return a+b;
}


1
2
3double mult(double a, double b){
    return a*b;
}


1
2
3
4
5
6
7
8
9int main(){
    std::function<double(double,double)> fct = add;
    std::function<double(double)> multby3 = std::bind(mult,_1,3);
    
    std::cout << "3+4 = " << fct(3,4) <<std::endl;
    fct = mult;
    std::cout << "3*4 = " << fct(3,4) << " = " << multby3(4) << std::endl;
    return 0;
}


1
2
3#include <iostream>
#include <functional>
using namespace std::placeholders;


1
2
3double add(double a, double b){
    return a+b;
}


1
2
3double mult(double a, double b){
    return a*b;
}


1
2
3
4
5
6
7
8
9int main(){
    std::function<double(double,double)> fct = add;
    std::function<double(double)> multby3 = std::bind(mult,_1,3);
    
    std::cout << "3+4 = " << fct(3,4) <<std::endl;
    fct = mult;
    std::cout << "3*4 = " << fct(3,4) << " = " << multby3(4) << std::endl;
    return 0;
}


1
2
3[outside variable list](type1 var1, type2 var2,...)->rettype {
    ...
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <iostream>
#include <functional>

int main(){
    double x=10;
    std::function<void(double,double)> fct = [x](double x1, double x2)->void{ std::cout << x1+x2+x << std::endl;};
    fct(3,4);
    fct = [&x](double x1, double x2)->void{ 
        std::cout << x1+x2+x << std::endl;
        x=0;
    };
    fct(3,4);
    std::cout << x << std::endl;
}


1
2#include <iostream>
#include <functional>


1
2
3double roundup(double a){
    return ((int)a)+1;
}


1
2
3double times2(double a){
    return a*2;
}


1
2
3
4template<typename A, typename B, typename C>
std::function<C(A)> compose(std::function<C(B)> f, std::function<B(A)> g){
    return [f,g](A x)->C{return f(g(x));};
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10int main(){
    std::function<int(double)> ru = roundup;
    std::function<double(double)> t2 = times2;
    std::function<int(double)> times2roundup = compose(ru,t2);
    //Alternativ auch ohne Zwischenspeichern mit Typecast möglich
    /*std::function<double(double)> times2plus3 = compose((std::function<int(double)>)roundup,
            (std::function<double(double)>)times2);*/
    std::cout << "ceil(1.2*2) = " << times2roundup(1.2) << std::endl;
    return 0;
}


1
2
3
4template<typename A, typename B, typename C>
std::function<C(B)> operator*(std::function<C(A)> f, std::function<C(B)> g){
    return [f,g](B x)->A{return f(g(x));};
}


1
2
3
4
5
6int main(){
    std::function<double(double)> p3 = roundup;
    std::function<double(double)> t2 = times2;
    std::cout << "2*ceil(1.2*2) = " << (t2*p3*t2)(1.2) << std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10#include <iostream>
int main(){
    double x[4] = {1,2,3,4};
    double* ptr = x;
    for(int i = 0; i< 4; ++i){
        std::cout << *ptr << " ";
        ptr++;
    }
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <iostream>
#include <vector>
int main(){
    std::vector<int> x{1,2,3,4,5};
    std::vector<int>::iterator it = x.begin();
    auto rit = x.rbegin();
    for(int i=0; i<5;++i){        
        std::cout << "(" << *it << "," << *rit << ") ";
        it++;
        rit++;
    }
    std::cout << std::endl;
    
    for(auto it = x.begin(); it < x.end();++it){        
        *it = 5;  //Non-const iterator kann be used to modify vector entries      
    }
    for(auto it = x.crbegin(); it < x.crend();++it){        
        std::cout <<  *it << " ";   //const iterator can only be used to read vector entries
    }
    std::cout << std::endl;
    std::cout << "Iteratorarithmetik: " << x.begin()[3] << " = " << *(x.begin()+3) << std::endl;
    
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <iostream>
#include <vector>
int main(){
    std::vector<int> x={1,2,3,4,5};
    std::vector<int> y={10};
    x.insert(x.begin(),0);
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    y.insert(y.end(),3,0);
    for(int val : y){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    x.insert(x.begin()+3,y.begin(),y.end());
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <iostream>
#include <set>
#include <vector>
int main(){
    std::set<int> x = {1,2,4,5};
    std::vector<int> y = {1,2,4,5};
    x.insert(3);
    y.insert(y.begin()+2,3);
    
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    for(auto it = x.rbegin();it != x.rend();++it){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    for(auto it = y.rbegin();it != y.rend();++it){
        std::cout << *it << " ";
    }
    // Ohne Iteratoren nicht möglich, das []-Operator für set nicht definiert
    /*
    for(int i=4;i>=0;--i){
        std::cout << x[i] << " ";
    }*/
    return 0;    
}


1
2
3
4#include <iostream>
#include <set>
#include <functional>
using namespace std;


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16int main(){
    function<bool(double,double)> compare = [](double a, double b)->bool{
        return a+0.5<b;
    };
    set<double, function<bool(double,double)> > x(compare);
    x.insert(1.3);
    x.insert(1.1);
    x.insert(1.6);
    x.insert(2.8);
    cout << "x = (";
    for(double val : x){
        cout << val << " ";
    }
    cout << ")" << endl;
    return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17#include <iostream>
#include <vector>

int main(){
    std::vector<int> x={5,3,6,1,4,7,2};
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    std::sort(x.begin(),x.end());
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}


1
2
3
4
5
6#include <iostream>
#include <vector>
//Sort by last digit
bool compare(const int& a,const int& b){
   return (a%10)<(b%10);
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28int main(){
    std::vector<int> x={13,12,9,134,66,71};
    std::cout << "x = ";
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    //sort by last digit
    std::cout << "Sort by last digit:" << std::endl;
    std::sort(x.begin(),x.end(),compare);
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    //sort by even < odd
    std::cout << "Sort even before odd numbers:" << std::endl;
    std::sort(x.begin(),x.end(),
              [](const int&a, const int&b)->bool{
                  return (a%2)<(b%2);
              }
             );
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}


1
2
3
4
5
6#include <iostream>
#include <vector>
#include <algorithm>
int mod2(int a){
   return a%2;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22int main(){
    std::vector<int> x={13,12,9,134,66,71};
    std::vector<int> y(6);
    std::cout << "x = ";
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    std::transform(x.begin(),x.end(),y.begin(),mod2);
    for(int val : y){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    std::transform(x.begin()+2,x.end(),x.begin()+2,[](int a)->int{return a%2;});
    for(int val : x){
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}


1
2
3
4
5#include <iostream>
#include <set>
#include <vector>
#include <functional>
#include <cmath>


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22using std::vector;
using std::set;
using std::function;
class Solver {
private:
    function<double(double)> fct;
protected:
    double a;
    double b;
    double tol;
    set<vector<double>, function< bool(vector<double>,vector<double>) > > solutions;
    double bisection(double a, double b, double rhs, bool& error);
    double lookup(double rhs, bool& notfound);
    void addSol(double sol, double rhs);
public:
    Solver(function<double(double)>, double a = 0, double b = 0, double tol = 1e-13);
    void setDomain(double a, double b);
    void setTol(double tol);
    void setFct(function<double(double)> fct);
    virtual double eval(double x);
    double solve(double rhs);
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13void Solver::setDomain(double a, double b){
    try{
        if(a>b){
            throw a;
        }
        this->a=a;
        this->b=b;
    }
    catch(double x){
        std::cout << "Domain boundary invalid" << std::endl;
        std::abort();
    }
}


1
2
3
4void Solver::setFct(std::function<double(double)> fct) {
    this->fct = fct;
    solutions.clear();
}


1
2
3void Solver::setTol(double tol){
    this->tol = tol;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13Solver::Solver(std::function<double(double)> fct, double a, double b, double tol) :
    fct(fct),
    a(a),
    b(b),
    tol(tol),
    solutions(
        [this](std::vector<double> a, std::vector<double> b)->bool{
            if(a[1]+this->tol< b[1]){
                return true;
            }
            return false;
        }
    ) {}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13double Solver::eval(double x){
    try{
        if(x>b || x<a){
            throw x;
        }
        return fct(x);
    }
    catch(double x){
        std::cout << "Evaluation point outside of domain" << std::endl;
        std::abort();
       
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25double Solver::bisection(double a, double b, double rhs, bool& error){
    std::cout << "running bisection algorithm...";
    int counter = 0;
    double m = 0, fm=0;
    double fa = eval(a)-rhs;
    if(fa*(eval(b)-rhs)>0){
        error = true;
        return 0;
    }        
    while(b-a>2*tol){
        counter++;
        m = (a+b)/2;
        fm = eval(m)-rhs;
        if(fa*fm<=0){
            b=m;
        }else{
            a=m;
            fa=fm;
        }
    }
    std::cout << "finished after " << counter << " steps" << std::endl;
    error = false;
    return m;
    
}


1
2
3void Solver::addSol(double sol, double rhs){
    solutions.insert({sol,rhs});
}


1
2
3
4
5
6
7
8
9double Solver::lookup(double rhs, bool& notfound){
    auto pos = solutions.find({0,rhs});
    if(pos==solutions.end()){
        notfound = true;
        return 0;
    }
    notfound = false;
    return (*pos)[0];
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19double Solver::solve(double rhs){
    bool error;
    double tmp = lookup(rhs,error);
    try{
        if(error){        
            tmp = bisection(a,b,rhs,error);
            if(error){
                throw rhs;
            }
            addSol(tmp,rhs);
        
        }
        return tmp;
    }
    catch(double rhs){
        std::cout << "Can't find solution for given rhs = " << rhs << std::endl;
        std::abort();        
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13using std::function;
class Solver_Diff : public Solver {
private:
    function<double(double)> deriv;
protected:
    double newton(double rhs, double x, bool& error);
public:
    Solver_Diff(function<double(double)>, function<double(double)>, double a = 0,
        double b = 0, double tol = 1e-13);
    void setDeriv(function<double(double)> deriv);
    double evalDeriv(double x);
    double solve(double rhs);
};


1
2
3
4void Solver_Diff::setDeriv(std::function<double(double)> deriv) {
    this->deriv = deriv;
    solutions.clear();
}


1
2Solver_Diff::Solver_Diff(std::function<double(double)> fct, std::function<double(double)> deriv, double a, double b, double tol) :
    Solver(fct, a, b, tol), deriv(deriv) {}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12double Solver_Diff::evalDeriv(double x){
    try{
        if(x>b || x<a){
            throw x;
        }
        return deriv(x);
    }
    catch(double x){
        std::cout << "Evaluation point outside of domain" << std::endl;
        std::abort();
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22double Solver_Diff::newton(double rhs, double x0, bool& error){
    std::cout << "running Newton algorithm...";
    double fx0,dfx0,x;
    int counter  = 0;
    while(1){        
        counter++;
        fx0 = eval(x0)-rhs;
        if(fabs(fx0)<tol){
            std::cout << "finished after " << counter << " steps" << std::endl;
            error =false;
            return x0;
        }
        dfx0 = evalDeriv(x0);
        x = x0 - fx0/dfx0;
        if(fabs(dfx0)<tol*fabs(fx0) || fabs(x-x0)<tol*fabs(fx0) || x<a || x>b){
            std::cout << "failed! " << std::endl;
            error = true;
            return 0;
        }
        x0=x;       
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21double Solver_Diff::solve(double rhs){
    bool error;
    double tmp = lookup(rhs,error);
    try{
        if(error){        
            tmp = newton(rhs,0.5*(a+b),error);
            if(error){
                tmp = bisection(a,b,rhs,error);
                if(error){
                    throw rhs;
                }
            }
            addSol(tmp,rhs);
        }
        return tmp;
    }
    catch(double rhs){
        std::cout << "Can't find solution for given rhs = " << rhs << std::endl;
        std::abort();
    }
}


1
2
3
4
5
6
7
8class Solver_Poly : public Solver_Diff {
private:
    vector<double>coeff;
    void setDeriv();
public:
    Solver_Poly(vector<double> coeff = vector<double>(0), double a = 0, double b = 0, double tol = 1e-13);
    void setFct(vector<double> coeff);
};


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29Solver_Poly::Solver_Poly(vector<double> coeff, double a, double b, double tol) :
    Solver_Diff(
    // Evaluation of the polynomial with Horner scheme    
    [this](double x) -> double {
        int n = this->coeff.size();
        
        if (n == 0) {
            return 0;
        }
        double tmp = this->coeff[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            tmp = tmp * x + this->coeff[i];
        }
        return tmp;
        }, 
    // Evaluation of the derivative of the polynomial with Horner scheme
    [this](double x) -> double {
            int n = this->coeff.size();
            if (n <= 1) {
                return 0;
            }
            double tmp = (n - 1) * this->coeff[n - 1];
            for (int i = n - 2; i >= 1; --i) {
                tmp = tmp * x + i * this->coeff[i];
            }
            return tmp;
        },
    a, b, tol),
    coeff(coeff) {}


1
2
3
4void Solver_Poly::setFct(vector<double> coeff){
    this->coeff = coeff;    
    solutions.clear();
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20int main(){
    Solver_Poly S(vector<double>{0.5,0,0,1},-3,5,1e-12);
    
    std::cout << "** f(x) = x^3+0.5" << std::endl;
    double tmp = S.solve(0);    
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
    std::cout << "** f(x) = x^2-4" << std::endl;
    S.setFct(vector<double>{-4,0,1});
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << ", |f(x)-0| = " << fabs(S.eval(tmp)-0) << std::endl;
    tmp = S.solve(1);
    std::cout << "f(x)=1: x = " << tmp << ", |f(x)-1| = " << fabs(S.eval(tmp)-1) << std::endl;
    tmp = S.solve(0);
    std::cout << "f(x)=0: x = " << tmp << std::endl;
    return 0;
}

Was ist C++¶

Objektorientierte Programmiersprache¶

Wie erstellt man ein C++ Programm?¶

Hello World!¶

Verwendung von using¶

Shell-Input für main¶

Eingabe / Ausgabe¶

Was ist neu in C++?¶

Datentyp bool¶

Funktionen in C++¶

Weiteres zu Default Parametern¶

Überladen von Funktionen¶

Überladen vs. Default Parameter¶

Klassen & Objekte¶

Zugriffskontrolle¶

Beispiel 1/2¶

Methoden implementieren¶

Methoden aufrufen 1/2¶

Methoden direkt implementieren¶

Strukturen¶

Klasse string¶

Wozu Zugriffskontrolle?¶

Try-Throw-Catch¶

Beispiel: Klasse für Brüche mit Zugriffskontrolle¶

Konstruktor & Destruktor 1/2¶

Konstruktor & Destruktor 2/2¶

Konstruktor: Ein Beispiel¶

Namenskonflikt & Pointer "this"¶

Destruktor: Ein Beispiel¶

Methoden: Kurzschreibweise¶

Noch ein Beispiel¶

Schachtelung von Klassen¶

Templates¶

Funktionstemplate 1/2¶

Klassen-Template¶

C++ Standardcontainer¶

Das Vector Template¶

Weitere Eigenschaften von vector 1/2¶

Weitere Eigenschaften von vector 2/2¶

Vektoren mittels vector¶

Matrizen mittels vector¶

Referenzen in C++ (=Pointer light)¶

Call-by-Reference mittels Pointer¶

Call-by-Reference mittels Referenzen¶

Beispiel: Matrix-Vektor Produkt¶

Referenzen vs. Pointer¶

Range based for-Schleife¶

Range based for-Schleife¶

Referenzen als Funktions-Output¶

Referenzen als Methoden-Output¶

Elementare Konstanten¶

Einfache Beispiele zu const¶

Read-Only Referenzen¶

Read-Only Referenzen als Output¶

Type Casting¶

Read-Only Referenzen als Input¶

Beispiel 1: Kopierkonstruktor¶

Beispiel 2: Zuweisungsoperator¶

Beispiel 3: Effiziente Parameterübergabe im Skalarprodukt¶

Lösung: Methoden als const deklarieren¶

Zusammenfassung Syntax¶

Überladen und const¶

Überladen von const-Methoden¶

Überladen von Operatoren¶

Skalar x Vektor, Vektor x Skalar¶

Weiteres Beispiel: Addition für Vektoren¶

Beispiel für unäre Operatoren: negatives Vorzeichen¶

Beispiel für unäre Operatoren als Teil der Klasse¶

Stream Operator << überladen¶

Typecast¶

Zusammenfassung der Syntax¶

Welche Operatoren kann man überladen?¶

Dynamische Speicherverwaltung in C++¶

delete vs. free¶

Negativ Beispiel: Vektor ohne std::vector¶

Vererbung in C++¶

public-Vererbung¶

Formales Beispiel¶

Ein erstes C++ Beispiel¶

private Members vererben 1/2¶

Verwendung von `using`¶

Shell-Input für `main`¶

Datentyp `bool`¶

Klasse `string`¶

Weitere Eigenschaften von `vector` 1/2¶

Weitere Eigenschaften von `vector` 2/2¶

Vektoren mittels `vector`¶

Matrizen mittels `vector`¶

Range based `for`-Schleife¶

Range based `for`-Schleife¶

Stream Operator `<<` überladen¶

`delete` vs. `free`¶

Negativ Beispiel: Vektor ohne `std::vector`¶

`public`-Vererbung¶

`private` Members vererben 1/2¶

`private` Members vererben 2/2¶

`private`, `protected`, `public` 1/2¶

`private`, `protected`, `public` 2/2¶

Pointer und `virtual` 1/3¶

Pointer und `virtual` 2/3¶

Pointer und `virtual` 3/3¶

Destruktor und `virtual` 1/2¶

Destruktor und `virtual` 2/2¶

`lambda`-Expressions und `std::function`¶

`std::bind` und `std::function`¶

Besonders elegant: Den `*`-Operator überladen¶

Iteratoren und neue Funktionalität von `std::vector`¶

Beispiel mit `std::set`¶

Weitere nützliche Eigenschaften von `std::set`¶

Sortieren mit `std::sort`¶

`std::sort` mit eigener Vergleichsfunktion¶

Funktion auf Vektor anwenden mit `std::transform`¶

`algorithms` Bibliothek¶

Solver Klasse mit `std::function`, `std::set` und `lambda` - Expressions¶