[C++] impostazione progetto

[zannas]

Salve a tutti, ogni tanto mi tocca passare di qua a chiedere delucidazioni in quanto purtroppo, il c++ è tanto potente quanto difficile (almeno per me).

Allora, il discorso è questo:
Ho tanti oggetti, che, al loro interno devono contenere tra le varie cose un altro tipo di oggetto.

Putroppo, l'oggetto contenuto (MATERIALE) può essere di diverso tipo (ACCIAIO, CALCESTRUZZO...) che, qualunque materiale sia, avrà al suo interno delle funzioni.

Mi spiego con un po' di codice e vi dico cosa non mi funziona:

class Elemento {
        ...
        Materiale* m; //a priori non conosco che tipo di materiale sia
        ...

        double get_E() {
            m->get_E();
        }

       void set_materiale(Materiale& mat){
            m = &mat;
        }
        
       ...
};

class Materiale {
    public:
        virtual double get_E()=0;
};

class Acciaio : public Materiale {
    ...

    double get_E() {
      E=100.;//variabile propria di Acciaio
      return E; 
    }
};

class CLS : public Materiale {
    ....
    
    double get_E() {
        return Ecls(); //funzione propria
    }
};

nel programma vero e proprio:

int main() {
    std::vector<Elemento> elementi;
    
    ....creo gli elementi...

//assegno materiale
std::vector<Acciaio> acciaio;
std::vector<CLS> cls;

    for (int k=0;k<elementi.size();k++) {
         ....
         //scelta materiale
         switch(scelta) {
              case 1: {
                     acciaio.push_back(Acciaio(...));
                     plate[k].set_materiale(acciaio[acciaio.size()-1]);
                         }
              break;
              case 2: {
                     armatura.push_back(CLS(...));
                     plate[k].set_materiale(cls[cls.size()-1]);
                         }
              break;
        }

successivamente, supponendo di settare tutti gli elementi con Materiale settato su Acciaio, usando

elemento[i].get_E()

mi aspetterei che fornisse il valore di 100, in realtà o non mi funziona e il programma dà errore o mi restituisce 0....

Ora, che sbaglio? E cosa dovrei fare per risolvere?
Ho utilizzato un puntatore in quanto, creando un puntatore di tipo "Materiale" poi posso sfruttare le funzioni delle classi derivate.
E' importante inoltre che ogni ELEMENTO abbia un oggetto MATERIALE suo non "condiviso" con altri ELEMENTI.

Vi ringrazio!!!

[MItaly]

Perché in metà del codice sembra che lavori sul vector elementi, ma dentro al for lavori effettivamente sul vector plate?

(per inciso, invece di acciaio[acciaio.size()-1] puoi semplicemente scrivere acciaio.back())

[zannas]

grazie per la risposta, sopratutto per la seconda!!!
Sulla prima osservazione che hai fatto, plate sono degli oggetti istanziati dalla classe Elementi.

Comunque ho trovato l'errore...una banalità ultrastupida...l'errore è perchè non ho scritto così:

double get_E() {
           return m->get_E();
        }

mi ero dimenticato del return!!!!!

ora ho un altro problema simile, ma prima provo a risolverlo da solo

[zannas]

Ri-Ciao, stavolta ho veramente un errore a cui non so' dare spiegazione....

Praticamente, ogni elemento, oltre al materiale ha al suo interno un vettore di oggetti chiamati nodi (non sò se sia importante ma al momento, il massimo numero di nodi presente sarà 4)

class Elemento {
        Materiale* m;
        public:
        std::vector<Nodo> nodo;
        
        public:
        Plate(int i, int prop) {
            ...
        }
};

A ogni nodo sarà associato un valore.
Nel file principale a un certo punto, ho un codice del genere:

double N_loc[elementi.size()];
for(int i=0;i<elementi.size();i++) {
        double sigma[elementi[i].nodo.size()];
        for(int k=0;k<elementi[i].nodo.size();k++){
            std::cout<<elementi[i].get_E()<<"\n";
            sigma[k]=elementi[i].get_E(); //per esempio
        }
        //integrazione
       N_loc[i]=0.;
       //creo 2 elementi triangolari fittizi
       Plate P1 = Elemento(0,0);
       Plate P2 = Elemento(0,0);
       P1.nodo.push_back(elementi[i].nodo[0]);
       P1.nodo.push_back(elementi[i].nodo[1]);
       P1.nodo.push_back(elementi[i].nodo[2]); //(ASSURDO)
       P2.nodo.push_back(elementi[i].nodo[0]);
       P2.nodo.push_back(elementi[i].nodo[2]);
       P2.nodo.push_back(elementi[i].nodo[3]); //(ASSURDO)

       N_loc[i] = P1.get_area()/3.*(sigma[0]+sigma[1]+sigma[2]);
       N_loc[i] = N_loc[i]+P2.get_area()/3.*(sigma[0]+sigma[2]+sigma[3]);
}

allora, il codice funziona se assegno come materiale CLS o Acciaio, se invece lo assegno come un altro materiale che non sono stato qui a riportare ma che è simile (quasi uguale) ad Acciaio (solo con qualche variabile statica in più) non funziona più! Il tutto torna a funzionare con tutti i materiali se inserisco solo 2 e non 3 nodi (per questo mi sembra assurdo).

In particolare, per essere precisi, per i=0 tutto funziona, il problema avviene non appena i=1, in corrispondenza di elemento[i].get_E();

Io proprio non so' che spiegazione darmi.. Qualche casino con il puntatore interno di ogni elemento m ??!?!

[zannas]

dato che il problema si verifica solo con un materiale specifico, riporto qui la "struttura" di un materiale che funziona e uno con cui non funziona....

class Materiale {
    public:
        virtual double sigma(double& epsilon)=0;
        virtual double get_E()=0;
};
//con questo funziona
class Acciaio : public Materiale {
    double f_yk;
    double E;
    static const double gamma_m0;

    double f_yd;
    double epsilon_yd;

    public:
    Acciaio(double& fyk);

    double sigma(double& epsilon);
    double get_E();
};
//con questo NON funziona
namespace CA {
    class Acciaio : public Materiale {
        static const double f_yk;
        static const double f_tk;
        double E;

        static const double gamma_s;

        static const double f_yd;
        double epsilon_yd;

        public:
        Acciaio();
        double sigma(double& epsilon);
        double get_E();
    };
}

la get_E() di entrambi è uguale e si limita a restituire E.