#include <iostream>
#include <stdexcept>

using namespace std;

class A {
private:
    double *w;        //essendo private, come devo usarlo nelle altre classi?
    short len;

public:
    A(short m);
    virtual double foo(short a) = 0;
    short getLen();

protected:
    double get(short i);
};

class B : A {
private:
    int p;

public:
    B(short m, int x);
    double foo(short a);

protected:
    double sum(short s);
};

template <typename T>
class C : A {
private:
    T x;

public:
    C(short n);
    double foo(short r);
    T g(T k);                   //non ho ben capito cosa sta creando in questo modo???
};

int main() {

    srand(111222333);
    A *vett[50];
    for (int i=0; i<50; i++) {
        short n = 1 + rand()%10;
        switch (rand()%3) {
            case 0:
                vett[i] = new B(n, rand()%10 + 1);
                break;
            case 1:
                vett[i] = new C<double>(n);
                break;
            case 2:
                vett[i] = new C<short>(n);
        }
    }

}

A::A(short m) {
    srand(m); //numeri compresi tra 0 e 1
    double w[m];                      //il programma mi chiede di inizializzare w con m
    len = m;                          //elementi presi casualmente tra 0 e 1, faccio bene ad usare un
    for (int i = 0; i<m; i++) {       //generatore casuale?
        w[i] = rand()%2;
    }
}

double A::get(short i) {
    return w[i%len];
}

short A::getLen() {          // il diagramma uml non mi dice che deve fare getLen()
                             // ho immaginato sia il metodo col quale prendere len, ma come lo
}                            //implemento?

B::B(short m, int x) {       //anche qui costruttore che non so che debba fare,
                             // è un costruttore di default?

}

double B::sum(short s) {
    int somma = 0;
    for (int i=s%len; i<m; i++) {    // il compilatore non mi trova len e w dato che sono privati in A
        somma += w[i];
    }
    sum = somma;
    return sum;
}

double B::foo(short a) {
    return sum(a)/p;

}

template <typename T>
C<T>::C(short n) {
    if constexpr(std::is_same_v<short, T>)     //non ho ben capito questa constexpr, su internet
            int x = n;                         //ho trovato poco, idem per is_same_v<>
    else
        int x = log(1+(sin(n))^2);
}

template <typename T>
C<T>::foo(short r) {
    return g(r);
}

template <typename>
C<T>::g(T k) {                 //credo che l'implementazione sia sbagliata
    return 2*x*(k+1);
}