Compito a casa operazioni con frazioni

#include<iostream>
using namespace std;
class Frazione{
            public:
                Frazione();
                ~Frazione();
                Frazione(int in);
                void visualizza();
                void aggiorna();
                int* num;
                int* den;
            private:
                int in;
            };
class Calcolatrice{
                public:
                    void somma(Frazione* b, int* dim);
                    void sottrazione(Frazione* b, int* dim);
                    void moltiplicazione(Frazione* b, int* dim);
                    void divisione(Frazione* b, int* dim);
                    void semplificazione(Frazione* b);
                  };
void Calcolatrice::semplificazione(Frazione *b)
{

    int* i;
    i= new int;
    int* dim;
    dim=new int;
    if(*b->num<*b->den)
    {
        *dim=*b->den;
    }
    else
    {
        *dim=*b->num;
    }
    for(*i=1;*i<*dim;*i=*i+1)
    {
        if((*b->num%*i==0)&&(*b->den%*i==0))
        {
            *b->num=*b->num/ *i;
            *b->den=*b->den/ *i;
        }
    }
    cout<<endl<<"frazione semplificata= "<<*b->num<<"/"<<*b->den;
}
void Calcolatrice::divisione(Frazione* b, int* dim)
{
    int i;
    i=0;
    Frazione* ris;
    ris=new Frazione(i);
    *ris->num=(*b[0].num * *b[1].den);
    *ris->den=(*b[0].den * *b[1].den);
    for(i=2;i<*dim;i++)
    {
        *ris->num=(*ris->num * *b[i].den);
        *ris->den=(*ris->den * *b[i].num);
    }
    cout<<"il risultato è="<<*ris->num<<"/"<<*ris->den;
    semplificazione(ris);
    delete ris;
}
void Calcolatrice::moltiplicazione(Frazione* b, int* dim)
{
    int i;
    i=0;
    Frazione* ris;
    ris=new Frazione(i);
    *ris->num=(*b[0].num * *b[1].num);
    *ris->den=(*b[0].den * *b[1].den);
    for(i=2;i<*dim;i++)
    {
        *ris->num=(*b[i].num * *ris->num);
        *ris->den=(*b[i].den * *ris->den);
    }
    cout<<"il risultato è="<<*ris->num<<"/"<<*ris->den;
    semplificazione(ris);
    delete ris;
}
void Calcolatrice:: sottrazione(Frazione* b, int* dim)
{
    int i;
    i=0;
    Frazione *ris;
    ris=new Frazione(i);
    //cout<<*dim<<b;
    *ris->num=((*b[0].num * *b[1].den)-(*b[1].num * *b[0].den));
    *ris->den=(*b[0].den * *b[1].den);
    for(i=2;i<*dim;i++)
    {
       *ris->num=(*ris->num * *b[i].den)-(*b[i].num * *ris->den);
       *ris->den=(*ris->den * *b[i].den);
    }
    cout<<"il risultato è="<<*ris->num<<"/"<<*ris->den;
    semplificazione(ris);
    delete ris;
}
Frazione::~Frazione()
{
    delete num;
    delete den;
}
void Calcolatrice::somma(Frazione* b, int* dim)
{
    int i;
    i=0;
    Frazione *ris;
    ris=new Frazione(i);
    //cout<<*dim<<b;
    *ris->num=((*b[0].num * *b[1].den)+(*b[1].num * *b[0].den));
    *ris->den=(*b[0].den * *b[1].den);
    for(i=2;i<*dim;i++)
    {
       *ris->num=(*ris->num * *b[i].den)+(*b[i].num * *ris->den);
       *ris->den=(*ris->den * *b[i].den);
    }
    cout<<"il risultato è="<<*ris->num<<"/"<<*ris->den;
    semplificazione(ris);
    delete ris;
    //return 0;
}
Frazione::Frazione(int in)
{
    num=new int;
    den=new int;
    *num=in;
    *den=in;
}
Frazione::Frazione ()
{
    num=new int;
    den=new int;
    cout<<"inserire il numeratore: ";
    cin>>*num;
    cout<<"inserire il denoinatore: ";
    cin>>*den;
}
void Frazione::visualizza()
{
    char*scelta;
    scelta=new char;
    cout<<"la frazione inserita è: "<<*num<<"/"<<*den<<" ";
   /* cout<<"si vuole modificare un elemento della frazione?";
    cin>>*scelta;
    if(*scelta=='s')
        aggiorna();*/
}
void Frazione::aggiorna()
{
    char*scelta;
    char* c;
    c=new char;
    scelta=new char;
    cout<<endl<<"si desidera cambiare un elemento?s-n";
    cin>>*c;
    while(*c=='s')
    {
    cout<<"Si desidera cambiare il numeratore(n) o il denominatore (d)? ";
    cin>>*scelta;
    if(*scelta=='n')
    {
        cout<<"inserisci il numeratore: ";
        cin>>*num;
    }
    else
    {
        cout<<"inserisci il denominatore: ";
        cin>>*den;
    }
    visualizza();
    cout<<endl<<"si desidera cambiare un altro elemento?s-n ";
    cin>>*c;
    }
    *c='n';
    delete scelta;
    delete c;
}
main()
{
    int* dim;
    int *i;
    char *oper;
    oper=new char;
    dim=new int;
    i=new int;
    cout<<"quante frazioni vuoi inserire?";
    cin>>*dim;
    Frazione* a;
    a=new Frazione[*dim];
    //cout<<endl<<a;
    for(*i=0;*i<*dim;*i=*i+1)
    {
        a[*i].visualizza();
        a[*i].aggiorna();
    }
    cout<<"quale operazione si vuole eseguire?(+ - x /)";
    cin>>*oper;
    Calcolatrice* calc;
    calc= new Calcolatrice;
    switch(*oper)
    {
        case '+': calc->somma( a, dim);
                    break;
        case '-': calc->sottrazione(a, dim);
                    break;
        case 'x': calc->moltiplicazione(a, dim);
                    break;
        case '/': calc->divisione(a, dim);
                    break;
    }
    //cout<<"fine programma";
    delete []  a;
   // a.visualizza();
    //a.aggiorna();
}

Compito a casa

#include<iostream>
using namespace std;
typedef struct persona{
                            char nome [15];
                            char cognome[15];
                            float stipendio;
                      }dipendente;
main()
{
    dipendente *a;
    a=new dipendente;
    cout<<"inserire nome: ";
    cin>>a->nome;
    cout<<endl<<"inserire cognome: ";
    cin>>(*a).cognome;
    cout<<endl<<"inserire lo stipendio: ";
    cin>>a->stipendio;

    cout<<endl<<"dati inseriti";
    cout<<endl<<"nome: "<<a->nome;
    cout<<endl<<"cognome: "<<a->cognome;
    cout<<endl<<"stipendio: "<<a->stipendio;
    delete a;
}

Puntatori: array e struct

#include<iostream>
using namespace std;
typedef struct Punto{
                        int ascissa;
                        int ordinata;
                    }punto;
main()
{
    int i, dim;
    cout<<"inserire a dimensione";
    cin>>dim;
    int *a;
    a=new int[dim];
    for(i=0;i<dim;i++)
    {
        //a[i]=i; metodo di assegnazione più semplice
        *(a+i)=i;
    }
    for(i=0;i<dim;i++)
    {
        cout<<a[i]<<" ";
    }
    delete a; //liberiamo la memoria
    cout<<endl;
    punto*insieme;
    insieme= new punto[10];
    for(i=0;i<10;i++)
    {
        insieme[i].ascissa=i; //notazione puntata per raggiungere i singoli campi
        insieme[i].ordinata=i+1;
    }
    for(i=0;i<10;i++)
    {
        cout<<"ascissa: "<<insieme[i].ascissa<<" ";
        cout<<"ordinata: "<<insieme[i].ordinata;
        cout<<endl;
    }
}

in questo esempio notiamo che la new può essere usata per creare array e array di struct. questo è rso possibile dai puntatori poichè la new crea 10 indirizzi contigui e restituisce al puntatore quello di partenza. Per riempire l' array il compilatore somma all' indirizzo di partenza l' indice( *(a+i)=i ), così si posiziona nell area di memoria da riempire con il valore. lo stesso procedimento viene effettuato per l' array di struct. 

Puntatori: new e delete

La funzione new ha due scopi il primo trovare un indirizzo vailido da asseganare al puntatore la seconda è restituirlo al puntatore; gli indirizzi validi sono contenuti nell' heap, è molto importante poichè se non viene usato un indirizzo valido c' è il rischio di sovrascrivere aree di memoria utilizzate da altri programmi ( compreso il sistema operativo) portanto ad errori che possono anche bloccare l' intero sistema, l' heap ha un limitato numero di indirizzi e nel caso finiscano si incorre nell' overflow, per evitare quest' ultimo alla new,che crea, è associata la delete che libererà l' area di memoria.
es:
main()
{
        int*p;
        cout<<p;
        p= new int;
        cout<<p;
        delete p;
}
provand ad eseguire l' esempio si noterà che l' indirizzo contenuto in p dopo la new sarà diverso dal primo.

Compito a casa

# include <iostream>
using namespace std;

class persona{
public:
        persona();//il costruttore vine messo di default
        void visualizza();
        void aggiorna();
private:
    char nome[15];
    char cognome[15];
    char data[15];
    char citta[15];

};
class studente:public persona{
    public:
        studente();//il costruttore vine messo di default
        void visualizza1();
        void aggiorna1();
    private:
        char classe[15];
        char sezione[15];
        char indirizzo[15];
};


class dipendente:public persona{
    public:
        dipendente();//il costruttore vine messo di default
        void visualizza2();
        void aggiorna2();
    private:
    char mansione[15];
    char stipendio[15];
};
persona::persona()
{
    cout<<" Inserire i dati"<<endl;
    cout<<"inserire nome: ";
    cin>>nome;
    cout<<endl<<"inserire cognome: ";
    cin>>cognome;
    cout<<endl<<"inserire data di nascita: ";
    cin>>data;
    cout<<"inserisci città: ";
    cin>>citta;
    cout<<endl;
}
studente::studente()
{
    cout<<"inserire la classe: ";
    cin>>classe;
    cout<<endl<<"inserire la sezione: ";
    cin>>sezione;
    cout<<endl<<"inserire l' indirizzo: ";
    cin>>indirizzo;
    cout<<endl;
}
dipendente::dipendente()
{
    cout<<"inserire la mansione: ";
    cin>>mansione;
    cout<<endl<<"inserire lo stipendio: ";
    cin>>stipendio;
    cout<<endl;
}
void persona::visualizza()
{
    cout<<"questi sono i dati inseriti"<<endl;
    cout<<"nome: "<<nome<<endl;
    cout<<"cognome: "<<cognome<<endl;
    cout<<"data di nascita: "<<data<<endl;
    cout<<"citta: "<<citta<<endl;
}
void studente::visualizza1()
{
    cout<<"classe: "<<classe<<endl;
    cout<<"sezione: "<<sezione<<endl;
    cout<<"indirizzo: "<<indirizzo<<endl;
}
void dipendente::visualizza2()
{
    cout<<"mansione: "<<mansione<<endl;
    cout<<"stipendio: "<<stipendio<<endl;
}
void persona::aggiorna()
{
    char a;
    char x;
    do
    {
    cout<<"quali campi si desidera modificare? n nome, c cognome, d data di nascita,r citta,"<<endl;
    cin>>a;
    switch(a)
    {
        case 'n': cout<<"inserire nuovo nome: ";
                  cin>>nome;
                  break;
        case 'c': cout<<endl<<"inserire nuovo cognome: ";
                  cin>>cognome;
                  break;
        case 'd': cout<<endl<<"inserire nuova data di nasscita: ";
                  cin>>data;
                  break;
        case 'r': cout<<endl<<"inserire nuova citta: ";
                  cin>>citta;
                  break;
    }
    cout<<"vuoi modificare altri campi? s si, n no";
    cin>>x;
    }while(x=='s');
}
void studente::aggiorna1()
{
    char a;
    char x;
    do
    {
    cout<<"quali campi si desidera modificare? c classe, s sezione,i indirizzo,"<<endl;
    cin>>a;
    switch(a)
    {
        case 'i': cout<<"inserire nuovo indirizzo: ";
                  cin>>indirizzo;
                  break;
        case 'c': cout<<endl<<"inserire nuovo classe: ";
                  cin>>classe;
                  break;
        case 's': cout<<endl<<"inserire nuova sezione: ";
                  cin>>sezione;
                  break;
    }
    cout<<"vuoi modificare altri campi? s si, n no";
    cin>>x;
    }while(x=='s');
}
void dipendente::aggiorna2()
{
    char a;
    char x;
    do
    {
    cout<<"quali campi si desidera modificare? m mansione, s stipedio"<<endl;
    cin>>a;
    switch(a)
    {
        case 'm': cout<<"inserire nuova mansione: ";
                  cin>>mansione;
                  break;
        case 's': cout<<endl<<"inserire nuova stipendio: ";
                  cin>>stipendio;
                  break;
    }
    cout<<"vuoi modificare altri campi? s si, n no";
    cin>>x;
    }while(x=='s');
}

main()
{

    char scelta;
    char x,y;
    cout<<"vuoi inserire uno studente (s) o un dipendente (d)?";
    cin>>scelta;
    if(scelta=='s')
    {
        //persona p;
        studente s;
        s.visualizza();
        s.visualizza1();
        cout<<"si desidera modificare i campi?"<<endl;
        cin>>x;
        if(x=='s')
        {
            s.aggiorna();
            s.aggiorna1();
        }
    }
    else
    {
        //persona p;
        dipendente d;
        d.visualizza();
        d.visualizza2();
        cout<<"si desidera modificare i campi?"<<endl;
        cin>>x;
        if(x=='s')
        {
            d.aggiorna();
            d.aggiorna2();
        }
    }
}

Puntatori

I puntatori sono tipi di variabili contraddistinti con il segno * dopo il tipo (int*, float*, double*,etc...), esse non contengono il valore, ma l' indirizzo in cui è allocato.
Un semplice esempio di prova coi puntatori
#include<iostream>
using namespace std;

main()
{
    int* a;
    int b;
    b=5;
    cout<<a<<" questo è l' indirizzo"<<endl;
    cout<<b<<" questo è l' intero"<<endl;
    //a=b; erorrore
    a=&b;
    cout<<a<<" indirizzo dell' intero"<<endl;
    cout<<*a<<"questo è l intero"<<endl;
}

Ereditarietà

L ereditarietà è un concetto importante per tutti i linguaggi di programmazione orientati agli oggetti, serve per aggiornare un vecchio codice aggiungendo nuove funzionalità conservando quelle vecchie. Per effettuare l aggiornamento si usano delle regole di passaggio (o modificatori) e sono 3:
PUBLIC: con questo modificatore solo la parte pubblica e protetta verrà ereditata dalla nuova classe, gli attributi e i metodi che erano pubblici rimarrano pubblici e quelli protetti resteranno protetti.
PROTECTED: usando questo moificatore la parte pubblica e protetta verrà ereditata dalla nuova classe, ma gli attributi e i metodi diventeranno tutti protetti.
PRIVATE:usando questo modificatore la parte pubblica e privata verrà ereditata dalla nuova classe, ma i metodi e gli attributi saranno tutti privati.
Di seguito un semplice esempio di uso dell' ereditarietà:

#include <iostream.h>

class Nonna 
{
private: int n1;
protected: int n2;
public: int n3;
  Nonna() : n1(0),n2(0), n3(0) {}
  void scrivi_Nonna() const;
} ;

class Mamma : protected  Nonna
{
private: int m1;
protected: int m2;
public: int m3;
  Mamma() : m1(0),m2(0), m3(0) {}
  void scrivi_Mamma() const;
} ;

class Figlia : Mamma    // accesso private di default
{
private: int f1;
protected: int f2;
public: int f3;
  Figlia() : f1(0),f2(0), f3(0) {}
  void scrivi_Figlia() const;
};

void Nonna::scrivi_Nonna() const
{
 cout << "\nFunzione-membro scrivi_Nonna:\n";
 cout << "n1 = " << n1 << '\n';
 cout << "n2 = " << n2 << '\n';
 cout << "n3 = " << n3 << '\n';
}

void Mamma::scrivi_Mamma() const
{
 cout << "\nFunzione-membro scrivi_Mamma:\n";
// cout << "n1 = " << n1 << '\n';  // errore
 cout << "n1 e' privato: non si eredita\n";
 cout << "n2 = " << n2 << '\n';
 cout << "n3 = " << n3 << '\n';
 cout << "m1 = " << m1 << '\n';
 cout << "m2 = " << m2 << '\n';
 cout << "m3 = " << m3 << '\n';
}

void Figlia::scrivi_Figlia() const
{
 cout << "\nFunzione-membro scrivi_Figlia:\n";
// cout << "n1 = " << n1 << '\n';  // errore
 cout << "n1 e' privato: non si eredita\n";
 cout << "n2 = " << n2 << '\n';
 cout << "n3 = " << n3 << '\n';
// cout << "m1 = " << m1 << '\n';  // errore
 cout << "m1 e' privato: non si eredita\n";
 cout << "m2 = " << m2 << '\n';
 cout << "m3 = " << m3 << '\n';
 cout << "f1 = " << f1 << '\n';
 cout << "f2 = " << f2 << '\n';
 cout << "f3 = " << f3 << '\n';
}

void scrivi_Figlia(const Figlia& f)
{
 cout << "\nFunzione globale scrivi_Figlia:\n";
// cout << "n1 = " << f.n1 << '\n';  // errore
 cout << "n1 e' privato: inaccessibile\n";
// cout << "n2 = " << f.n2 << '\n';  // errore
 cout << "n2 e' protetto: inaccessibile\n";
// cout << "n3 = " << f.n3 << '\n';  // errore
 cout << "n3 e' protetto (in Mamma): inaccessibile\n";
// cout << "m1 = " << f.m1 << '\n';  // errore
 cout << "m1 e' privato: inaccessibile\n";
// cout << "m2 = " << f.m2 << '\n';  // errore
 cout << "m2 e' protetto: inaccessibile\n";
// cout << "m3 = " << f.m3 << '\n';  // errore
 cout << "m3 e' privato (in Figlia): inaccessibile\n";
// cout << "f1 = " << f.f1 << '\n';  // errore
 cout << "f1 e' privato: inaccessibile\n";
// cout << "f2 = " << f.f2 << '\n';  // errore
 cout << "f2 e' protetto: inaccessibile\n";
 cout << "f3 = " << f.f3 << '\n';
}

int main()
{
 {
  Nonna n;
  n.scrivi_Nonna();
 }
 {
  Mamma m;
  m.scrivi_Mamma();
 }
 cout << "\nPremi return per visualizzare il secondo blocco ";
 char c;
 cin.get(c);
 Figlia f;
 f.scrivi_Figlia();
 scrivi_Figlia(f);
 return 0; 

}

Primo programma con uso di oggetti

#include<iostream>
using namespace std;
class persona
{
    public:
        persona();
        persona(int a);
        ~persona();
        void aggiorna();
        void visualizza();
    private:
        char nome[15];
        char cognome[15];
        int eta;
};

persona::persona()
{
    cout<<endl<<"inserire nome: ";
    cin>>nome;
    cout<<endl<<"inserire cognome: ";
    cin>>cognome;
    cout<<endl<<"inserire età: ";
    cin>>eta;
}
persona::persona(int a)
{
    cout<<"inserire nome: ";
    cin>>nome;
    cout<<endl<<"inserire cognome: ";
    cin>>cognome;
    eta=a;
}
void persona::visualizza()
{
    cout<<"dati inseriti:"<<endl<<"nome:"<<nome<<endl<<"cognome:"<<cognome<<endl<<"età:"<<eta;
}
persona::~persona()
{
    cout<<endl<<"destruction derby";
}
void persona::aggiorna()
{
    char ins;
    cout<<"quali dati si desiderano aggiornare?"<<endl<<"n--> nome c-->cognome e-->età ";
    cin>>ins;
    switch(ins)
    {
        case 'n': cout<<"inserire nuovo nome: ";
                  cin>>nome;
                  break;
        case 'c': cout<<"inserire nuovo cognome: ";
                  cin>>cognome;
                  break;
        case 'e': cout<<"inserire nuova età: ";
                  cin>>eta;
                  break;
    }
}
main()
{
    char scelta;
    int i;
    persona dipendente;
    do
    {
        dipendente.visualizza();
        cout<<endl<<"si desidera modificare i dati?s-n ";
        cin>>scelta;
        if(scelta=='s')
        dipendente.aggiorna();
    }while(scelta!='n');
    persona dipv(18);
    dipv.visualizza();
    persona dip[3];
    for(i=0;i<3;i++)
    {
        cout<<endl<<"dipendente "<<i;
        dip [i].visualizza();
    }
}
Come si può notare nella classe sono stati dichiarati due costruttori con parametri diversi e un solo distruttore. nel main invece sono state effettuate delle prove con diversi tipi di oggetti:
persona dipendente: dichiarato un oggetto senza parametri, quindi viene invocato il costruttore di default.
persona dipv(18): dichiarato un oggetto con un parametro int, quindi verrà chiamato il costruttore con il parametro int.
persona dip[3]: dichiarato un array di oggetti (3 in questo caso), quindi, non avendo ulteriori parametri, verrà invocato il cotruttore di default. Provando ad eseguire il programma si potrà notare come appena, il programma, eseguirà la linea con la dichiarazione degli oggetti il costruttore venga chiamato 3 volte di seguito.
Si può notare inoltre che  prima della fine del programma il distruttore venga invocato 5 volte per liberare la memoria di tutti gli oggetti.

Costruttore-distruttore

Il costruttore è un metodo quando viene dichiarato un oggetto e serve per allocare la memoria del medesimo. Il nome del costruttore deve essere lo stesso della classe, ci possono essere più costruttori a patto che i loro parametri siano differenti. Esiste inoltre un costruttore di default senza parametri.
Il distruttore è sempre un metodo e viene chiamato quando un oggetto viene rilasciato dalla memoria, infatti serve per liberare lo spazio sulla memoria, deve avere lo stesso nome della classe preceduto dal carettere speciale ~, il distruttore è uno solo non necessitando di parametri. Come per il costruttore esiste un  distruttore di default.
Di seguito un semplice esempio di uso di costrotturi e distruttori:

#include<iostream>
using namespace std;
class A{        //dichiaro una classe
                //di defaukt gli attributi sono privati, cioè nn accessibile dall'esterno
        int c;
       public:     // con public rendo i metodi accessibili dall'esterno
        A();    // costruttore
        A(int a);
        A(float a);
        ~A();   // distruttore
        void stampa(); //dichiaro un metodo
        };
void A::stampa() //definizione sterna del metodo stampa
{
        cout << c;
}
A::A(int a)//inizializzo c con il costruttore
{
   cout << "sono int"<<a;
}
A::A(float a)//inizializzo c con il costruttore
{
   cout << "\nsono float"<<a;
}
A::A()//inizializzo c con il costruttore
{
cout << "eseguo costruttore \n";
}
A::~A()// liberiamo la memoria occupata dall'oggetto
{
cout << "eseguo distruttore\n";
}
 main() //corpo
 {
   //dichiarazione di un oggetto
  //B.c; error 'int A::C is private'
  A stampa(5);//notazione puntata per raggiungere il metodo nell'oggetto
  A stampa1((float)1.5);
  A stampa2;
  return 0;
}


Provando ad eseguire il programma si noterà quando il costruttore e il distruttore vengono chiamati.

Classi ed oggetti

Un oggetto è un elemento dotato di attributi e metodi, i quali posso essere pubblici, ovvero accessibili dal main, oppure privati, non accessibili dal main. Le classi invece ci servono per creare l' interfaccia cioè gli attributi e i metodi dell' oggetto e per definire se debbano essere pubblici o privati. Lo scopo delle classi è quello di permettere all' oggetto di essere utilizzato da terzi senza il bisogno di sapere come ne agiscano i metodi.  un esempio di creazione ed suo di una classe: