#include <iostream>
#include <concepts>

concept Vieleck<typename V>{
    typename length_type;
    requires std::ArithmeticLike<length_type>;

    int anzSeiten(const V&);
    length_type getSeitenlaenge(const V&, int index);
}
////////////////////////////////////////////////////////////////////////////
class Viereck{
public:
    int Seiten[4];
    Viereck(int a, int b, int c, int d) {
	Seiten[0]=a;
	Seiten[1]=b;
	Seiten[2]=c;
        Seiten[3]=d;
    };
};

int anzSeiten(const Viereck& vier){ return 4; };
int getSeitenlaenge(const Viereck& vier, int index){
    return vier.Seiten[index];
};

concept_map Vieleck<Viereck>{}

template <Vieleck V>
V::length_type Umfang(const V& ve){
    Vieleck<V>::length_type sum = 0;
    for (int i = 0;  i < anzSeiten(ve); i++) sum += getSeitenlaenge(ve,i);
    return sum;
};
/////////////////////////////////////////////////////////////////////////////
class Rechteck{
public:
    double Laenge;
    double Breite;
    Rechteck(double a, double b){
	Laenge = a;
        Breite = b;
    };
};

concept rechtwinkligesViereck<typename T> : Vieleck<T> {}

concept_map rechtwinkligesViereck<Rechteck>{
   typedef double length_type;
   int anzSeiten(const Rechteck& q) { return 4; };
   double getSeitenlaenge(const Rechteck& q, int index){
       if (index % 2)
	   return q.Laenge;
       else
           return q.Breite;
   }; 
}

template <rechtwinkligesViereck V> 
V::length_type Umfang(const V& ve){ 
    return 2 * (getSeitenlaenge(ve, 0) + getSeitenlaenge(ve, 1));
};

template <typename V> 
    requires rechtwinkligesViereck<V>
V::length_type Flaeche(const V& ve){ 
    return (getSeitenlaenge(ve, 0) * getSeitenlaenge(ve, 1));
};

/////////////////////////////////////////////////////////////////////////////
class Quadrat{
public:
    long double Seite;
    Quadrat(long double a) {
	Seite = a;
    };
};

concept gleichseitigesVieleck<typename T> : Vieleck<T> {}

concept_map gleichseitigesVieleck<Quadrat>{
   typedef long double length_type;
   int anzSeiten(const Quadrat& q) { return 4; };
   long double getSeitenlaenge(const Quadrat& q, int index){
       return q.Seite;
   };
};

concept_map rechtwinkligesViereck<Quadrat>{
   typedef long double length_type;
   int anzSeiten(const Quadrat& q) { return 4; };
   long double getSeitenlaenge(const Quadrat& q, int index){
       return q.Seite;
   };
};

template <gleichseitigesVieleck V> 
requires !rechtwinkligesViereck<V>
V::length_type Umfang(const V& ve){ 
    return anzSeiten(ve) * getSeitenlaenge(ve, 0);
};


////////////////////////////////////////////////////////////////////////////
int main(){

    Viereck v1(10, 12, 15, 13);
    std::cout <<  Umfang(v1) << std::endl;

    Rechteck r(10.1, 20);
    std::cout <<  Umfang(r) << std::endl;
    std::cout <<  Flaeche(r) << std::endl;

    Quadrat q(12.1);
    std::cout <<  Umfang(q) << std::endl;
    std::cout <<  Flaeche(q) << std::endl;
}