Aufgabe 17a

Schwierigkeitsgrad: Mittel

Themen: Objektorientierung

---

Aufgabenstellung

In dieser Aufgabe sollen Sie ein Programm schreiben, welches die Federkennlinien verschiedener Federnarten berechnet und malt.

Implementieren Sie eine Klasse Vektor, die drei kartesische Komponenten im dreidimensionalen Raum speichert.

Details:

• Private Attribute: int x, y, z
• Konstruktor(en) zum Initialisieren der Komponenten
• Getter-Methoden für alle drei Komponenten
• Methode double betrag() zur Berechnung der Vektorlänge
• Methode Vektor pow(double n) const zur Berechnung der n-ten Potenz des Vektors
• Operatorüberladung für die Addition von zwei Vektoren Vektor operator+(const Vektor &lhs, const Vektor& rhs);
• Operatorüberladung für die Multiplikations eines Vektors mit einem Skalar
• Operatorüberladung um den Vektor auf der Konsole auszugeben friend std::ostream& operator<< (std::ostream& os, const Vektor& vec);
• Testen Sie die Klasse mit mindestens zwei Objekten und deren Addition, geben Sie die Ergebnisse aus.

 

Lösung

#pragma once
#include <iostream>
#include <math.h>

class Vektor {
    private:
    double x, y, z;
    
    public:
    // Konstruktoren
    Vektor();
    Vektor(int x, int y, int z);
    Vektor(Vektor& other);

    // Getter-Methoden für alle drei Komponenten
    int get_x() const;
    int get_y() const;
    int get_z() const;

    // Methode `double betrag()` zur Berechnung der Vektorlänge
    double betrag();

    // Methode zur Berechnung der n-ten Potenz für jedes Element des Vektors
    Vektor pow(double n) const;

    // Methode um den Vektor auf der Konsole auszugeben
    friend std::ostream& operator<< (std::ostream& os, const Vektor& vec);
};

// Operatorüberladung für die Addition von zwei `Kraftvektor`-Objekten
Vektor operator+(const Vektor &lhs, const Vektor& rhs);

// Operatorüberladung für die Multiplikation eines Vektors mit einem Skalar
Vektor operator*(const Vektor &lhs, const double& rhs);

vektor.cpp

#include "vektor.hpp"

// Konstruktoren
Vektor::Vektor(): x(0), y(0), z(0) {
}
Vektor::Vektor(int x, int y, int z): x(x), y(y), z(z) {
}
Vektor::Vektor(Vektor& other): x(other.x), y(other.y), z(other.z) {
}

// Getter-Methoden für alle drei Komponenten
int Vektor::get_x() const {
    return this->x;
}

int Vektor::get_y() const {
    return this->y;
}

int Vektor::get_z() const {
    return this->z;
}

// Methode `double betrag()` zur Berechnung der Vektorlänge
double Vektor::betrag() {
    return std::sqrt(this->x * this->x + this->y * this->y + this->z * this->z);
}

// Methode zur Berechnung der n-ten Potenz für jedes Element des Vektors
Vektor Vektor::pow(double n) const {
    return Vektor(std::pow(this->x, n), std::pow(this->y, n), std::pow(this->z, n));
}

// Methode um den Vektor auf der Konsole auszugeben
std::ostream& operator<< (std::ostream& os, const Vektor& vec) {
    os << "( "<< vec.x << ", " << vec.y << ", " << vec.z << ")\n";
    return os;
}

// Methode oder Operatorüberladung für die Addition von zwei `Kraftvektor`-Objekten
Vektor operator+(const Vektor &lhs, const Vektor& rhs) {
    return Vektor(lhs.get_x() + rhs.get_x(), lhs.get_y() + rhs.get_y(), lhs.get_z() + rhs.get_z());
}

// Operatorüberladung für die Multiplikation eines Vektors mit einem Skalar
Vektor operator*(const Vektor &lhs, const double& rhs) {
    return Vektor(lhs.get_x() * rhs, lhs.get_y() * rhs, lhs.get_z() * rhs);
}

---