Programmverständnis

#include <iostream>
 
class Probe {
    public:
        Probe() {
            std::cout << "X ";
        }
 
        ~Probe() {
            std::cout << "Z ";
        }
        Probe fun1(Probe &p) {
            return p;
        };
};
 
void fun2(Probe &p) {
    Probe z = p; // Kein Copy-Konstruktor wird aufgerufen.
};
 
int main() {
    Probe p1; // Konstruktor wird aufgerufen -> X
    p1 = p1.fun1(p1); // fun1 ruft die Referenz auf. Keine Kopie wird erstellt.
    fun2(p1); // fun2 ruft die Referenz auf. In der Funktion wird eine Kopie erstellt.
    Probe p2 = p1; // Kopierkonstruktor wird aufgerufen.
    return 0; // Destruktor wird aufgerufen für p1 und p2 -> Z Z
};

X Z Z Z Z

#include<iostream>
template<typename T>
bool equal(T a, T b) {
    return a == b;
}
 
int main() {
    std::cout << equal<int>(3, 4) << "\n";
    std::cout << equal<double>(3, 3.0) << "\n";
 
    int a=1, b=1;
    std::cout << equal<int*>(&a, &b) << "\n";
    return 0;
}

#include <iostream>
class Test {
    public:
        Test() {
            std::cout << "A ";
        }
 
        Test(const Test& t) {
            std::cout << "B ";
        }
 
        ~Test() {
            std::cout << "C ";
        }
};
 
Test fun(Test t) { // t wird kopiert (keine Referenz) -> B
    Test x = t; // x wird aus t kopiert -> B
} // Destruktor wird aufgerufen für t und x -> C C
 
int main() {
    Test t1; // Konstruktor wird aufgerufen -> A
    fun(t1);
    Test t2 = t1; // Kopierkonstruktor wird aufgerufen -> B
    return 0; // Destruktor wird aufgerufen für t1 und t2 -> C C
}

A B B C C B C C

#include <iostream>
 
template<typename T>
T add(T a, T b) {
    return a + b;
}
 
int main() {
    std::cout << add<int>(3, 4) << "\n";
    std::cout << add<double>(3, 4.5) << "\n";
    std::cout << add<std::string>("Hello , ", "World!") << "\n";
    return 0;
}

funktional
7
7.5
Hello , World!

#include <iostream >
class Element {
    private:
        int _data = 0;
 
    public:
        Element(int data) : _data(data) {
            std::cout << "Erzeugt(" << _data << ") " << std::endl;
        }
 
        Element(const Element& e) : _data(e._data + 1) {
            std::cout << "Kopiert(" << _data << ") " << std::endl;
        }
 
        ~Element () {
            std::cout << "Zerstoert(" << _data << ") " << std::endl;
        }
 
        Element& operator=(const Element& e) {
            if (this != &e) {
                _data = e._data + 5;
                std::cout << "Zugewiesen(" << _data << ") " << std::endl;
            }
            return *this;
        }
};
 
int main() {
    Element e1(10); // Konstruktor wird aufgerufen -> Erzeugt(10)
    Element e2(20); // Konstruktor wird aufgerufen -> Erzeugt(20)
    Element e3 = e2; // Kopierkonstruktor wird aufgerufen -> Kopiert(21)
    e1 = e3; // Zuweisungsoperator wird aufgerufen -> Zugewiesen(26)
    return 0; // Destruktor wird aufgerufen in der Reihenfolge: e3, e2, e1 -> Zerstoert(26) Zerstoert(21) Zerstoert(26)
}

Erzeugt(10) Erzeugt(20) Kopiert(21) Zugewiesen(26) Zerstoert(21) Zerstoert(20) Zerstoert(26)

#include <iostream>
#include <vector>
#include <string>
 
template<typename T>
void printElements(const std::vector<T>& vec) {
    std::cout << "Elemente: ";
    for (const T& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << "\n";
}
 
class Punkt {
    public:
        int _x, _y;
        Punkt(int x, int y) : _x(x), _y(y) {}
};
 
int main() {
    std::vector<int> intVec = {1, 2, 3, 4};
    printElements(intVec);
 
    std::vector<std::string> stringVec = {"Hallo", "Welt"};
    printElements(stringVec);
 
    std::vector<Punkt> punktVec = {Punkt(1, 2), Punkt(3, 4)};
    printElements(punktVec);
 
    return 0;
}

nicht funktional
Elemente: 1 2 3 4
Elemente: Hallo Welt
FEHLER: Für Klasse Punkt gibt es keinen << Operator.

#include <iostream>
 
class Value {
    protected:
        int _value;
    public:
        Value(int value) : _value(value) {
            std::cout << "K: " << _value << std::endl;
        }
 
        Value(const Value& m) : _value(m._value) {
            std::cout << "C: " << _value << std::endl;
        }
        
        ~Value () {
            std::cout << "D: " << _value << std::endl;
        }
        
        Value& operator ++() {
            _value = _value + 1;
            std::cout << "I: " << _value << std::endl;
            return *this;
        }
};
 
int main() {
    Value m1(1);
    Value m2 = ++m1;
    Value m3(3);
    m3 = ++m2;
    ++m3;
    return 0;
}

K: 1
I: 2
C: 2
K: 3
I: 3
I: 4
D: 4
D: 3
D: 2

#include <iostream>
#include <map>
#include <string>
 
template <typename K, typename V>
void printMap(const std::map<K, V> &myMap) {
    for (const auto &pair: myMap) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }
    std::cout << std::endl;
}
 
class C {
    public:
        int _x;
        C(int x) : _x(x) {};
};
 
std::ostream &operator<<(std::ostream &os , const C &c) {
    os << c._x;
    return os;
}
 
int main() {
    std::map<std::string, double> map1 = {{"Apfel", 0.2}, {"Kirsche", 0.05}, {"Banane", 0.3}};
    printMap(map1);
 
    std::map<C, double> map2 = {{C(2), 12.0} , {C(1), 42.0}};
    printMap(map2);
 
    return 0;
}

Apfel: 0.2
Banane: 0.3
Kirsche: 0.05
! Sortierung durch std::map -> Apfel, Banane, Kirsche

class C {
    public:
        int _x;
        C(int x) : _x(x) {}
 
        // Vergleichsoperator für die Sortierung in std::map
        bool operator<(const C &other) const {
            return _x < other._x;
        }
};

! Sortierung durch std::map -> 1, 2
1: 42
2: 12