Cerca nel blog

lunedì 29 settembre 2014

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; 
}

giovedì 25 settembre 2014

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.

lunedì 22 settembre 2014

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:

lunedì 21 ottobre 2013

Il cristianesimo

CRISTIANESIMO:tra i vari cambiamenti in atto durante il 3 secolo dopo cristo dopo i barbari, nel nostro impero romano avviene
un altra notevole trasformazione e che interessa per la prima volta il mondo religioso: la diffusione del cristianesimo a roma.
Da un po di tempo infatti esisteva in urbe una grande tolleranza religiosa proveniente dall' Oriente, e portata a roma grazie
alle conquiste, nelle varie provincie, delle legioni romane; per cui dappertutto si vedevano templi di Giove, Minerva, con
acconto quello di Zeus, Osiride, Anubi di Rha. Questi erano tra gli dei più venerati che garantivano all' uomo la salvezza eterna;
per alcuni di questi dei si praticavano persino sacrifici umani. Così, all' interno di questo fermento religioso, durante i primi
secoli dell' impero romano, si collocò, proveniente dalla palestina, il messaggio diffuso da un certo Gesù di Nazaret, il quale,
aveva proclamato che era giunto sulla terra il regno di Dio e che l' inviato da dio, egli stesso, avrebbe salvato tutti i popoli
della terra e li avrebbe liberati dall' oppressore. Gesù Cristo proclamava che la selvezza non era riservata ai ricchi o ai potenti,
ma specialmente ai più poveri, ai puri di cuore, a coloro che operavano perdonando le offese. La nuova religione cristiana "monoteistica"
predicava ed aveva al centro del suo pernsiero valori ai quali i roman MAI avevano pensato; e parlava di un dio , padre di tutti gli uomini
che stava a di sopra di tutti compreso l' imperatore.

I Pirati

Con il termine pirateria si intende l’attività di quei marinai, i quali, abbandonata per scelta o per costrizione la vita sui vascelli mercantili, abbandonavano, depredavano, violentavano e spesso affondavano le navi altrui, in altomare, nei porti, sui fiumi o nelle insenature. 

Diversi sono i termini con cui venivano indicati questi Barbari, i primi pirati nel corso del tempo; questi bucanieri, filibustieri, corsari; essi commettevano attività illecite e si riunivano nei covi.

La vita a bordo di una nave pirata era piena di contrasti; sui velieri non mancava il lavoro per l’equipaggio, il quale era costantemente impegnato in una manutenzione della nave stessa. Le regole che la ciurma doveva rispettare erano poche ma dure; vediamone alcune: 

1. Nessuno doveva giocare a carte o a dadi per denaro

2. I lumi delle candele dovevano essere spenti alle ore 20

3. Bisognava tenere le proprie armi ben pulite e pronte all’uso

4. Ognuno doveva curare personalmente e lavare la propria biancheria

5. Donne e fanciulle non potevano salire a bordo

6. Tutti avevano diritto di voto, a provviste fresche ed a una reazione di Rhum

7. Chi disertava in battaglia veniva punito con la morte e veniva getto in mare aperto

I Pirati prendevano le loro decisioni in maniera collettiva, non esisteva un Leader, almeno che non fosse il capitano, il quale veniva eletto dalla ciurma, che andava dall’ultimo mozzo al timoniere della nave: il bottino veniva diviso in “quote” uguali anche se raramente al capitano ne venivano assegnate due.