Classi c++

[ing82]

Creo la classe materiale1 in questo modo

class materiale1

{

public:

void scegli();//sceglie la classe del materiale e assegna il valore a valore1

double out_valore1-1();//restituisce valore1-1

double out_valore1-2();//restituisce valore1-2

private:

double valore1;

double valore1-1;

double valore1-2;

}

Creo la classe materiale2

class materiale2

{

public:

void scegli();//sceglie la classe del materiale e assegna il valore a valore2

double out_valore2-1();//restituisce valore2-1

double out_valore2-2();//restituisce valore2-2

private:

double valore2;

double valore2-1;

double valore2-2;

}

Le proprietà di questi due materiali devono molto spesso essere usate assieme per calcolare delle resistenze.

Se l'unione di materiale1 e materiale2 dovesse essere mat_composto, potrei definire la classe mat_composto, al cui interno dovrei trovare il sistema per usare materiale1 e materiale2, come fare?
Provo a scrivere quello che pensavo di fare, se si può fare di meglio o quanto ho in mente è sbagliato vi chiedo la cortesia di spiegarmi come si deve fare cercando per quanto possibile di sfruttare le tre classi qui definite, non sono un programmatore di professione, ma solo per necessità...

class mat_composto

{

public:

//qui metto le funzioni che servono per mat_composto ad esempio la funzione
//resistenza che tra i parametri che le servono ci sono anche ad esempio
//valore1-1 di materiale1 e valore2-2 di materiale2
double resistenza(double valore1-1, double valore2-2, altri parametri...);

private:

materiale1 mat1;
materiale2 mat2;

}

[Rising1]

allora intanto "valore1-1", "valore1-2" etc non possono essere dichiarati perche nei nomi delle variabili non deve essere presente il "-" o altri simboli "fraintendibili". Sostituire "-" con "_" in tutti i nomi
detto questo nella classe mat_composto puoi dichiarare un costruttore del tipo

public:
mat_composto(Materiale1 mat1in,Materiale2 mat2in)
{
mat1=mat1in;
mat2=mat2in;
}

ma è meglio aggiungere alle classi materiale1 e materiale2 l'overload dell'operatore = (in realtà potrebbe non essere necessario ma dipende da come effettivamente sia fatta più nel dettaglio la classe)
Adesso resistenza(altri parametri) può accedere ai metodi di mat1 e mat2 direttamente senza bisogno di ricevere come argomenti anche valore1-1 e valore 2-2
(ricordo di modificare questi valore1-1 in valore1_1)

//esempio:
class mat_composto{
//etc...
public:
double resistenza(altri parametri...)
{
double val;
val=mat1.out_valore1-1()
//etc
}

}

int main()
{
materiale1 mat1;
materiale2 mat2;
//...
mat_composto matcom(mat1,mat2);
double res=matcom.resistenza(altri parametri);
}

[ing82]

In effetti non ho mai usato "-", ma sempre "_", però inconsapevolmente, grazie dell'osservazione.
Adesso vediamo se ho capito (premesso che ho sentito parlare di overload, ma devo andare a "studiarmelo" per capirne a fondo le potenzialità).
Riscrivo tutto da capo:

class materiale1
{
    public:
        //tentativo di implementare l'overload di "="
        //seguendo un esempio trovato col simbolo "+"
        materiale1 operator=(const materiale1& m1)
        {
            materiale1 mtemp; 
            mtemp.valore1 = m1.valore1; 
            mtemp.valore1_1 = m1.valore1_1;
            mtemp.valore1-2 = m1.valore1_2;
            return mtemp;
        }
        void scegli();//sceglie la classe del materiale e assegna il valore a valore1
        double out_valore1_1();//restituisce valore1_1
        double out_valore1_2();//restituisce valore1_2
    private:
        double valore1;
        double valore1_1;
        double valore1_2;

}

class materiale2
{
    public:
        //tentativo di implementare l'overload di "="
        //seguendo un esempio trovato col simbolo "+"
        materiale2 operator=(const materiale2& m2)
        {
            materiale2 mtemp; 
            mtemp.valore2 = m2.valore2; 
            mtemp.valore2_1 = m2.valore2_1;
            mtemp.valore2-2 = m2.valore2_2;
            return mtemp;
        }
        void scegli();//sceglie la classe del materiale e assegna il valore a valore2
        double out_valore2_1();//restituisce valore2_1
        double out_valore2-2();//restituisce valore2_2
    private:
        double valore2;
        double valore2_1;
        double valore2_2;

}


class mat_composto
{
    public:

        mat_composto(materiale1 mat1in,materiale2 mat2in)

        {

            mat1=mat1in;

            mat2=mat2in;

        }
        double resistenza(altri parametri...)
        {
            double val;
            val=mat1.out_valore1-1();

            //etc

        }

    private:

        //eventuali variabili private da definire

}

che poi nel programma principale diventa

int main()
{
    materiale1 mat1;

    materiale2 mat2;

    //...

    mat_composto matcom(mat1,mat2);

    double res=matcom.resistenza(altri parametri);

    return 0;

}

[MItaly]

Tip: per incollare il codice, non è necessario inserire tutti i tag [INDENT] a mano, basta inserirlo tra tag [CODE] ... [/CODE], in questo modo viene rispettata l'indentazione (e viene attivata l'evidenziazione della sintassi). L'ultimo post l'ho sistemato io.

[ing82]

Tip: per incollare il codice, non è necessario inserire tutti i tag[INDENT] a mano, basta inserirlo tra tag

 ...

, in questo modo viene rispettata l'indentazione (e viene attivata l'evidenziazione della sintassi). L'ultimo post l'ho sistemato io.

Allora c'è qualcuno che mi spia...

Grazie, direi che è molto più comodo... (però non sono riuscito a togliere l'effetto del CODE ... /CODE)

[ing82]

Adesso vediamo se ho capito

Nessuno si fa vivo, spero che sia l'effetto del silenzio assenso...(quanto scritto è giusto...)

Avrei ora altre ue domande:

1. ma è sempre più comodo definire una classe in cui inserire le funzioni che servono (ad esempio per mat_composto saranno da implementare più funzioni che calcolano diverse resistenze), oppure non è detto che questa sia sempre la strada migliore, ma basta implementare le funzioni, ognuna che se ne sta per i fatti propri (cioè non all'interno di una classe)?
2. materiale1 può avere valori diversi in base alla normativa di riferimento: secondo voi è meglio definire una classe per ciascuna normativa, o è meglio dare un occhio alle classi derivate e provare a sfruttarle?

Grazie

[ing82]

1. materiale1 può avere valori diversi in base alla normativa di riferimento: secondo voi è meglio definire una classe per ciascuna normativa, o è meglio dare un occhio alle classi derivate e provare a sfruttarle?

Grazie

Sono arrivato alla conclusione che è meglio sfruttare le classi derivate

Tra l'altro mi sembra più comodo sfruttare l'ereditarietà multipla anche per mat_composto, o sbaglio? (a patto di definire protected quelle che erano variabili private)

Spero che qualche anima pia si faccia viva...

[ing82]

Spero che qualche anima pia si faccia viva...

Basta un ok, oppure ma cosa stai dicendo, è tutto sbagliato...

[ing82]

Visto che l'argomento è sempre quello delle classi, mi accodo al post che avevo precedentemente iniziato.
Il problema è gestire una classe che permetta di calcolare le proprietà geometriche di figure piane, anche composte da più figure, il cui input può essere fatto dall'utente o a partire da quanto memorizzato in un file "dxf".
Per ora ho quindi deciso di implementare separatamente la classe "Sezione" e la classe "Filedxf".
Tra i vari metodi della classe sezione ce ne sarà quindi uno che permetterà di interagire con l'oggetto di tipo "Filedxf".
La dichiarazione della classe Sezione sarà quindi simile a quanto segue:

class Sezione
{
public:
inputdadxf(Filedxf file);
...
}

Nel caso di figura composta da una unica sezione, avrei potuto in alternativa includere l'oggetto "Filedxf" tra i membri protected di Sezione.
Ho scartato questa possibilità perchè, per gestire il caso di figure composte da più sezioni, creerò l'oggetto "Sezionemultipla", in cui uno dei suoi membri sarà un vettore costituito da elementi di tipo "Sezione": in questo modo potrò gestire l'input delle n sezioni costituenti la Sezionemultipla singolarmente, per quanto riguarda l'input "a mano" da parte dell'utente".
Per quanto riguarda l'input da file dxf, considerando che le n sezioni saranno comunque tutte nello stesso file e sullo stesso layer, implementerò una funzione membro che gestisca l'inserimento multiplo da file dxf, ma sempre come "oggetto esterno" alla classe, rendendo, spero, meno pesante l'oggetto Sezionemultipla rispetto al caso di inclusione dell'oggetto Filedxf in ciascun elemento di tipo Sezione del vettore.

Cosa ne pensate, ammesso di essermi spiegato?

[ing82]

La discussione è stata spostata

http://forum.html.it/forum/showthrea...2#post25307402