#include <iostream>

typedef double Skalar;

struct Vec
{
  Skalar x, y, z;

  // ---[ Verbund-Operatoren als Methoden (member functions) ]---

  Vec& operator+=(Vec const& v);  // hinzufügen
  Vec& operator-=(Vec const& v);  // wegnehmen
  Vec& operator*=(Skalar s);      // skalieren
};

Vec& Vec::operator+=(Vec const& v)
{
  x += v.x;
  y += v.y;
  z += v.z;
  return *this;
}

Vec& Vec::operator-=(Vec const& v)
{
  x -= v.x;
  y -= v.y;
  z -= v.z;
  return *this;
}

Vec& Vec::operator*=(Skalar s)
{
  x *= s;
  y *= s;
  z *= s;
  return *this;
}

// ---[ zweistellige Operatoren als "gewöhnliche" Funktionen ]---

Vec operator+(Vec const& u, Vec const& v)
{                                         // Vec sum = u;  
  return Vec(u) += v;                     // sum += v;
}                                         // return sum

Vec operator-(Vec const& u, Vec const& v)
{
  return Vec(u) -= v;
}

Vec operator*(Vec const& v, Skalar s) // Skalarmultiplikation
{
  return Vec(v) *= s;
}

Vec operator*(Skalar s, Vec const& v)
{
  return v*s;
}

Skalar operator*(Vec const& u, Vec const& v) // Skalarprodukt
{
  return u.x*v.x + u.y*v.y + u.z*v.z;
}

// ---[ I/O-Operatoren immer als Funktionen ]---

std::ostream& operator<<(std::ostream& os, Vec const& v)
{
  return os << v.x << ' ' << v.y << ' ' << v.z;
}

std::istream& operator>>(std::istream& is, Vec& v)
{
  Vec tmp;
  if (is >> tmp.x >> tmp.y >> tmp.z) // Etikette:
  {                                  // Nur bei vollem Erfolg
    v = tmp;                         // geänderten Wert zurückgeben.
  }
  return is;
}

// ---[ Nutzung ]------------------------------------------------------

int main()
{
  Vec u = { 1,2,3 };
  Vec v = { 1,0,0 };
  Vec w = u + v;

  std::cout << 2*w << '\n'; // 4 4 6

  // LISPeln in C++ - unhandlich, aber erlaubt:
  operator<<( std::cout, 
              operator*( 2, 
                         operator+(u,v) ) ) << '\n';
  // klarer:
  std::cout << 2*(u+v) << '\n';
}