Corso di C++

Bene vediamo quanto durerà prima che qualcuno rompa

« Older   Newer »
 
  Share  
.
  1. 1mPHUNit0
     
    .

    User deleted


    Si si lo sò esistono centinaia di corsi di c++ e questo è un lavoro inutille :brrr:
    ... ma diciamo che è il mio block notes, tanto per ricordarmi le cose...e se non vi piace ....pazienza :unsure:

    Se non avete ancora un compilatore c++ consiglio fortemente di procurarsene uno, anche semplice, ma procuratevelo.
    Io consiglio codeblocks. :pk:
    E' un interfaccia grafica che contiene un editor buono per scrivere programmi in qualsiasi linguaggio :asd: e il compilatore per il c++ che consiglio ovvero Mingw, una versione per windows del noto gcc usato pure da dev c++. Inoltre esiste anche per linux.
    Si scarica da quì
    http://garr.dl.sourceforge.net/sourceforge....0rc2_mingw.exe
    E questo è un breve tutorial...ma non serve
    www.programmerscafe.net/it/content/view/21/53/1/0/
    Il compilatore a pagamento per windows è ovviamente Visual Studio 2005.
    C'è una versione free ma è da linea di comando e quindi non la consiglio ai principianti
    Visual C++ 2005 Express Edition

    E lo dico fin da subito per evitare le solite interogazione: DevC++ hai un editor neppure dei migliori e un compilatore che si attiene ad un ansi c++ quindi non completissimo perciò meglio Mingw.

    Bene iniziamo :wuik:

    Una macchina non è in grado di capire direttamente il linguaggio C++: è troppo stupida per poterlo fare e il linguaggio C++ è troppo distante dalla logica binaria, l'unica che abbia senso per un calcolatore.
    Affinché la macchina possa eseguire un programma in C++ occorre rielaborarlo fino a ridurlo ad un insieme di valori esprimibili in codice binario (linguaggio macchina, 1 e 0, presenza e assenza di tensione): in sostanza va compilato.
    Cosa significa nella pratica?
    Bhè il sorgente (ovvero il codice scritto da noi, mioprogramma.cpp) viene letto dal compilatore e, se non ci sono errori, viene prodotto l'object file, ovvero un file mioprogramma.0
    Questo non è ancora eseguibile dal microprocessore, dalla nostra CPU insomma in quanto dentro al sorgente noi usiamo dei richiami a delle cose che sono esterne, ovvero delle funzioni esterne al linguaggio, come le librerie.
    A incorporare le librerie ci pensa il linker del compilatore
    Cosa sono le librerie?
    Sono dei contenitori che contengono le funzioni esterne compilate dal linker del compilatore in codice binario, producendo gli object files.
    Essenzialmente il C++ dipende da un numero limitatissimo di istruzioni (o meglio, funzioni). E'dunque un linguaggio intrinsecamente povero, ma che può essere arricchito facilmente ed efficacemente: di fatto, tantissime funzioni
    esterne possono essere masticate da un compilatore ed aggiunte al C++.
    Un'altra caratteristica del linguaggio è la scarsità di regole sintattiche, e questo lascia una grandissima libertà di espressione ("Kiss" Keept it simple, stupid).
    Tutte queste caratteristiche fanno si che il C++ sia portato per le interazioni di basso livello con la macchina e le sue risorse, sfruttando a fondo tutta la potenza dell'elaboratore.

    Per ora lascio fuori il concetto di programmazione orientata agli oggetti, e quanto detto vale benissimo pure per il linguaggio C e ovviamente lascio fuopri discorsi sulla sottostruttura C che dovranno essere abbandonati...
    Invece introdurrò la programmazione a oggetti e i concetti di Ereditarietà, Polimorfismo e Incapsulazione caratteristice specifiche del C++ rispetto al C.
    Nota bene, fare C usando C++ non è esattamente come fare C, lo è quasi ma alcune cose sono più rigide in C++ quindi nello scrivere con il C non del C++ bisognerà rinunciare alla flessibilità senza regole del C.
    Altre caratteristiche del C++ sono la Tipizzazione medio forte, ovvero il fatto che tutte o quasi le variabili debbano essere definite per tipo.
    Un "tipo di dato" definisce una gamma di valori che una variabile è in grado di contenere. Esistono numerosi tipi di dati: interi, numeri a virgola mobile, booleani, caratteri, stringhe e così via. Con il C++ non si può passare tanto facilmente da un tipo di dato a un altro per la stessa variabile. Questo per molti versi è pure un bene.
    La tipizzazione del C invece è debole.

    Altra particolarità del linguaggio C++ sono i controlli dell errore a runtime,
    durante l'esecuzione del programma, per evitare che dati o costrutti mal congegnati possano generare errori.
    Nel C non esiste nessun controllo di questo tipo,tutto è demandato al programmatore che deve curarsi di "preventivare" tutte le casistiche a cui un dato o un costrutto possa andare incontro.
    Nel caso specifico, uno sforamento di indice di array provocherà nella migliore delle ipotesi una sovrascrittura di un dato memorizzato nella RAM immediatamente dopo l'area di memoria destinata all'array, nel peggiore dei casi si potrà verificare un blocco del programma, o peggio del sistema.
    Piccola nota per i curiosi: l'assenza "da linguaggio" di meccanismi di protezione che impediscano errori di questo tipo, viene sfruttata nell'hacking con le tecniche di "buffer overrun" per guadagnare il tanto agognato accesso root ad un sistema.

    Inoltre il C è un linguaggio strutturato, il c++ come detto invece a oggetti, solo che si può benissimo usare anche come solo strutturato.
    La caratteristica fondamentale di un linguaggio strutturato è quella di eseguire il codice del programma in maniera sequenziale, senza "salti" da una parte all'altra.
    Un esempio di linguaggio non strutturato è il BASIC, con l'istruzione GOTO.
    In un linguaggio strutturato, ogni serie di operazioni, viene eseguita sequenzialmente; non esistono salti, se non chiamate alle sub routines o alle funzioni che possono svolgere dei compiti specifici e ripetitivi.
    Questa, assieme all'isolamento dei dati, che definiremo tra qualche istante, sono le due caratteristiche che rendono il C un linguaggio molto amato dai programmatori professionisti.
    L'isolamento dei dati è la capacità di un programma di utilizzare dei dati all'interno di funzioni o subroutines senza che questi vadano ad interferire con eventuali stessi dati definiti al di fuori di queste ultime.
    Questa caratteristica, permette di operare sui dati con un buon livello di sicurezza degli stessi, senza correre il rischio di alterare erroneamente qualche dato "entrando" in una subroutine.
    Ma questo lo vedremo a suo tempo...era solo una preview.
    Ora, per imparare a programmare servirebbe: un buon corso di logica dell'elaboratore e di sua struttura, uno di algebra,
    uno di matematica discreta e non.

    Poiché siamo autodidatti impareremo tutto questo indirettamente attraverso la pratica e divertendoci :ipip:

    Un buon sito in inglese pieno di cose utili
    www.cplusplus.com/reference/
    Fondamentale per trovare informazioni sulle cose che si usano


    Edited by 1mPHUNit0 - 17/1/2013, 17:00
     
    Top
    .
  2. 1mPHUNit0
     
    .

    User deleted


    In C++ (come in C), prima che il compilatore inizi a lavorare, viene attivato un programma, detto preprocessore, che ricerca nel file sorgente speciali istruzioni, chiamate direttive.
    Una direttiva inizia sempre con il carattere # e al suo termine non vuole il ;
    Il preprocessore crea una copia del file sorgente (da far leggere al compilatore) e,
    ogni volta che incontra una direttiva, la esegue sostituendola con il risultato dell'operazione.
    Pertanto il preprocessore, eseguendo le direttive, non produce codice binario, ma codice sorgente per il compilatore. Ogni file sorgente (ve ne possono essere diversi), dopo la trasformazione operata dal preprocessore, prende il nome di translation unit. Ogni translation unit viene poi compilata separatamente con la creazione del corrispondente file oggetto, in codice binario.
    Spetta al linker, infine, collegare tutti i files oggetto, generando un unico programma eseguibile.
    In sostanza è il linker a richiamare il compilatore quando vede funzioni esterne.
    In C++ esistono molte direttive (alcune delle quali dipendono dal sistema operativo)
    come #include , #define , #undef e molte altre che vedremo quando capiteranno
    Vediamone una che usiamo sempre
    Direttiva #include
    Si usa in due modi
    #include <filename>
    oppure
    #include "filename"
    che determina l'inserimento, nel punto in cui si trova la direttiva, dell'intero contenuto del file con nome filename.
    Se si usano le parentesi angolari, si intende che filename vada cercato nella directory di default del linguaggio; se invece si usano le virgolette, il file si trova nella directory del programma (del file sorgente insomma).
    La direttiva #include viene usata quasi esclusivamente per inserire gli header-files (.h)

    Il linguaggio C++ (come il C) distingue i caratteri maiuscoli da quelli minuscoli.
    Esempio: i nomi MiaVariabile e miavariabile indicano due variabili diverse
    Quando si manda in esecuzione un programma, questo inizia sempre dalla funzione identificata dalla parola chiave main
    Il main è chiamato dal sistema operativo, che gli può passare dei parametri; a sua volta il main può restituire al sistema un numero intero (di solito analizzato come possibile codice di errore).
    Quindi per definizione la funzione main è sempre di tipo intero (int), si può specificare,
    e alcuni compilatori lo richiedono, ma non è necessario, comunque si dovrebbe scrivere
    int main ( ).....sarebbe sbagliato definirla cone un tipo che non restituisce valori scrivendo void main ()



    CITAZIONE
    \n A capo.
    \t Spazio o tab orrizzontale
    \r Ritorno del carrello a inizio linea
    \a Trillo o bell
    \\ Backslash
    \" Double quote



    Edited by 1mPHUNit0 - 21/1/2013, 15:34
     
    Top
    .
  3. 1mPHUNit0
     
    .

    User deleted


    Ma guardiamo meglio questo classico primo programma in tutti i linguaggi
    Si chiama Hello world è quello dell'esempio è sbagliatissimo per diversi motivi :ang:
    e uno già lo sappiamo quel primo void sbagliatissimo
    Il secondo motivo è che parla di C+++.....ma è evidente che l'immagine invece si riferisce al C...e per diversi motivi

    Uno, l'uso della funzione printf( ) contenuta nella libreria stdio.h
    che in c++ si può anche usare ma non si deve usare in quanto meglio usare le cose fatte per il c++ piuttosto che quelle per il C
    Quindi si sarebbe dovuta usare la libreria analoga del C++ iostream.h
    e l'identificatore (questo non è una funzione ) std::cut dell operatore << di uscita a schermo

    Inoltre c'è un altro errore che mi permette di parlare dell ANSI C++
    Questo l'ho fatto io e volutamente, cioè usare iostream.h...in realtà quella h non si dovrebbe mettere ...ma il nuovo standard non è ancora stato implementato da molti compilatori (oggi 2013, si!)
    Ponendo subito dopo la riga con la direttiva #
    using namespace std; si può fare a meno di usare tutti gli std::
    L' operatore :: è detto resolution scope operator è va usato ogni volta che vengono richieste librerie .h nostre non standard, quindi senza utilizzare using namespace std;
    E nota bene il punto e virgola finale che è necessario
    Solo le direttive al pre processore non vogliono il punto e virgola :):

    Edited by 1mPHUNit0 - 17/1/2013, 17:15
     
    Top
    .
  4. 1mPHUNit0
     
    .

    User deleted


    Allora, per scrivere un programma come quello dell esempio serve appunto un editor.
    Un compilatore è un compilatore, non è un editor.
    Ma motissimi compilatori contengono un editor integrato e vengono detti IDE (Integrated Development Environment). Il nostro Codeblocks è appunto un IDE, insomma un Frontend per Mingw (minimal gcc for windows),
    Non che sia fondamentale che lo contengano ma è comodo.
    In sostanza si potrebbe usare l'editor che preferite perfino il notepad salvando poi il file con estensione .cpp

    Inizio con il riscrivere correttamente il più facile programma inutile del mondo
    che chiamerò Ciao Silvia Figacciona! byPhun e ci metterò un po di cose in più :bab:

    CITAZIONE
    //Questo programma si chiama "Ciao Silvia Figacciona! byPhun" e questo è un commento
    /*per scrivere commenti su più righe si deve usare la barra e l'asterisco e non le due barre e comunque i commenti il precompilatore manco li vede e si chiudono così, andando a capo
    */
    #ifdef HAVE_CONFIG_H
    #include <config.h>
    #endif
    /*queste direttive al preprocessore servono per personalizzare il codice in base alla configurazione della macchina sulla quale è compilato... Fate finta non ci sia per ora...
    era solo per mettere della carne sul fuoco
    */
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main( )
    {
    cout << "Ciao Silvia Figacciona! byPhun!" << endl;//il quote significa che è una stringa e non una variabile
    system("pause");
    return EXIT_SUCCESS;
    }

    return EXIT_SUCCESS;
    si sarebbe potuta sostituire con
    return 0
    Ma non è consigliato, in quanto il valore fornito dalla main potrebbe essere diverso da sistema a sistema.
    Mentre la macro return EXIT_SUCCESS; se non ci sono problemi di errore termina il programma
    Ma meglio ancora non mettere nulla, in C++ si può fare
    Ecco questo è il vostro primo programma in C++
    E avete imparato i primi importanti concetti


    E mo lo rispiego tutto pezzo per pezzo per gli gnucchi

    Edited by 1mPHUNit0 - 21/1/2013, 16:07
     
    Top
    .
  5. 1mPHUNit0
     
    .

    User deleted


    Ciao Silvia Figacciona! byPhun.cpp

    ----------------------------------------------------------------------------------------------------
    Sui commenti sappiamo già tutto...quindi dico nulla ma solo che è buona norma metterne

    #include <iostream>
    Ecco...quì un paio di cose le voglio dire
    www.cplusplus.com/reference/iostream/

    Ma come si fà a capire quali direttive servono?
    Be dall'algoritmo.
    Se si vuole scrivere qualcosa su un monitor e usare una tastiera
    per forza servira qualcosa per fare imput e output con il c++
    Si cerca con google output c++...o si cerca in un libro con le reference
    e si vede quali direttive servono e che funzioni forniscono
    Magari si scoprono pure utilizzi di funzioni che manco si sapeva esistessero

    #include <cstdlib>
    Stesso discorso fatto sopra per queste librerie standard del c++
    www.cplusplus.com/reference/clibrary/cstdlib/
    Dico solo che forniscono delle funzioni e delle macro...e manco tante
    ...quindi usandola si ricorda quando serve
    In particolare a me sono servite per la funzione system("....") (che ha le sue opzioni carine)
    e per la macro return EXIT_SUCCESS.

    system("....");
    Ecco questa lancia su una shell o linea di comando o pompt di dos il comando che mettete al posto dei .... quindi vuol dire che quando compilate un programma e producete l'exe cliccandoci sopra lancerà quello che ci scrivete dentro
    Quindi system("pause"); aspetterà finche non viene premuto un qualsiasi tasto che aspetta di leggere.

    using namespace std; già la conosciamo

    Di questa invece non ho parlato molto o affatto ed è il cuore di ogni programma C/C++
    <b>int main(int argc, char *argv[])
    {
    }

    Che la main debba essere intera per struttura e che sia una funzione ho già detto
    Ma cosa è la main()?
    Questo è il punto da cui inizia un qualsiasi programma in C/C++
    Quando si manda in esecuzione un programma, questo inizia sempre dalla funzione identificata dalla parola chiave main
    Deve esserci per forza in un programma C/C++
    E il codice e le dichiarazioni vengono messe tutte dentro le parentesi graffe
    che vanno scritte in style come
    {
    }
    Il main è chiamato dal sistema operativo, che gli può passare dei parametri; a sua volta il main può restituire al sistema un numero intero (di solito analizzato come possibile codice di errore).

    E con questo direi che Ciao Silvia Figacciona! byPhun.cpp> lo si è spiegato.

    Edited by 1mPHUNit0 - 21/1/2013, 16:08
     
    Top
    .
  6. 1mPHUNit0
     
    .

    User deleted


    Dove Si Scarica la IDE Codeblocks?
    Già Detto
    Dove Gli Sviluppatori Mettono i Sorgenti ...Sourceforge!!!
    http://garr.dl.sourceforge.net/sourceforge....0rc2_mingw.exe
    E il sito ufficiale?
    http://www.codeblocks.org/
    Punto 1: Download Code::Blocks
    O dal sito nella sottosezione Code::Blocks IDE (Windows binaries)
    O dal link che ho messo a sourceforge
    Punto 2:Installre Code::Blocks
    Full Installation
    Punto 3: Farlo partire e configurarlo
    Dovrebbe partire una Compilers auto-detection window
    image

    Ecco scegli e chiudi
    Poi File menu "New project" e pof......

    image

    Ora quello che abbiamo fatto è un programma che gira su prompt di dos
    quindi è una "Console Application"
    La si sceglie e poi "Create"

    Ora vi chiederà di salvare il vostro progetto da qualche parte in documenti
    Be chiamatelo con un nome diverso ogni volta e separate i vari progetti

    Se ora aprite la main.cpp c'è già un hello world fatto per noi

    image

    Ecco non è quello del vostro progetto ma un esempio di applicazione console che si può modificare e salvare nel nostro progetto
    Ora cliccando F9, compilerà quello che avete aperto e lancerà l'exe prodotto

    Edited by 1mPHUNit0 - 22/10/2007, 05:42
     
    Top
    .
  7. 1mPHUNit0
     
    .

    User deleted


    Bene, anzi male, adesso devo spiegare i tipi di dati senza sembrare palloso
    Bhe inizio con gli interi

    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main()
    {
    int mele, pere; // In questo modo definisco due variabili numeriche che usano interi
    int frutti; // ...altra variabile intera
    mele = 5; pere = 6; // Assegnazione dei valori iniziali
    frutti= mele + pere; //Il totale hehehehh
    cout << endl; // Questo manda a capo
    cout << "minchia quanta frutta!!!" << endl; /*nota il quote significa questa è una stringa e non una variabile */
    << "in totale" << frutti << " manco molti";//finisce solo quì il cout
    cout << endl; // manda a capo
    system("pause");
    return 0; // Exit}

    int pere, mele; // In questo modo definisco due interi
    Questo è detto Dichiarazione Delle Variabili

    Ogni volta che si introducono i nomi, e quindi dichiarando il tipo prima,
    si fà una Dichiarazione Delle Variabili

    mele = 5; pere = 6; // Assegnazione dei valori iniziali
    E sopra come si assegnano dei valori a delle variabili dichiarate

    Ovviamente si può pure dichiarare e assegnare in un solo passaggio
    int mele = 5;
    Esiste pure un altro modo di fefinire le variabili e assegnarte i valori, La Notazione Funzionale
    int mele (5);
    Ora quando si dichiara una variabile il compilatore trova un suo spazio in memoria e la crea pure, ma io potrei anche solo volerla dichiarare senza crearla subito in questo nodo
    extern int a;

    Quindi, cosa è una variabile?
    Tutto quello che passa per la testa della CPU stà nella RAM, infilato in qualche indirizzo di memoria, che è una sequenza di bit 1 oppure 0 :
    se il programma vi può accedere in lettura e scrittura, variabili;
    se in sola lettura costanti.
    Al fine di attribuire significato ad una sequenza di bit occorre sapere
    quanti bit la compongono, ovvero IL TIPO DI DATO

    In C++ 5 tipi, detti "nativi" del linguaggio :

    char numero intero di 1 byte (interpretabile come codice ascii di un carattere)
    int numero intero di 4 byte
    float numero in virgola mobile con 6-7 cifre significative (4 byte )
    double numero in virgola mobile con 15-16 cifre significative (8 byte )
    bool valore booleano: true o false (1 byte )

    Questi tipi “primitivi” hanno a loro volta dei qualificatori
    Esistono 4 qualificatori: short, long, signed, unsigned,
    short e long si applicano al tipo int (che di suo è long ed è della dimensione dei registri della cpu, in genere 32 bit, quindi si parla solo di short):
    il qualificatore short definisce variabili di 16 bit (2 byte)
    e il qualificatore long definisce variabili di 32 bit (4 byte).

    Al byte (8 Bit fanno un Byte) corrisponde il tipo di dato char
    e può assumere 2^ 8 valori , 256 valori diversi

    Edited by 1mPHUNit0 - 21/1/2013, 16:10
     
    Top
    .
  8. 1mPHUNit0
     
    .

    User deleted


    cout vuol dire console out, cioè butta su console,
    ed è solo un identificatore da solo combina nulla

    Per esempio nel codice che abbiamo scritto contenente
    cout << "minchia quanta frutta!!!" << endl;
    il compilatore vede cout e dice bene devo prepararmi per creare un area di memoria (Buffer o memoria tampone) che deve ricevere qualcosa in streaming (flusso) e che deve essere poi sbattuto in console
    Mentre << è un operatore di uscita a schermo che dice, mo te lo spiego io cosa è quel qualcosa
    A bene, dice il compilatore, sentiamo un pò...
    "minchia quanta frutta!!" gli risponde cout
    O cavolo, risponde il compilatore, ma è Una Stringa! non è una variabile
    Bravo, gli risponde cout, mo termina il flusso al buffer svuotalo e vai a capo (<< endl)

    Solo dopo che il buffer è svuotato appare la scritta sulla console
    Mentre se andavamo a capo nel modo
    cout << "minchia quanta frutta!!!/n";
    Mica lo svuotava il buffer, andava solo a capo ma non scriveva nulla fino a quando non terminava il programma, allora sì si svuotava e scriveva

    Ovviamente se esiste un identificatore di flusso fuori
    Esisterà pure un identificatore di inserimento di un flusso non credete?
    Eccolo si chiama cin e avrà il suo operatore di infilaggio hehehehe (Inserimento) >>
    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main()
    {
    int a, b;
    cin >> a;
    cin >> b;
    if(a == b)
    cout << a << " e" << b << " cavolo sono uguali.\n";
    else
    cout << a << " e" << b << " umm non sono uguali bimbo.\n";
    system("pause");
    return 0;
    }

    CITAZIONE
    #include <string>
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main()
    {
    string str("Ciao Silvia Figacciona! byPhun!" ); /*si poteva scrivere anche, str = "Ciao Silvia Figacciona! byPhun!";*/
    cout << str << endl;
    cout << "La lunghezza della stringa è: " << str.size() << endl;// oppure si usa .length()
    system("pause");
    return 0;
    }

    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    #include <string>
    using namespace std;
    int main()
    {
    string tuonome,tuocognome,tuttoilnome;
    char frasetta[] = " Figacciona";
    cout << "il tuo nome è?: \n";
    cin >> tuonome;
    cout << "Il tuo cognome è: \n";
    cin >> tuocognome;
    tuttoilnome = tuonome + " " + tuocognome + frasetta;
    cout << "Tu sei" + tuttoilnome + "\n";
    cout << "e ha lunghezza " << tuttoilnome.size() << " caratteri\n";
    cout << "Il primo carattere è " << tuttoilnome[0] << "\n";
    system("pause");
    return 0;
    }

    In C++, prima che qualsiasi dato venga trasferito da un posto a un altro,per prima cosa finisce nel buffer, proprio come quando guardate un filmato in internet
    Tipo
    CITAZIONE
    char a[4];
    cin>>a; //io scrivo ciao, che cin lo mette in a.

    1. Sia la stringa "ciao" che '\n' (poichè si preme enter dopo ciao) vanno nel buffer (chiamato input stream buffer).
    2. '>>' legge ogni carattere della stringa ("ciao") dal buffer e li rimuove.
    In altre parole gli estrae dal buffer e li mette nell array 'a' uno ad uno, sequenzialmente
    3. Quì a cin segue '>>', che vuol dire che ogni spazio bianco non viene messo in "a"
    4. e poichè '\n' è anche esso uno spazio bianco in qualche senso, non viene estratto,
    rimane nel buffer
    Ora prendiamo il caso di cin.getline() che prende tutto, anche gli spazi.
    CITAZIONE
    char stringhetta[4];
    getline(stringhetta,4,'#');

    Inanzitutto nota che ho messo tre parametri al posto dei soliti due che si trovano negli esempi,
    il terzo è un opzione tipo ,'#','\n' o altro
    A cosa serve il delimitatore #?
    Mentre mettendo # il delimitatore diventa questo.

    Edited by 1mPHUNit0 - 21/1/2013, 16:30
     
    Top
    .
  9. 1mPHUNit0
     
    .

    User deleted


    Ma continuo con le Variabili che non avevo finito
    Ricapitolando
    CITAZIONE
    Tutto quello che passa per la testa della CPU stà nella RAM, infilato in qualche indirizzo di memoria, che è una sequenza di bit 1 oppure 0 :
    se il programma vi può accedere in lettura e scrittura, variabili;
    se in sola lettura costanti.

    In sostanza la memoria è organizzata in locazioni di memoria consecutive e numerate (registri)
    Ogni locazione è individuata da un indirizzo (Registro MAR Memory Address Register)
    Il compilatore associa ogni variabile a un indirizzo
    e si dice Valore della variabile il contenuto di questa locazione
    (Registro MDR Memory Data Register)
    Mentre Indirizzo Della Variabile....ovviamente il suo indirizzo (Esadecimale)
    Insomma in poche parole serve individuare una zona di memoria prima di metterci una variabile.

    Si è visto come si dichiarano e si assegnano i valori delle variabili singolarmente
    CITAZIONE
    int pere, mele; // In questo modo definisco due interi

    Questo è detto Dichiarazione Delle Variabili
    Fate molta attenzione a non dimenticare la virgola tra i due nomi

    CITAZIONE
    mele = 5; pere = 6; // Assegnazione dei valori iniziali
    Questo è detto Assegnazione Delle Variabili

    E consigliabile sempre dichiarare una variabile con un valore assegnato di inizializzazione
    Questo per evitare eventuali errori di variabilli non dichiarate


    Si possono pure fare concatenazioni come
    a=b=c=2
    Ed è una novità del C++ rispetto al C
    Qualcuno potrebbe pensare che = sia un segno di uguaglianza
    Non è così
    Si chiama operatore di assegnazione, e ha i suoi termini left value (posti o locazioni) e right value (valori)
    In c++ il segno di uguale è == ed è detto Operatore di Uguaglianza

    Un codice simile
    CITAZIONE
    {
    mele;
    int mele;
    return 0;
    }

    Darebbe errore, proprio per il primo mele non dichiarato, e infatti non si capisce che razza di tipo è

    Per vedere a quale indirizzo di memoria è assegnata una variabile
    si usa l'operatore &
    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main(void)
    {
    int mele;
    cout << &mele;
    system("pause");
    return 0;
    }

    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main(void)
    {
    short mele;
    float euro;
    cout << "L'indirizzo di euro è: "
    << &euro<< "\n";
    cout << "La dimensione di euro è "
    << sizeof(euro) << "\n";
    cout << "L'indirizzo di mele è " << &mele << endl;
    cout << "La dimensione di mele è "
    << sizeof(mele) << endl;
    system("pause");
    return 0;
    }

    sizeof(nomevariabile) lo avevo già usato ed è molto utile come visto
    CITAZIONE
    cin.getline(memoriatampone, sizeof(memoriatampone));

    Mentre "\n" e endl sono la stessa cosa ma evidentemente + comodo endl (c++ style)

    Ovviamente se diamo a mele il valore 20 all'avvio del compilatore
    se usiamo mele in memoria resterà il valore 20
    Come si vede...be facile
    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main(void)
    {
    int mele;
    cout << mele;
    system("pause");
    return 0;
    }

    E' per questo motivo che è meglio dichiarare le variabili inizializzandole
    Le locazioni non vengono azzerate automaticamente
    E ovviamente occhio agli errori stupidi come per esempio
    CITAZIONE
    int mele;
    mele = "buone";

    Ovviamente "buone"
    non è un intero ma è una stringa al più
    Mentre questo funziona...ma assegna un intero ovvero 2
    CITAZIONE
    int mele;
    mele = 2.5;


    Edited by 1mPHUNit0 - 21/1/2013, 16:31
     
    Top
    .
  10. 1mPHUNit0
     
    .

    User deleted


    Ora
    Se si vuole incrementare una variabile di 1 si scrive
    a=a+1;
    Ok
    Però se l'incremento è unitario si usa
    a++;
    Perchè lo dico, perchè spesso capita questo errore ovvero
    b=a++
    pensando che a b vega passato a incrementato e non è così!!
    Infatti succede che a b viene assegnato a e poi viene incrementato a
    In pratica l'operatore = ha la precedenza
    Per questo motivo nel caso si voglia diversamente esiste ++a

    Gli operatori Relazionali
    CITAZIONE
    > >= maggiore, maggiore uguale
    < <= minore, ninore uguale
    == Uguale (come avevo anticipato)
    != Diverso

    C'è comunque la questione della precedenza
    Alta
    >, >= ,<, <=,
    bassa
    ==, !=
    Operazioni Elementari
    Ok nulla da dire oltre a quello che si conosce
    Però due cosucce restano
    -Il risultato della divisione di due numeri di tipo int.....è ancora int
    Quindi usate i float
    E comunque la divisione tra due numeri di tipo diverso si converte nel tipo + complicato
    - 1%2 vuol dire il resto della divisione citata

    Se poi ad esempio abbiamo Frutti = Frutti + Mele;
    Allora + elegantemente si scrive Frutti += Mele
    Ma vale + in generale
    CITAZIONE
    a = a + 2; si può scrivere a +=2; e vale pure per il meno
    a = a * 2; si può scrivere a *=2; e vale pure per il /
    a = a % 2; si può scrivere a %=2;

    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main(void)
    {
    int numeratore = 50, denominatore = 3;
    float risultato = numeratore / denominatore;
    cout << numeratore << " / " << denominatore << " = " << risultato;
    system("pause");
    return 0;
    }



    Edited by 1mPHUNit0 - 28/12/2007, 15:10
     
    Top
    .
  11. 1mPHUNit0
     
    .

    User deleted


    Prima di andare avanti torno un attimo indietro
    Ai commentti e a using namespace sdt

    I commenti
    Questo è un comment box
    CITAZIONE
    /********************************************************
    * Ciao Forum: -- questo programma scrive "ciao silvia".
    * Anzi "ciao silvia figacciona by phun"
    *
    * Scritto da tutti i principianti
    * *
    * Scopo: Introdurre i primi principi
    *
    * Uso:
    * Nulla compilare e run e poi apparirà pure l'exe
    *****************************************/

    CITAZIONE
    /**********************************
    **********************************
    ******** Attenzione *******
    ******** Atenzione *******
    ******** Attenzione *******
    **********************************
    **********************************/

    //------------> quello che si desidera<--------

    //>>>>>>>>>>>> quello che si desidera <<<<<<

    /*******************************************
    * Un altro box
    * per sezioni diverse
    *******************************************/

    /*------------------------------------------------------*\
    * Un altro box carino
    \*------------------------------------------------------*/

    /*
    * Inizio di una sezione
    * ^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^ ^^^^^^^*/
    /*
    * Un commento di medio livello
    * con molte linee di codice
    *dove si può enfatizzare un termine con**okkio** .
    */

    // Un semplice commento a una linea

    CITAZIONE
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    int main()
    {
    cout << "+--------+\n";
    cout << "|Silvietta|\n";
    cout << "+--------+\n";
    system(pause);
    return 0;;
    }

    Ora tornando un attimo sull using namespace sdt
    Questo serve per poter usare proprie librerie dando etichette ai comandi usati.
    In questo modo si potranno considerare diversi anche identificatori identici

    Ad esempio se si usava solo
    std::cout
    Allora invece di usare
    CITAZIONE
    using namespace std;

    si poteva pure scrivere
    CITAZIONE
    using std::cout;

    Che vuol dire, a bello se vedi cout consideralo std::cout
    Oppure
    using RobadiSilvia::cout
    specifica che per cout si intende RobadiSilvia::cout
    Dove RobadiSilvia è una nostra namespace

    Questo è un altro modo figo di usare namespace
    CITAZIONE
    // namespaces
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    namespace RobadiSilviauno
    {
    int euro = 5;
    }
    namespace RobadiSilviadue
    {
    float euro = 5.5;
    }
    int main () {
    cout << RobadiSilviauno::euro << endl;
    cout << RobadiSilviadue::euro << endl;
    system("pause");
    return 0;
    }

    Ora come su usa using
    CITAZIONE
    // using
    #include <iostream>
    #include <cstdlib>
    using namespace std;

    namespace RobadiSilviauno
    {
    int pochieuro = 5;
    int molteuro = 1000;
    }

    namespace RobadiSilviadue
    {
    float pochieuro = 5.5;
    float molteuro = 100.5;
    }

    int main () {
    using RobadiSilviauno::pochieuro;
    using RobadiSilviadue::molteuro;
    cout << pochieuro << endl;
    cout << molteuro << endl;
    cout << RobadiSilviauno::molteuro << endl;
    cout << RobadiSilviadue::pochieuro << endl;
    system("pause");
    return 0;
    }

    Oppure in questo modo
    CITAZIONE
    // using
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    namespace RobadiSilviauno
    {
    int pochieuro = 5;
    int molteuro = 1000;
    }
    namespace RobadiSilviadue
    {
    float pochieuro = 5.5;
    float molteuro = 100.5;
    }
    int main () {
    using namespace RobadiSilviauno;
    cout << pochieuro << endl;
    cout << molteuro << endl;
    cout << RobadiSilviadue::pochieuro << endl;
    cout << RobadiSilviadue::molteuro << endl;
    system("pause");
    return 0;
    }

    Questa roba piuttosto utile è una novità di quelle belle del C++ e che il C non ha

    Si possono pure creare Alias
    CITAZIONE
    namespace silviettafunction {
    void f();
    }

    namespace figa =silviettafunction;

    Ora ogni volta che scriviamo figa sarà come usare silviettafunction

    Edited by 1mPHUNit0 - 28/12/2007, 15:12
     
    Top
    .
  12. 1mPHUNit0
     
    .

    User deleted


    Ora , dato che mi sono un po stancato di parare, un programmino
    tanto per rilassarmi, e introdurre altro che spiegherò a breve,
    appena finito il discorso sulle variabili, sull Imput/output e sull introduzione delle stringhe

    CODICE
    /******************************************************
    *     1mPHUNit0 per http://ciaosilvia.forumfree.it/   *
    *                                                     *
    *  Questo codice è messo a disposizione dei nostri    *
    *        cari visitatori e funziona perfettamente     *
    *                                                     *
    *                                                     *
    *  Ogni domanda è benvenuta e Thawra vi aiuterà       *
    *******************************************************/
    /*Programma per trovare le soluzioni delle equazioni nella standard forma ax^2+bx+c=0.*/

    #include <cmath>
    #include <iostream>
    #include <cstdlib> //grazie a cstdlib si ha system("pause");
    #include <conio.h> //grazie a conio.h si ha getch()
    int main ()
    {
    using namespace std;
    bool ripeti = true;//usato nella ripetizione
    char test;//usato come parametro per la ripetizione
    float a=0,b=0,c=0,delta=0;
    double x1=0,x2=0;
    while (ripeti)
    {
    cout << "\n\nQuesto programma calcola le radici di un equazione di secondo grado" << endl;
    cout << "ax^ + bx + c = 0:\n";
    cout << "Inserie i coefficenti, a, b and c:\n " << endl;
    cout<< "\ta:  ";
    cin>> a;
    cout<< "\n\tb:  ";
    cin>> b;
    cout<< "\n\tc:  ";
    cin>> c;
    // si poteva anche usare while (cin >> a >> b >> c)
    if (a==0)
    {
    cerr << "Errore Cazzo! Primo Coefficiente 0!"<< endl;
    continue;
    }
    cout<<"\n\tCoefficienti = " << a << " " << b << " " << c << endl;
    cout<<"\n\tEquazione = " << a << "x^2+" << b << "x+" << c << "=0"<< endl;
    delta=(b*b)-(4*a*c);
    cout << "\n\tdelta = " << delta << endl;
    if ( delta > 0 ) // test delta positivo
       {
      x1=(-b-sqrt(delta))/2*a;
      x2=(-b+sqrt(delta))/2*a;
    cout << "\n\tx1: " << x1 <<endl;
    cout << "\n\tx2: " << x2 << endl;
       }
    else if ( delta == 0 ) // test delta uguale a zero
       {cout << "le soluzioni sono reali e coincidenti"<< endl;
        cout << "\n\tx1=x2=-(b /( 2*a))= " << -( b / ( 2*a))<< endl;
       }
    else // ultimo caso da testare è il delta negativo
    {
    cerr << "\tDelta Negativo, Radici Complesse. Cercatele Tu!" << endl;

    }
    cout << "\nVuoi calcolare le soluzioni di nuovo?\n(Y oppue N): ";
    cin >> test;
    ripeti = (test == 'Y' || test == 'y') ? true : false;
    }
    system("pause");// preso dalla libreria di cstdlib, oppure grazie a conio.h si ha getch()
    //ma ancor meglio è usare l'oggetto cin.getch e non necessita di nulla!

    return 0;
    }


    Edited by 1mPHUNit0 - 20/5/2013, 21:44
     
    Top
    .
  13. 1mPHUNit0
     
    .

    User deleted


    Ancora che parlo di variabili?
    E si cavolo, ci sono altre cose da dire e degli esempi per chiarire
    ancora meglio quanto detto, e inoltre sono fondamentali
    Inanzitutto avevo detto che il C++ è un linguaggio Tipizzato abbastanza forte,
    diversamente dal C che non lo è molto
    Ovvero che bisogna dichiarare il tipo di dato prima di poter assegnare valori,
    e quando fatto, esistono solo alcuni modi per cambiarne il tipo, e non sono molti
    Per Tipo, come detto si intende una classificazione che raggruppa tutte quelle variabili che sono memorizzate nello stesso modo e a cui si applica lo stesso insieme di operazioni.

    Il cambiamento di tipo di un dato viene detto Casting
    Questi i modi principali
    static_cast
    const_cast
    dynamic_cast
    reinterpret_cast.
    Non ne parlo adesso perchè servono altri concetti,
    ma qualcosa di introduttivo posso dirlo
    Alcune conversioni, come detto vengono fatte automaticamente dal compilatore
    e sono dette Conversioni Implicite
    Le Conversioni Esplicite invece richiedono l'intervento diretto del programmatore
    Ecco, un certo tipo di Conversioni Esplicite sono quelle ereditate dal C,
    e sono semplici (Conversioni Standard), farò qualche esempio di come si usano in C++
    CITAZIONE
    short a=5;
    int b;
    b = (int) a; // cast c-like
    b = int (a); // notazione funzionale

    Questo basta in genere per fare tutte le conversioni che si vogliono , ma meglio evitarlo o non esagerare, e comunque usare i Cast che vedidremmo in futuro
    Perchè?
    Perchè poi quando altri elementi faranno riferimento ai dati, potrebbero verificarsi errori anche quando il codice scritto pare corretto.
    I cosidetti errori a run time

    A, non l'ho detto prima , li C++ è sensibile allle maiuscole,
    però per qualto riguarda gli spazi bianchi uno può fare come crede,
    nel senso
    a=6;, a*b etc etc...sono la stessa cosa di a = 6; a * b etc etc

    Edited by 1mPHUNit0 - 19/11/2007, 23:35
     
    Top
    .
12 replies since 21/10/2007, 03:25   1739 views
  Share  
.
Top