komplex.h

Go to the documentation of this file.

#pragma once
#include <cassert>       // static_assert
#include <cmath>         // sqrt()
#include <iostream>
#include <type_traits>   // std::is_floating_point<T>()
 
//using namespace std;   // don't use in header
 
template <class T>
class Komplex
{
    // check type of template at compile time
    static_assert(std::is_floating_point<T>(),"Vector elements have to be floating point numbers.");  // C++11
public:
    Komplex() : Komplex(T(0),T(0))                           // constructor forwarding  
    { }
        //          |-- Standardwert
    Komplex(T re, T im=0.0) // Parameterkonstruktor mit ein oder zwei Argumenten
    : _re(re), _im(im)
    { }    
   // See rule of five: https://en.cppreference.com/w/cpp/language/rule_of_three
   //
    Komplex(const Komplex<T>&  org)               = default; // Copykonstruktor
    Komplex(      Komplex<T>&& org)               = default; // Movekonstruktor
    Komplex<T>& operator=(const Komplex<T>&  rhs) = default; // Copy-Zuweisungsoperator
    Komplex<T>& operator=(      Komplex<T>&& rhs) = default; // Move-Zuweisungsoperator
    ~Komplex()                                    = default; // Destruktor
 
    //            |--  Member der Instanz werden durch die Methode nicht veraendert!
    T Get_re() const
    {
        return _re;
    }
    void Set_re(T val)
    {
        _re = val;
    }
    //            |--  Member der Instanz werden durch die Methode nicht veraendert!
    T Get_im() const
    {
        return _im;
    }
    void Set_im(T val)
    {
        _im = val;
    }
 
    Komplex<T>& operator+=(const Komplex<T>& rhs);
 
    //                                             |--  Member der Instanz werden durch die Methode nicht veraendert!
    Komplex<T> operator+(const Komplex<T>& rhs) const;
 
    bool operator<(const Komplex<T>& rhs) const
    {
        return _re < rhs._re || ( _re == rhs._re && _im < rhs._im );
    }
 
    bool operator==(const Komplex<T>& rhs) const
    {
        return _re == rhs._re && _im == rhs._im ;
    }
 
    bool operator>(const Komplex<T>& rhs) const
    {
        return !( *this < rhs || *this== rhs ) ;
    }
 
 
protected:
private:
    T _re; 
    T _im; 
};
 
template <class T>
std::ostream& operator<<(std::ostream& s, const Komplex<T>& rhs);
 
 
template <class T>
Komplex<T> operator+(T lhs, const Komplex<T>& rhs);
 
 
template <class T>
T abs(const Komplex<T>& rhs)
{
    return std::sqrt(rhs.Get_re()*rhs.Get_re()+rhs.Get_im()*rhs.Get_im());
}
 
 
#include "komplex.tcc"