Cerca nel blog

Visualizzazione post con etichetta Informatica. Mostra tutti i post
Visualizzazione post con etichetta Informatica. Mostra tutti i post

mercoledì 22 ottobre 2014

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

martedì 14 ottobre 2014

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.

mercoledì 8 ottobre 2014

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

lunedì 6 ottobre 2014

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

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

Tabella ASCII





ASCII è l'acronimo di American Standard Code for Information Interchange.




È un sistema di codifica dei caratteri a 7 bit, comunemente utilizzato nei calcolatori, proposto dall'ingegnere dell'IBM Bob Bemer nel 1961, e successivamente accettato come standard dall'ISO. Per non confonderlo con le estensioni a 8 bit proposte successivamente, questo codice viene talvolta riferito come US-ASCII.

traduttori

I traduttori sono programmi responsabili della traduzione fra due diversi linguaggi di programmazione. Essi generano normalmente programmi scritti in linguaggio macchina a partire da un linguaggio ad alto livello e si distinguono in:

• Compilatori;
• Interpreti.


I Compilatori traducono i programmi in moduli software scritto in codice macchina, specifico per una determinata architetturahardware, che deve essere linkato e, una volta caricato in memoria da un loader, può essere fruito direttamente da un processore. Non è però scontato che il linguaggio destinazione sia il linguaggio macchina della macchina host, in quanto esistono anche i cross-compilatori, il cui scopo è generare codice esecutivo per altre macchine, le cui risorse (processore, memoria, dischi) potrebbero essere troppo limitate per far girare l'ambiente di sviluppo nel quale viene scritto il programma. Quindi i programmi vengono eseguiti in un emulatore (in sostanza una macchina virtuale) e poi l'eseguibile creato viene portato sulla macchina destinazione.

Gli Interpreti traducono di volta in volta l'istruzione in esecuzione in linguaggio macchina quindi devono essere sempre attivi durante l'esecuzione del programma principale. Anzi per essere più precisi si può affermare che l'unico programma in esecuzione è l'interprete, mentre il programma "principale" costituisce i dati.

IDE

Un ambiente di sviluppo integrato (in lingua inglese integrated development environment ovvero IDE ,anche integrated design environment o integrated debugging environment, rispettivamente ambiente integrato di progettazione e ambiente integrato di debugging), in informatica è un software che, in fase di programmazione, aiuta i programmatori nello sviluppo delcodice sorgente di un programma.


Caratteristiche
Normalmente è uno strumento software che consiste di più componenti, da cui appunto il nome integrato:
• un editor di codice sorgente;
• un compilatore e/o un interprete;
• un tool di building automatico;
• (solitamente) un debugger.


A volte è integrato anche con un sistema di controllo di versione e con uno o più tool per semplificare la costruzione di una GUI.
Alcuni IDE, rivolti allo sviluppo di software orientato agli oggetti, comprendono anche un navigatore di classi, un analizzatore di oggetti e un diagramma della gerarchia delle classi.
Sebbene siano in uso alcuni IDE multi-linguaggio, come Eclipse, NetBeans e Visual Studio, generalmente gli IDE sono rivolti ad uno specifico linguaggio di programmazione, come Visual Basic o Delphi.

COSTRUTTO

Cos'è un costrutto?

in c (ma anche in altri linguaggi ad alto livello) un costrutto non è altro che una struttura di controllo in un linguaggio di programmazione strutturata sono quei dispositivi sintattici che permettono di combinare tra loro istruzioni elementari creando cosi istruzioni complesse o blocchi di istruzioni, controllando il flusso della loro esecuzione, i piu famosi in c sono i costrutti selettivi come if - else e lo switch, e i costrutti iterativi come il while e il for.

nel caso dello switch la sintassi è

switch (nomeVariabile)

{

case 1:

.......istruzioni......

break;

case 2:

.....istruzioni.......

break;

}

N.B: se non viene scritta l'istruzione break nel primo caso quando il primo caso viene eseguito eseguira tutte le istruzioni fino a quando non trovera l'sitruzione break ad esempio quella del secondo caso.

BIOS

Cos'è il BIOS?




È il programma che il microprocessore usa per inizializzare il computer dopo che avete premuto il bottone di accensione. E' anche responsabile per la comunicazione tra il sistema operativo e le periferiche di input e output(come hard disk, scheda video, scheda audio, tastiera, mouse etc.etc.). Il BIOS e' parte integrale del PC e viene salvato su una EPROM. Quando avviate il vostro computer, il processore avvia il BIOS, questi controlla che quanto e' collegato al processore sia funzionante e quindi carica il sistema operativo in memoria.

Sebbene il BIOS sia l'intermediario tra il microprocessore e le periferiche di input e output, in alcuni casi puo' fare in modo che il flusso di dati venga deviato direttamente nella memoria.

ALGORITMO

Cos’è un Algoritmo?
Un algoritmo è un procedimento che risolve un determinato problema attraverso un numero finito di passi.
Un algoritmo è un insieme di istruzioni che soddisfa le seguenti proprietà:
1. E' finito: si conclude dopo un numero finito di passi, cioè l'esecuzione termina in un tempo finito.
2. E' definito e preciso: ogni istruzione è definita in maniera non ambigua, univocamente
interpretabile dall'esecutore; ad ogni passo deve essere definita una e una sola operazione
successiva.
3. Se ci sono dati in ingresso, la tipologia di questi è precisata (es. numeri interi, numeri reali, stringhe,
..).
4. Fornisce almeno un risultato: un algoritmo che non fornisce risultati è inutile.
5. E' eseguibile: tutte le istruzioni possono essere eseguite in un tempo finito, cioè l'esecutore è in
grado, con le risorse a sua disposizione, di eseguire ogni istruzione indicata.
6. Risolve una classe di problemi: garantisce risultati corretti per tutti i problemi appartenenti alla stessa
classe. Tuttavia ciò' non vieta di scrivere un algoritmo specifico per una particolare istanza di
problema.



Definizione di problema
Un problema è un quesito nel cui enunciato si forniscono i dati necessari per giungere, mediante calcoli o
elaborazioni, alla soluzione richiesta nell'enunciato stesso.


Che cosa significa risolvere un problema
Dal punto di vista informatico, risolvere un problema significa ricercare ed esprimere un elenco di istruzioni
(algoritmo) che, interpretate da un esecutore, conducano da determinate informazioni iniziali (dati) a
informazioni finali (risultati).

Definizione di programma
Il programma è un algoritmo espresso con un linguaggio di programmazione. Un linguaggio di programmazione si basa su tre costrutti fondamentali:
Sequenza
Selezione

Iterazione

G.U.I.

Graphic user interface, Interfaccia grafico costituito da icone, finestre e tasti selezionabili attraverso il mouse. MS-Windows nelle sue varie versioni è oggi il GUI più diffuso.

GUI e CLI

L'interfaccia grafica consente all'utente di interagire con il computer manipolando graficamente degli oggetti, al contrario di quanto avviene sulla cosiddetta riga di comando di una CLI (command line interface), in cui l'esecuzione del programma viene guidata da istruzioni impartite tramite la tastiera.

Se con la GUI è possibile fornire al software una grafica accattivante e una rinnovata semplicità d'uso, anche la CLI ha i suoi vantaggi. Infatti, si tende ad utilizzare maggiormente quest'ultima dove la semplicità d'uso deve lasciare il passo ad esigenze di maggiore controllo sull'esecuzione del programma, sia quanto alle istruzioni inserite: si pensi ad es. all'uso che se ne è fatto nel tempo, e si fa tuttora, in ambito Unix; sia quanto alle informazioni restituite dal programma: ad es. strumenti di sviluppo e di analisi del codice; uso durante il debugging di un'applicazione; manipolazione di dati tramite la redirezione e il piping.


Nulla vieta di realizzare un software dotato di GUI, che sia in realtà un wrapper per uno o più programmi dotati della sola CLI; un esempio è il noto programma GParted. In realtà, questo è avvenuto al livello del sistema operativo, nei primi tempi in cui si sono diffuse le interfacce grafiche di sistema (sia per Windows, sia per Linux), e avviene tutt'oggi su Linux, nel quale la shell grafica è uno strato posto "al di sopra" della shell testuale, non lo sostituisce, ed è nettamente separato da essa.


http://www.ehiweb.it/glossario/G/GUI
http://it.wikipedia.org/wiki/Interfaccia_grafica

lunedì 30 settembre 2013

Come trovare l' indirizzo ip

vai nel dos

start esegui digita cmd

li ti troverai in 
c:>

basta che scrivi

nslookup www.google.it
e ti dirà l i.p
con qualsiasi sito
nslookup

C:\Users\>nslookup www.google.it
Server: cns-c.libero.it
Address: 193.70.152.15:53

Risposta da un server non autorevole:
Nome: www.l.google.com
Addresses: 64.233.183.104, 64.233.183.103, 64.233.183.99, 64.233.183.147
Aliases: www.google.it, www.google.com

HTTP

L'Hyper Text Transfer Protocol (HTTP) e' un protocollo di comunicazione generalmente utilizzato per il trasferimento delle pagine web in internet. Esso viene ampiamente utilizzato durante la navigazione in rete attraverso i piu' comuni browser (Internet Explorer, Firefox, Safari e simili) come potete notare osservando la prima parte della barra dell'indirizzo dove viene riportato prima del percorso vero e proprio.I dati che passano tramite http non sono crittati e quindi facilmente intercettabili e leggibili da parte di chiunque, a differenza di quanto avviene con la sua variante piu' sicura denominata HTTPS.
La porta standard utilizzata dal protocollo HTTP e' la 80. 

Hub e router

Gli hub consentono ai computer di una rete di comunicare. Ogni computer è collegato all'hub con un cavo Ethernet e le informazioni inviate da un computer a un altro passano attraverso l'hub. Poiché un hub non è in grado di identificare l'origine o la destinazione prevista delle informazioni ricevute, invia le informazioni a tutti i computer connessi, incluso quello da cui sono state inviate. Un hub è in grado di inviare o ricevere informazioni, ma non di eseguire entrambe le operazioni contemporaneamente, pertanto gli hub risultano più lenti dei commutatori. Sono tuttavia i meno complessi e meno costosi di questi tipi di dispositivi.

Illustrazione di una rete con un hub

Router

I router consentono ai computer di comunicare e sono in grado di far passare le informazioni tra due reti, ad esempio tra la rete domestica e Internet. Il nome "router" deriva proprio da questa capacità di indirizzare il traffico di rete. I router possono essere cablati (tramite cavi Ethernet) o wireless. Se si desidera semplicemente connettere i computer, gli hub e i commutatori sono adatti allo scopo, ma, se si desidera concedere a tutti i computer l'accesso a Internet tramite un solo modem, utilizzare un router o un modem con un router incorporato. Nei router sono inoltre disponibili strumenti di protezione incorporati, quale un firewall. I router sono più costosi degli hub e dei commutatori.