| |
— | appunti3s:dichiarazione_e_definizione [2020/06/08 22:19] (current) – created - external edit 127.0.0.1 |
---|
| ====== Dichiarazione e definizione ====== |
| La //dichiarazione// è un "annuncio" al compilatore dell'uso di nuovo elemento, ma per poter usare l'elemento, questo deve essere anche //definito//. |
| Quindi è obbligatorio "definire" tutto ciò che è stato "dichiarato". |
| Una classe può essere usata solo dopo aver effettuato (oltre alla sua definizione) anche la definizione delle funzioni che essa contiene. |
| |
| |
| ===== Dichiarazione ===== |
| Annuncia l'utilizzo di un nuovo oggetto (variabile) o una nuova funzione (o f. membro). |
| La //dichiarazione// può essere fatta più volte in posti diversi ogni volta che è necessario dare informazioni al compilatore per lavorare su un nuovo oggetto o funzione. |
| Vedere EXTERN... |
| * La //dichiarazione// delle funzioni viene fatta nell'header file. |
| * La //dichiarazione// di una funzione, se necessario, può essere fatta anche più di una volta. |
| * La //dichiarazione// delle funzioni membro viene fatta dentro le //definizioni// delle classi, sempre nell'header file. |
| * La //dichiarazione// di una funzione (f.membro) è detta anche //firma//. es: //int funzione(float a);// |
| * La //dichiarazione// di un oggetto (variabile) può essere fatta, in un unico colpo, attraverso la sua //definizione// (all'interno di una classe o di una funzione (o f.membro). |
| * La dichiarazione di una classe contiene solo il nome della classe, e anch'essa termina sempre col punto e virgola (;) |
| * nota: per approfondire le dichiarazioni, studiare i namespace.... |
| |
| ===== Definizione ===== |
| La //definizione// contiene in sé anche una //dichiarazione//. |
| La //definizione// oltre ad effettuare anche una //dichiarazione// (l'annuncio), in più: |
| * alloca (riserva) anche la necessaria area di memoria per contenerlo. L'area può essere immediatamente inizializzata. |
| * La //definizione// di una funzione (f.membro), oltre ad annunciarne l'utilizzo, specifica anche il blocco delle istruzioni che la costituiscono, detto anche il //corpo//. Viene detta anche //implementazione//. |
| * Per il precedente motivo la definizione è unica e non si può ripetere. |
| * La //definizione// di una classe, invece, non alloca memoria né inizializza! |
| * La //definizione// di una classe è l'unica ad avere bisogno delle parentesi graffe, e termina anch'essa col punto e virgola (;) |
| * La //definizione// di una classe (come detto prima) non contiene le //definizioni//, ma solo le //dichiarazioni// delle sue funzioni membro. |
| * La //definizione// di una classe deve, per questo motivo, essere seguita dalla //definizione// (o implementazione) di tutte le sue funzioni membro . |
| |
| |
| ===== Variabili ===== |
| Non si distingue tra //dichiarazione// e //definizione//: |
| <code>int x; </code> |
| è sia dichiarazione che definizione. |
| Dopo aver visto alcuni esempi, si può stabilire una regola per le dichiarazioni di variabili: |
| <code>const float tassoMutuo = 0.064;</code> |
| specificatore + tipo + operatore + nome + operatore + inizializzazione |
| ===== Funzioni ===== |
| esempio di //dichiarazione// (nell'header) |
| <code>void fun(std::string parola);</code> |
| esempio di //definizione// |
| <code>void fun(std::string parola) |
| { |
| // codice... |
| }</code> |
| |
| >> Le funzioni membro definite dentro la def. della classe sono **implicitamente** "[[appunti3s:inline]]" |
| ===== Classi ===== |
| esempio di //dichiarazione// (nell'header) |
| <code>Class Cosa;</code> |
| esempio di //definizione// (anch'essa nell'header) |
| <code> |
| Class Cosa |
| { |
| public: |
| Cosa(); // dich. di funzione (da definire) |
| private: |
| int x; |
| void fun(std::string parola); // dich. di funzione (da definire) |
| }; |
| </code> |