Funzioni C++ per input

da tastiera controllato in applicazioni console

Siete il visitatore n.

English version not available

Pagina ottimizzata per risoluzione 1024x768

Recapiti

Problemi di controllo dei singoli caratteri con l'immissione da tastiera tramite stream

Nei manuali di C/C++ non si fa riferimento a librerie standard, ovvero previste dal linguaggio, per la gestione dell'input di singoli caratteri da tastiera. Nel momento in cui si ha bisogno, in applicazioni per console, che l'utente immetta dati numerici o alfanumerici, si può sfruttare una serie abbastanza ampia di funzioni appartenenti alla libreria standard quali scanf, get e altre, che permettono di manipolare le sequenze di caratteri immesse e trarne le informazioni volute. Tali funzioni hanno però il difetto, che talvolta può essere un inconveniente piuttosto serio, di essere applicabili alla sequenza di caratteri immessa dall'utente solo dopo che questi abbia premuto il tasto CR (invio). In pratica, per fare immettere all'utente ad esempio un numero intero decimale, sfruttando lo stream di ingresso previsto dalla funzioni standard l'utente è libero di:

a) digitare un numero di caratteri quasi a piacere

b) digitare caratteri che non hanno nulla a che vedere con il tipo di valore che il programma deve elaborare.

Ad esempio, le istruzioni

int a;
do
{
cout << "Digita un numero compreso fra -5 e 9 \n";
cin >> a;
}
while (a< -5 || a>9);

cout << a << endl;

sollecitano l'utente ad immettere un numero compreso fra i valori indicati, ma l'utente potrebbe a quel punto digitare anche i primi venti versi della Divina Commedia (senza premere CR), riempiendo sostanzialmente lo schermo di caratteri che nulla hanno a che vedere con i dati da immettere. Solo nel momento in cui si preme CR, di fatto, lo stream di ingresso cin viene scorso per rintracciare eventuali caratteri congruenti con il tipo di dato di cui si richiede l'immissione, in questo caso un int.

Per evitare questi problemi, si impone l'utilizzo di un controllo su ogni singolo carattere digitato sulla tastiera, in modo da

a) accettare e visualizzare solo i caratteri congruenti con il dato da immettere, ad esempio cifre e segno nel caso di immissione di un numero decimale

b) controllare che non venga immesso un numero spropositato di cifre, per non andare a sovrascrivere altre parti di testo già presenti sullo schermo

Sebbene non facciano parte della libreria standard, generalmente le utility per la gestione dei singoli caratteri battuti sulla tastiera sono fornite nelle varie implementazioni dei compilatori C++, gratuiti e non.
Solitamente il file di libreria che le contiene, già compilato o meno, ha nome conio.xxx (I/O da console), dove l'estensione può essere .c, .cpp, .cc, .o o simili. Il corrispondente file di intestazione (header) ha generalmente nome conio.h.

Riconoscimenti e avvertenze

Le funzioni qui descritte e riportate sono state scritte utilizzando l'ambiente di sviluppo Dev C++ 4.9.8.0, a carattere gratuito, sottoposto comunque a diritti e licenze (Copyright Bloodsheed Software, GNU license, ecc.). Nell'ambiente Dev C++ viene fornita la libreria conio.c, parte di altre librerie e/o ambienti (MingW).

La citazione dell'opera di terze parti, nelle righe qui sopra, è incompleta e ha carattere indicativo; in ogni caso, in questa pagina non viene riportato alcun materiale scritto da altri, ma solo funzioni scritte dall'autore di questo articolo. In particolare, non viene riportata la libreria conio.c; per scaricarla e utilizzarla, leggere attentamente le relative condizioni di licenza.

Trattandosi di materiale messo gratuitamente a disposizione di chiunque lo desideri, ne è vietata ogni forma di utilizzazione per pubblicazioni commerciali. Ogni forma di utilizzazione per uso personale è permessa e auspicata.

Se in qualche modo si intende utilizzare le funzioni descritte in questo articolo per scopi non puramente personali, o divulgare il materiale contenuto in questa pagina (escluse le funzioni), è fatto obbligo di richiedere un permesso scritto all'autore di questo articolo (anche via e-mail).

E' invece possibile divulgare il listato delle funzioni, mantenendo però nei commenti il nome dell'autore.

Nel caso queste funzioni vengano solo lievemente modificate, è gradito che venga citato il nome dell'autore originale. Naturalmente, nel caso le funzioni vengano profondamente modificate, nessuna citazione è richiesta.

Le informazioni contenute in questa pagina sono fornite così come sono, senza alcuna forma di garanzia. Non mi assumo naturalmente alcuna responsabilità per danni diretti o indiretti a persone o a cose derivanti dalle informazioni contenute in questo articolo.

Le funzioni

Tale funzione controlla, tramite l'operatore sizeof(), che il compilatore con il quale si sta compilando il programma generi codice in cui i tipi discreti controllati nella funzione stessa siano rappresentati esattamente sul numero di byte previsto, ad esempio 4 byte per il tipo int. Nel caso tale controllo non abbia esito positivo, le altre funzioni qui riportate non dovrebbero essere utilizzate, pena possibile malfunzionamento e/o comportamento imprevisto. Tale controllo è reso necessario dal fatto che non per tutti i compilatori un dato tipo è rappresentato sullo stesso numero di byte; il C++ prevede infatti solo un numero di byte minimo per rappresentare un dato tipo.

Consente di immettere solo cifre decimali (0-9); la cifra immessa non viene visualizzata

Permette di fare immettere all'utente un numero intero, compreso fra -2^32 e 2^32-1, iniziando l'immissione alla locazione posx_curs, posy_curs. Tale funzione non fa altro che invocare la funzione immetti_int_limiti, descritta qui di seguito; per una descrizione più approfondita fare riferimento ad essa.

La funzione in questione permette di fare immettere all'utente un numero intero, compreso fra valore_min e valore_max, iniziando l'immissione alla locazione posx_curs, posy_curs. Naturalmente posx_curs e posy_curs devono essere valori ammissibili; valore_min e valore_max devono naturalmente essere compresi fra -2^32 e 2^32 - 1; valore_min deve essere <= valore_max.

La funzione opera nel seguente modo:

l'immissione di un numero compreso fra i limiti valore_min e valore_max termina premendo CR;

è possibile immettere solo segno +, e segno - e cifre decimali;

è possibile immettere numeri positivi e lo zero facendoli precedere o meno dal segno +

non è possibile immettere lo zero preceduto dal segno meno

non è possibile immettere numeri di più di una cifra con uno zero iniziale (es +03, -097928)

non è possibile immettere un numero di cifre maggiore di quello corrispondente al massimo fra le cifre di valore_max e valore_min

non è possibile terminare l'immissione, ovvero CR non ha effetto, se tale numero risulta esterno ai limiti specificati

per le correzioni si deve usare il tasto backspace

se il cursore raggiunge la posizione x=80, y=25, non è consentito immettere altre cifre

se il cursore raggiunge la posizione x=80, con y<25, e viene digitata una cifra, l'immissione continua sulla riga seguente, a capo.

La funzione riportata in questa pagina fa uso delle seguenti funzioni della libreria non standard conio.c

void clrscr() // pulisci schermo

int getch() // restituisce il codice ASCII del carattere digitato sulla tastiera

void gotoxy(int x. int y) // posiziona il cursore a colonna x e riga y

int putch (int a) // scrive sullo schermo, alla posizione individuata dal cursore, il carattere di codice ASCII a

Il file conio.c deve essere disponibile nell'ambiente di compilazione. Se non lo avete, probabilmente potete trovarlo in rete per il vostro sistema operativo. Attenzione: in alcune librerie, le funzioni qui utilizzate hanno nomi leggermente differenti, ad esempio int _getch al posto di int getch() e simili.

Nota: nella funzione immetti_int_limiti al momento ci sono ancora delle linee per il debug, le quali visualizzano i caratteri immessi e la sequenza di caratteri che va a riempire un array per il controllo limiti minime e massimo. Si tratta delle parti in cui viene utilizzato cout. Eliminarle tranquillamente (magari dopo aver capito a cosa servono).




// ----------------------------------------------------------------------------
// immissione di un numero di tipo int su 4 byte, compreso fra i limiti
// valore_min e valore_max, a partire dalla posizione posx_curs, posy_curs
// I limiti devono essere
// a) compresi nell'intervallo di rappresentabilita' del tipo int
// b) valore_min <= valore_max
// se a) e/o b) non sono verificate, il comportamento di questa funzione
// e' imprevedibile
// Per adattare questa funzione ad altri tipi numerici discreti (long long, ecc.),
// modificare n_max_cifre di conseguenza, e naturalmente il tipo degli argomenti,
// del risultato, della variabile numero e della variabile servizio.

// La scomposizione in cifre di valore_max e valore_min, quando si tratta di
// numeri negativi, e' stata testata e funziona se l'aritmetica degli interi
// e' tale che il resto della divisione, valore_xxx%10 , ha lo stesso segno
// del dividendo (negativo), ma sulla carta funziona anche se l'aritmetica e'
// tale che valore_xxx%10 assume lo stesso segno del divisore (positivo).


int immetti_int_limiti (int valore_min, int valore_max,
unsigned int posx_curs, unsigned int posy_curs)
{


const int n_max_cifre_tipo=10; // numero massimo di cifre, segno escluso, del TIPO
// che viene immesso dall'utente attraverso questa funzione (qui un int su 4 byte).


int servizio=0;
int cifre_valore_max[n_max_cifre_tipo];
int cifre_valore_min[n_max_cifre_tipo];

bool valore_max_is_positivo=false; // valore_max_is_positivo == true se valore_max >= 0
if (valore_max >=0)
{valore_max_is_positivo=true;}

bool valore_min_is_positivo=false; // valore_min_is_positivo == true se valore_min >= 0
if (valore_min >=0)
{valore_min_is_positivo=true;}

// scomposizione in cifre di valore_max
if (valore_max_is_positivo == true)
{
servizio=valore_max;
for (int i=0; i<n_max_cifre_tipo;i++)
{
cifre_valore_max[i]=servizio%10;
servizio=servizio/10;
}
}

if (valore_max_is_positivo == false)
{
servizio=valore_max;
for (int i=0; i<n_max_cifre_tipo;i++)
{
int j=0;
while (servizio%10!=0)
{
servizio++;
j++;
}
cifre_valore_max[i]=j;
servizio=servizio/10;
}
}

// scomposizione in cifre di valore_min
if (valore_min_is_positivo == true)
{
servizio=valore_min;
for (int i=0; i<n_max_cifre_tipo;i++)
{
cifre_valore_min[i]=servizio%10;
servizio=servizio/10;
}
}

if (valore_min_is_positivo == false)
{
servizio=valore_min;
for (int i=0; i<n_max_cifre_tipo;i++)
{
int j=0;
while (servizio%10!=0)
{
servizio++;
j++;
}
cifre_valore_min[i]=j;
servizio=servizio/10;
}
}


// calcolo numero massimo di cifre che il numero immesso puo' avere, escluso il segno
// Si tratta del massimo numero di cifre fra quelle di valore_min e di valore_max
// n_max_cifre_immissione risulta <= n_max_cifre_tipo
int n_max_cifre_immissione=0;
for (int i=n_max_cifre_tipo; i>0; i--)
{
if (cifre_valore_max[i-1] !=0 || cifre_valore_min[i-1] !=0)
{n_max_cifre_immissione=i;
break;
}
}
if (n_max_cifre_immissione == 0) // caso in cui valore_min == valore_max == 0
{n_max_cifre_immissione=1;}



gotoxy(1,1);

cout << endl;
cout << "valore_max = " << valore_max << endl;
for (int i=0;i<n_max_cifre_immissione; i++)
{cout << cifre_valore_max[i] <<'\t';}

cout << endl;
cout << "valore_min = " << valore_min << endl;
for (int i=0;i<n_max_cifre_immissione; i++)
{cout << cifre_valore_min[i] <<'\t';}

cout << "nmaxcifreimmissione= " << n_max_cifre_immissione << endl;




int cifre[n_max_cifre_immissione]; // vettore delle cifre immesse (dim. <= n_max_cifre_tipo)
for (int i=0; i<n_max_cifre_immissione; i++)
{cifre[i]=0;}

int numero=0; // risultato restituito dalla funzione

int carattere=0; // la getch() restituisce un int
int contatore_cifre=0; // indica il numero di cifre immesse (escluso il segno)

bool utilizzo_segno_meno=false;
bool utilizzo_segno_piu=false;// nota: se utilizzo_segno_piu == false NON vuol
// dire che il numero immesso e' negativo o nullo, ma solo che non e' stato usato
// il segno +
// se invece utilizzo_segno_meno == true, significa che il numero immesso e'
// sicuramente negativo, perche' la funzione NON permette di scrivere -0
bool carattere_OK=false;
bool immissione_terminata=false;
bool carattere_is_backspace=false;


gotoxy(posx_curs, posy_curs);

do
{
carattere_OK=false;
carattere=getch();

if (posx_curs == 80 && posy_curs == 25 && carattere !=8 && carattere != 13)
{continue;} // salta al while del do-while

if (carattere == '-' && utilizzo_segno_meno == false
&& utilizzo_segno_piu == false && contatore_cifre == 0)
{
utilizzo_segno_meno=true;
carattere_OK=true;
}

if (carattere == '+' && utilizzo_segno_piu == false
&& utilizzo_segno_meno == false && contatore_cifre == 0)
{
utilizzo_segno_piu=true;
carattere_OK=true;
}

if (
( (carattere == '0' && utilizzo_segno_meno == false && contatore_cifre == 0)
|| (carattere > '0' && carattere <= '9' && contatore_cifre == 0)
|| (carattere >= '0' && carattere <='9' && contatore_cifre >0 && cifre[0] != 0)
)
&& (contatore_cifre < n_max_cifre_immissione)
) // fine condizione if
{ // inizio parte then
for (int i=contatore_cifre; i>0; i--)
{cifre[i]=cifre[i-1];}
cifre[0]=carattere - '0';
contatore_cifre++;
carattere_OK=true;
} // fine parte then


// mettere l' if qui di seguito prima dell' if successivo , perche' il
// successivo altera contatore_cifre e potrebbe rendere vera la condizione
// dell' if qui di seguito
if (carattere == 8 && contatore_cifre == 0
&& (utilizzo_segno_meno == true || utilizzo_segno_piu == true)
) // backspace e c'e' solo il segno
{
utilizzo_segno_meno=false;
utilizzo_segno_piu=false;
carattere_is_backspace=true;
}

if (carattere == 8 && contatore_cifre > 0) // backspace e ci sono cifre
{
for (int i=0; i<contatore_cifre-1; i++)
{cifre[i]=cifre[i+1];}
cifre[contatore_cifre-1]=0;
contatore_cifre--;
carattere_is_backspace=true;
}

if (carattere == 13 && contatore_cifre > 0)
{
numero=0;
immissione_terminata=true; // viene messo nuovamente a false se i controlli
// seguenti sui limiti danno esito negativo

// controllo valore_max positivo o nullo
if (valore_max_is_positivo == true)
{
if (utilizzo_segno_meno == false) // numero immesso positivo o nullo;
// utilizzo_segno_piu puo' essere true o false
{
for (int i=n_max_cifre_immissione; i>0; i--)
{
if (cifre[i-1]<cifre_valore_max[i-1])
{break;} // esce dal for
if (cifre[i-1]>cifre_valore_max[i-1])
{
immissione_terminata=false;
break;
} // esce dal for
}
}
if (utilizzo_segno_meno == true) // numero immesso negativo
{ ; }
} // fine controllo valore_max positivo o nullo


// controllo valore_max negativo
if (valore_max_is_positivo == false)
{
if (utilizzo_segno_meno == false) // numero immesso positivo o nullo;
// utilizzo_segno_piu puo' essere true o false
{immissione_terminata=false;}

if (utilizzo_segno_meno == true) // numero immesso negativo
{
for (int i=n_max_cifre_immissione; i>0; i--)
{
if (cifre[i-1]>cifre_valore_max[i-1])
{break;} // esce dal for
if (cifre[i-1]<cifre_valore_max[i-1])
{
immissione_terminata=false;
break;
} // esce dal for
}
}

} // fine controllo valore_max negativo


// controllo valore_min positivo o nullo
if (valore_min_is_positivo == true)
{
if (utilizzo_segno_meno == false) // numero immesso positivo o nullo;
// utilizzo_segno_piu puo' essere true o false
{
for (int i=n_max_cifre_immissione; i>0; i--)
{
if (cifre[i-1]>cifre_valore_min[i-1])
{break;} // esce dal for
if (cifre[i-1]<cifre_valore_min[i-1])
{
immissione_terminata=false;
break;
} // esce dal for
}
}
if (utilizzo_segno_meno == true) // numero immesso negativo
{immissione_terminata=false;}
} // fine controllo valore_min positivo o nullo


// controllo valore_min negativo
if (valore_min_is_positivo == false)
{
if (utilizzo_segno_meno == false) // numero immesso positivo o nullo;
// utilizzo_segno_piu puo' essere true o false
{ ; }

if (utilizzo_segno_meno == true) // numero immesso negativo
{
for (int i=n_max_cifre_immissione; i>0; i--)
{
if (cifre[i-1]<cifre_valore_min[i-1])
{break;} // esce dal for
if (cifre[i-1]>cifre_valore_min[i-1])
{
immissione_terminata=false;
break;
} // esce dal for
}
}

} // fine controllo valore_min negativo

} // fine di if (carattere == 13 && contatore_cifre > 0)

if (immissione_terminata == true) // creazione numero da restituire al chiamante
{
numero=0;
if (utilizzo_segno_meno==false) // numero immesso positivo o nullo
{
for (int i=n_max_cifre_immissione; i>0; i--)
{numero=numero*10+cifre[i-1];}
}

// Attenzione: poiche' il valore minimo del tipo e', in valore assoluto,
// uguale a valore massimo + 1, NON si puo' semplicemente calcolare il valore
// assoluto di numero come sopra e poi cambiargli di segno, perche' il valore
// assoluto stesso potrebbe non essere rappresentabile
if (utilizzo_segno_meno==true) // numero immesso negativo
{
for (int i=n_max_cifre_immissione; i>0; i--)
{
if (numero==0 && cifre[i-1] != 0)
{numero= -cifre[i-1];}
else
{numero=numero*10-cifre[i-1];}
}
}
} // fine creazione numero da restituire al chiamante


gotoxy(1,7);
cout << endl;
cout << "valore immesso = " << endl;
for (int i=0;i<n_max_cifre_immissione; i++)
{cout << cifre[i] <<'\t';}
cout << endl;
gotoxy(posx_curs, posy_curs);



if (carattere_OK == true)
{
gotoxy(posx_curs, posy_curs);
putch(carattere);
posx_curs++;
if (posx_curs == 81 && posy_curs < 25) // in realta', se posx_curs == 80
// && posy_curs == 25 carattere_OK non puo' essere true, perche' la funzione
// non permette di inserire altri caratteri diversi da CR e backspace
{
posx_curs=1;
posy_curs++;
}

gotoxy(posx_curs, posy_curs);
}

if (carattere_is_backspace == true)
{
posx_curs--;
if (posx_curs == 0 && posy_curs>0) // se risulta posx_curs == 0 e
// posy_curs == 0 significa che la funzione e' stata invocata con
// valori inappropriati di posx_curs e posy_curs
{
posx_curs=80;
posy_curs--;
}
gotoxy(posx_curs, posy_curs);
putch(' ');
gotoxy(posx_curs, posy_curs);
carattere_is_backspace=false;
}

}
while(immissione_terminata==false); // fine do - while

return numero;
}
// ------- OK 090704 00.19 --------------------------------------------------------------------