-
1mPHUNit0.
User deleted
Si si lo sò esistono centinaia di corsi di c++ e questo è un lavoro inutille
... ma diciamo che è il mio block notes, tanto per ricordarmi le cose...e se non vi piace ....pazienza
Se non avete ancora un compilatore c++ consiglio fortemente di procurarsene uno, anche semplice, ma procuratevelo.
Io consiglio codeblocks.
E' un interfaccia grafica che contiene un editor buono per scrivere programmi in qualsiasi linguaggio 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
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
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. -
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. -
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
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. -
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ù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. -
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. -
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
Ecco scegli e chiudi
Poi File menu "New project" e pof......
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
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. -
1mPHUNit0.
User deleted
Bene, anzi male, adesso devo spiegare i tipi di dati senza sembrare palloso
Bhe inizio con gli interiCITAZIONE#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. -
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
TipoCITAZIONEchar 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.CITAZIONEchar 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. -
1mPHUNit0.
User deleted
Ma continuo con le Variabili che non avevo finito
RicapitolandoCITAZIONETutto 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 singolarmenteCITAZIONEint pere, mele; // In questo modo definisco due interi
Questo è detto Dichiarazione Delle Variabili
Fate molta attenzione a non dimenticare la virgola tra i due nomiCITAZIONEmele = 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 simileCITAZIONE{
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 vistoCITAZIONEcin.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 facileCITAZIONE#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 esempioCITAZIONEint mele;
mele = "buone";
Ovviamente "buone"
non è un intero ma è una stringa al più
Mentre questo funziona...ma assegna un intero ovvero 2CITAZIONEint mele;
mele = 2.5;
Edited by 1mPHUNit0 - 21/1/2013, 16:31. -
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 RelazionaliCITAZIONE> >= 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 generaleCITAZIONEa = 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. -
1mPHUNit0.
User deleted
Prima di andare avanti torno un attimo indietro
Ai commentti e a using namespace sdt
I commenti
Questo è un comment boxCITAZIONE/********************************************************
* 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 lineaCITAZIONE#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 usareCITAZIONEusing namespace std;
si poteva pure scrivereCITAZIONEusing 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 namespaceCITAZIONE// 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 usingCITAZIONE// 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 modoCITAZIONE// 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 AliasCITAZIONEnamespace silviettafunction {
void f();
}
namespace figa =silviettafunction;
Ora ogni volta che scriviamo figa sarà come usare silviettafunction
Edited by 1mPHUNit0 - 28/12/2007, 15: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 stringheCODICE/******************************************************
* 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. -
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++CITAZIONEshort 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.