Implementierungsdatei der Vektor-Klasse


  // Implementierung der Klassendeklaration von vektor_h

  #include "vektor.h"         // Einbinden der Definitionsdatei für Vektoren
  #include <iostream.h>       // Einbinden der I/O-Routinen

  // +-----------------------------------------+
  // | Konstruktor (inkl. Default-Konstruktor) |
  // +-----------------------------------------+

  vektor::vektor(double a, double b, double c)
  {
    elem[0] = a;               // Einfaches Setzen der Array-Einträge
    elem[1] = b;
    elem[2] = c;
  };

  // +------------------+
  // | Copy-Konstruktor |
  // +------------------+

  vektor::vektor(const vektor& v)
  {
    for (int i = 0; i < 3; i++)
      elem[i] = v.elem[i];     // Übernahme der Einträge des Vektors v
  };

  // +------------+
  // | Destruktor |
  // +------------+

  vektor::~vektor()
  {
  };

  // +---------------------------------------------+
  // | Funktion zum Auslesen eines Vektoreintrages |
  // +---------------------------------------------+

  double vektor::liefer(int i)
  {
    // Schauen, ob der übergebene Index i zulässig ist
    if (i < 0 || i > 2) {
      cout << "Zugriff nicht moeglich!" << endl;
      return 0;
    }
    return elem[i];
  };

  // +-------------------------------------------+
  // | Funktion zum Setzen eines Vektorelementes |
  // +-------------------------------------------+

  void vektor::setze(int i, double d)
  {
    // Schauen, ob der übergebene Index i zulässig ist
    if (i < 0 || i > 2)
      cout << "Zugriff nicht moeglich!" << endl;
    else
      elem[i] = d;
  };

  // +-------------------------------------+
  // | Funktion zum Ausgeben eines Vektors |
  // +-------------------------------------+

  void vektor::ausgabe()
  {
    for (int i = 0; i < 3; i++)
      cout << endl << elem[i];   // Vektor wird elementweise ausgegeben
  };

  /*
  --------------------------------------------------------------------------
    Überladen der OPERATOREN:
  --------------------------------------------------------------------------
  */

  // +--------------+
  // | Unäres Minus |
  // +--------------+

  vektor& vektor::operator-()
  {
    for (int i = 0; i < 3; i++)
      elem[i] *= (-1);           // Multiplikation der Vektoreinträge mit (-1)

    return *this;
  };

  // +-------------------------------------+
  // | Additionsoperator (Vektor + Vektor) |
  // +-------------------------------------+

  vektor vektor::operator+(const vektor& b)
  {
    vektor c;

    for (int i = 0; i < 3; i++)
      c.elem[i] = elem[i] + b.elem[i];       // elementweises Addieren

    return c;
  };

  // +----------------------------------------+
  // | Subtraktionsoperator (Vektor - Vektor) |
  // +----------------------------------------+

  vektor vektor::operator-(const vektor& b)
  {
    vektor c;


    for (int i = 0; i < 3; i++)
      c.elem[i] = elem[i] - b.elem[i];       // elementweises Subtrahieren

    return c;
  };

  // +-------------------------------------+
  // | Additionsoperator (Vektor + Vektor) |
  // +-------------------------------------+

  vektor& vektor::operator+=(const vektor& b)
  {
    for (int i = 0; i < 3; i++)
      elem[i] += b.elem[i];                  // elementweises Addieren

    return *this;
  };

  // +----------------------------------------+
  // | Subtraktionsoperator (Vektor - Vektor) |
  // +----------------------------------------+

  vektor& vektor::operator-=(const vektor& b)
  {
    for (int i = 0; i < 3; i++)
      elem[i] -= b.elem[i];                  // elementweises Subtrahieren

    return *this;
  };

  // +-------------------------------------------+
  // | Multiplikationsoperator (Vektor * double) |
  // +-------------------------------------------+

  vektor vektor::operator*(double d)
  {
    vektor c;

    for (int i = 0; i < 3; i++)
      c.elem[i] = elem[i] * d;               // elementweises Multiplizieren

    return c;
  };

  // +-------------------------------------------+
  // | Multiplikationsoperator (Vektor * double) |
  // +-------------------------------------------+

  vektor& vektor::operator*=(double d)
  {
    for (int i = 0; i < 3; i++)
      elem[i] *= d;                          // elementweises Multiplizieren

    return *this;
  };

  // +---------------------------------+
  // | Skalarprodukt (Vektor x Vektor) |
  // +---------------------------------+

  double vektor::operator*(const vektor& b)
  {
    double a = 0;

    for (int i = 0; i < 3; i++)
      a += elem[i] * b.elem[i];              // kanonisches Skalarprodukt

    return a;
  };

  /*
    FRIEND- Funktionen
  */

  // +-------------------------------------------+
  // | Multiplikationsoperator (double * Vektor) |
  // +-------------------------------------------+

  vektor operator*(double d, const vektor& v)
  {
    vektor c;

    for (int i = 0; i < 3; i++)
      c.elem[i] = d * v.elem[i];           // elementweises Multipizieren

    return c;
  };