Stl : filtrer le caractere clavier et constituer une chaine

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 093 fois - Téléchargée 36 fois

Contenu du snippet

Un exemple de plus sur la saisie caractère par caractère en vérifiant que chacun fait parti d'un filtre pour constituer une chaîne.
Il met en euvre la STL par une fonction de Algorithm permettant de contrôler que le caractère appartient au filtre, les sorties formatées et string.
Il utilise la fonction getch() du C pour faire une saisie bas niveau.

Le FILTRE donne les caractères autorisés.

Le programme a pour objectif d'utiliser des possibilités de la STL.

Source / Exemple :


//---- STL : Filtrer le caractere clavier et constituer  une chaine ----
//  	Met en oeuvre
//	  - getch() du C
//	  - les W formatees
//	  - string
//	  - la fonction binary_search() de Algorithm
//--------------------------------- David Saint-Mellion 12/02/2003 -----

#include <conio.h>	// getch()
#include <iostream>	// cout, endl
#include <algorithm>	// binary_search()
#include <string>
using namespace std;

  // Filtre des caracteres classes par ordre croissant
  // de la table ASCII pour binary_search().
  string FILTRE("+,/0129ABCW[]\abez{|}"); 

int main(){
	string bufferSaisie;
	char carSaisie;

	cout<<"Saisir, caracteres autorises : "<<FILTRE<<endl;
	
	do{
	// debut Tq
	    // Saisie d'un caractere
	    carSaisie=getch();
	    // Teste si le caractere appartient au FILTRE
	    if (binary_search(FILTRE.begin(),FILTRE.end(),carSaisie))
	       // Si vrai ajoute le caractere au bufferSaisie
	       bufferSaisie = bufferSaisie + carSaisie;
	    // Affiche le bufferSaisie
	   cout<<'\r'<<"SAISIE :"<<bufferSaisie;
	// Repeter Tq different de Return	
	}while (carSaisie!=0x0D);
	
	return 0;
}

// --------------------------- Fonction utilisee ---------------------------
// Recherche binaire de la valeur d'un objet dans une sequence triee
//  - bool binary_search(itrForward Prem, itrForward Dern, const T &Valeur);
//  Retourne true si Valeur appartient a la sequence itrPrem-itrDern
// -------------------------------------------------------------------------

Conclusion :


Condition :
- Il faut que les caractères du FILTRE soit classés par ordre croissant de la table ASCII
pour que la fonction binary_search() soit efficace.

Extention :
- Il peut être plus simple, dans certaines situations, de définir les caractères interdits. Dans ce cas, il faut les donner dans FILTRE et inverser la valeur de retour de la fonction binary_search() avec l'opérateur '!'

A voir également

Ajouter un commentaire

Commentaires

cs_davidsm
Messages postés
35
Date d'inscription
lundi 6 janvier 2003
Statut
Membre
Dernière intervention
12 novembre 2004
-
Pourquoi pas une classe 'Filtre'

Telle qu'elle est, il me semble qu'il vaut mieux rester sur le source amélioré avec la proposition de Kaid.

Par contre, elle est la base pour proposer des services de filtrage supplémentaires du genre :
- Le nombre de caractères à saisir
- De filtrer des valeurs pour d'autres types que les caractères : int, float ..
- --
- Dans classe Filtre, il me semble préférable de surcharger l'opérateur << plutot que (), mais c'est un peut plus compliqué.
cs_vieuxLion
Messages postés
455
Date d'inscription
samedi 26 octobre 2002
Statut
Membre
Dernière intervention
6 avril 2004
7 -
Intéressante discussion ! je reformule
l'assembleur est intéressant... mais limité à des régions de code à optimiser aggressivement
la conclusion étant que la réutilisation est intéressante:
voici une classe Filtre réutilisant 100% de la technique ci dessus
(pas d'opérateur << pour ne pas charger...)

#include <conio.h> // getch()
#include // cout, endl
#include <string>
using namespace std;

class Filtre
{
private:
// Filtre des caracteres
string filtre_;//("+,/0129ABCW[]abez{|}");
public:
Filtre(string filtre):filtre_(filtre)
{}
bool estCorrect(char c)
{return filtre_.find(c)!=string::npos;}
operator string()
{return filtre_;}
};

int main(){
string bufferSaisie;
char carSaisi;
Filtre f("+,/0129ABCW[]abez{|}");
cout<<"Saisir, caracteres autorises (ou non): "<< (string)f<<endl;

do{
carSaisi=getch(); // Saisie d'un caractere
if (f.estCorrect(carSaisi))// le caractere appartient-il au FILTRE
bufferSaisie = bufferSaisie + carSaisi;
// Affiche le bufferSaisie
cout<<'
'<<"SAISIE :"<<bufferSaisie;
}while (carSaisi!=0x0D);
cout << endl;
return 0;
}
cs_Kaid
Messages postés
950
Date d'inscription
mardi 2 octobre 2001
Statut
Membre
Dernière intervention
8 juillet 2006
-
Merci de m'avoir corrigé davidsm.
cs_davidsm
Messages postés
35
Date d'inscription
lundi 6 janvier 2003
Statut
Membre
Dernière intervention
12 novembre 2004
-
Pour chercher si un caractère est présent dans une chaîne stockée dans un objet de type string, il faut utiliser la fonction membre de la classe string : find().

La solution proposée par de Kaid est idéale dans ce cas avec un petit aménagement pour npos :

if ( FILTRE.find(carSaisie)!=string::npos )
bufferSaisie+=carSaisie;

La fonction find() renvoie la constante string::npos lorsqu'elle atteint la fin. Dans notre cas cela traduit que carSaisie n'appartient pas au FILTRE

De manière générale :
Si on utilise un objet et que la classe dispose d'une fonction de traitement, il vaut mieux l'utiliser plutôt que d'opérer avec une fonction plus générale de la classe "algorithm".

Le PROGRAMME avec string.find():

#include <conio.h> // getch()
#include // cout, endl
#include <string>

using namespace std;

// Les caractères du FILTRE peuvent être en vrac pour find()
string FILTRE("+BCW[],/0192Aabez{|}");

int main(){
string bufferSaisie;
char carSaisie;

cout<<"Saisir, caracteres autorises : "<<FILTRE<<endl;
do{
carSaisie=getch();
if ( FILTRE.find(carSaisie)!=string::npos )
bufferSaisie+=carSaisie;
}while (carSaisie!=0x0D);

return 0;
}
cs_Kaid
Messages postés
950
Date d'inscription
mardi 2 octobre 2001
Statut
Membre
Dernière intervention
8 juillet 2006
-
davidsm: 'La' ?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.