Sottoprogrammi
Una subroutine è una parte separata del programma che ha un nome e risolve il proprio compito separato. La subroutine si trova all'inizio del programma principale e può essere lanciata (chiamata) dal programma principale specificandone il nome.
L'utilizzo delle subroutine consente di evitare la duplicazione del codice, se è necessario scrivere lo stesso codice in punti diversi del programma.
Le librerie importate nel programma (per esempio, la libreria matematica сmath.h) consistono in subroutine che sono già state compilate da qualcuno. I programmatori non hanno bisogno di pensare a quali algoritmi implementano, ma semplicemente li applicano, pensando solo a cosa stanno facendo esattamente. Questo è un grande risparmio di tempo. Non è necessario scrivere un algoritmo che è già stato scritto da qualcun altro.
Ogni routine dovrebbe eseguire solo un compito, puoi semplicemente calcolare qualcosa, o generare alcuni dati o fare qualcos'altro.
Le subroutine sono di due tipi: procedure e funzioni.
Le subroutine eseguono alcune azioni, ad esempio, visualizzano il risultato sullo schermo in una certa forma (un semplice esempio, l'operatore printf() è una subroutine standard che stampa informazioni sullo schermo)
Le subroutine delle funzioni restituiscono un risultato (numero, stringa di caratteri, ecc.) che possiamo utilizzare nel programma principale.
Proviamo a scrivere una semplice procedura:
Supponiamo di voler visualizzare la stringa " Error" ogni volta che può verificarsi un errore nel codice per colpa dell'utente (ad esempio, quando inserisce dati errati)
Questo può essere fatto scrivendo la dichiarazione
cout << "Errore";
E ora immagina che una riga del genere debba essere inserita in molti punti del programma. Certo, puoi semplicemente scriverlo ovunque. Ma questa soluzione ha due inconvenienti.
1) questa stringa verrà memorizzata molte volte
2) se vogliamo modificare l'output in caso di errore, dovremo modificare questa riga in tutto il programma, il che è piuttosto scomodo
Per tali casi, sono necessarie procedure.
Un programma con una procedura potrebbe essere simile a questo:
#include<iostream>
utilizzando lo spazio dei nomi std;
void printError() // descrizione della procedura
{
cout << "Errore"; // corpo della procedura - comandi che la procedura eseguirà
}
principale()
{
...
printError() // avvia la procedura per l'esecuzione. Specifichiamo semplicemente il nome della procedura che vogliamo eseguire.
...
stampaErrore()
...
}
La procedura inizia con la parola void. Ci sono parentesi vuote dopo il nome della procedura.
Tutte le istruzioni eseguite in una procedura sono rientrate.
Le procedure sono scritte prima della funzione principale main()
Per eseguire una procedura, nel programma principale devi chiamarla per nome e ricordarti di scrivere le parentesi!
È possibile chiamare una procedura in un programma un numero qualsiasi di volte.
|
Immaginiamo ora di dover visualizzare messaggi diversi in risposta all'errore di un utente, a seconda del tipo di errore commesso.
In questo caso, puoi scrivere la tua procedura per ogni errore:
void printErrorZero()
{
cout << "Errore. Divisione per zero!";
}
void printErrorInput()
{
cout << "Errore nell'inserimento!";
}
E se ci sono molti più possibili errori? Questa soluzione non fa per noi!
Dobbiamo imparare a controllare la procedura dicendole quale messaggio di errore visualizzare.
Per fare ciò, abbiamo bisogno di parametri che scriveremo tra parentesi dopo il nome della procedura
void printError(stringhe)
{
cout << S;
}
In questa procedura, s è un parametro, una variabile speciale che consente di controllare la procedura.
Il parametro è una variabile che determina come funziona la subroutine. I nomi dei parametri sono elencati separati da virgole nell'intestazione del sottoprogramma. Il tipo di parametro è scritto prima del parametro.
Ora, quando si chiama la procedura, bisogna indicare tra parentesi il valore effettivo che verrà assegnato al parametro (variabile s) all'interno della nostra procedura
printError("Errore! Divisione per zero!");
Questo valore è chiamato argomento.
L'argomento è il valore del parametro che viene passato alla subroutine quando viene chiamata.
Un argomento può essere non solo un valore costante, ma anche una variabile o un'espressione aritmetica.
|
Variabili locali e globali
Spesso è necessario utilizzare variabili aggiuntive che verranno utilizzate solo nella subroutine. Tali variabili sono chiamate local (o local) e possono essere manipolate solo all'interno della subroutine in cui sono create.
L'ambito della variabile locale è il blocco tra parentesi graffe all'interno del quale è dichiarato
Il programma principale in C++ è anche una subroutine, quindi tutte le variabili dichiarate all'interno di main() sono variabili locali.
Altre subroutine non "sanno" nulla delle variabili locali di altre subroutine.
Pertanto, è possibile limitare l'ambito (ambito) di una variabile solo alla subroutine in cui è realmente necessario. In programmazione, questa tecnica è chiamata incapsulamento - nascondere una variabile dall'essere modificata dall'esterno.
Se è necessario dichiarare una variabile che sarebbe visibile in qualsiasi punto del programma (in qualsiasi subroutine), allora tali variabili vengono dichiarate al di fuori di tutte le subroutine (vedere il programma 3 dalla tabella sottostante).
Tali variabili sono chiamate global.
In C++, all'avvio del programma, tutte le variabili globali vengono automaticamente impostate a zero (le variabili booleane assumono il valore false ).
Analizza tre programmi:
| 1) In questo programma, la variabile i è locale. Una variabile locale è dichiarata all'interno di una subroutine |
2) Qui, anche se c'è una variabile i nel programma principale (con valore 7), verrà creata una nuova variabile locale i con valore 5.
Quando esegui questo programma, lo schermo visualizzerà il valore 75 |
3) Questo programma ha una variabile globale i. Il suo valore può essere modificato all'interno di una subroutine e all'interno del programma principale
La procedura funzionerà con la variabile globale i e le verrà assegnato un nuovo valore pari a 2. Il valore 2 | viene visualizzato sullo schermo
|
prova del vuoto()
{
int io = 5;
cout << io;
}
|
prova del vuoto()
{
int io = 5;
cout << io;
}
principale()
{
int io = 7;
cout << io;
test();
}
|
#include <iostream>
utilizzando lo spazio dei nomi std;
int io;
prova del vuoto()
{
io = 2;
}
principale()
{
test();
cout << io;
}
|
|
Attività
Scrivi una procedura che scambia i valori di due variabili.
Le peculiarità di questo compito sono che abbiamo bisogno che le modifiche apportate alla procedura diventino note al programma chiamante.
Proviamo a scrivere la procedura in questo modo:
void Swap ( int a, int b ) // con una tale descrizione dei parametri della procedura,
{ // verranno copiati i valori degli argomenti (x e y),
intero c; // le variabili a e b sono variabili indipendenti non correlate a x e y
c = un; un = b; b=c;
}
principale()
{
int x=1, y=2;
Scambia(x, y); // i valori delle variabili x e y (argomenti) vengono copiati nei parametri a e b
cout << "x=" << x<< ", y=" << y; // x=1, y=2
}
Se esegui questo programma, puoi vedere che i valori delle variabili x e y non sono cambiati. Affinché i parametri modifichino i valori degli argomenti, è necessario utilizzare passando i dati per riferimento. Per fare ciò, dopo il nome del tipo di dati nell'intestazione della subroutine, devi mettere il segno & ("e commerciale").
void Scambia ( int & a, int & b ) // ora le variabili a e b ottengono gli indirizzi delle variabili x e y in memoria
{
intero c;
c = un; un = b; b=c;
}
Utilizzo: se passi un argomento per riferimento, solo il nome della variabile (NON un numero e NON un'espressione aritmetica) può trovarsi in questa posizione quando chiami la procedura!< br />
NON chiamare una procedura come questa:
Scambia(x, 4 );
Scambia(5+x, y);
|