Arduino - Fonctions de caractères

Toutes les données sont entrées dans les ordinateurs sous forme de caractères, qui comprennent des lettres, des chiffres et divers symboles spéciaux. Dans cette section, nous abordons les capacités de C ++ pour examiner et manipuler des caractères individuels.

La bibliothèque de gestion de caractères comprend plusieurs fonctions qui effectuent des tests et des manipulations utiles des données de caractères. Chaque fonction reçoit un caractère, représenté par un int, ou EOF comme un argument. Les caractères sont souvent manipulés comme des entiers.

N'oubliez pas qu'EOF a normalement la valeur –1 et que certaines architectures matérielles ne permettent pas le stockage de valeurs négatives dans des variables char. Par conséquent, les fonctions de gestion des caractères manipulent les caractères comme des entiers.

Le tableau suivant résume les fonctions de la bibliothèque de gestion de caractères. Lorsque vous utilisez des fonctions de la bibliothèque de gestion de caractères, incluez le<cctype> entête.

S.No. Prototype et description
1

int isdigit( int c )

Renvoie 1 si c est un chiffre et 0 sinon.
2

int isalpha( int c )

Renvoie 1 si c est une lettre et 0 sinon.
3

int isalnum( int c )

Renvoie 1 si c est un chiffre ou une lettre et 0 sinon.
4

int isxdigit( int c )

Renvoie 1 si c est un caractère hexadécimal et 0 dans le cas contraire.

(Voir l'annexe D, Systèmes de nombres, pour une explication détaillée des nombres binaires, octaux, décimaux et hexadécimaux.)
5

int islower( int c )

Renvoie 1 si c est une lettre minuscule et 0 sinon.
6

int isupper( int c )

Renvoie 1 si c est une lettre majuscule; 0 sinon.
sept

int isspace( int c )

Renvoie 1 si c est un caractère d'espace blanc - nouvelle ligne ('\ n'), espace

(''), saut de page ('\ f'), retour chariot ('\ r'), tabulation horizontale ('\ t') ou tabulation verticale ('\ v') - et 0 sinon.
8

int iscntrl( int c )

Renvoie 1 si c est un caractère de contrôle, tel que nouvelle ligne ('\ n'), saut de page ('\ f'), retour chariot ('\ r'), tabulation horizontale ('\ t'), tabulation verticale (' \ v '), alert (' \ a ') ou backspace (' \ b ') - et 0 sinon.
9

int ispunct( int c )

Renvoie 1 si c est un caractère d'impression autre qu'un espace, un chiffre ou une lettre et 0 dans le cas contraire.
dix

int isprint( int c )

Renvoie 1 si c est un caractère d'impression avec espace ('') et 0 sinon.
11

int isgraph( int c )

Renvoie 1 si c est un caractère d'impression autre que l'espace ('') et 0 sinon.

Exemples

L'exemple suivant montre l'utilisation des fonctions isdigit, isalpha, isalnum et isxdigit. Fonctionisdigitdétermine si son argument est un chiffre (0–9). La fonctionisalphadétermine si son argument est une lettre majuscule (AZ) ou une lettre minuscule (a – z). La fonctionisalnumdétermine si son argument est une lettre majuscule, minuscule ou un chiffre. Fonctionisxdigit détermine si son argument est un chiffre hexadécimal (A – F, a – f, 0–9).

Exemple 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

Résultat

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

Nous utilisons l'opérateur conditionnel (?:)avec chaque fonction pour déterminer si la chaîne "est un" ou la chaîne "n'est pas un" doit être imprimée dans la sortie pour chaque caractère testé. Par exemple, linea indique que si «8» est un chiffre, c'est-à-dire si isdigitrenvoie une valeur vraie (différente de zéro) - la chaîne "8 est un" est imprimée. Si '8' n'est pas un chiffre (c'est-à-dire siisdigit renvoie 0), la chaîne "8 n'est pas un" est imprimée.

Exemple 2

L'exemple suivant montre l'utilisation des fonctions islower et isupper. La fonctionislowerdétermine si son argument est une lettre minuscule (a – z). Fonctionisupper détermine si son argument est une lettre majuscule (A – Z).

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

Résultat

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

Exemple 3

L'exemple suivant montre l'utilisation des fonctions isspace, iscntrl, ispunct, isprint et isgraph.

  • La fonction isspace détermine si son argument est un caractère d'espace blanc, tel que espace (''), saut de page ('\ f'), nouvelle ligne ('\ n'), retour chariot ('\ r'), tabulation horizontale ('\ t ') ou tabulation verticale (' \ v ').

  • La fonction iscntrl détermine si son argument est un caractère de contrôle tel que tabulation horizontale ('\ t'), tabulation verticale ('\ v'), form feed ('\ f'), alert ('\ a'), backspace ('\ b '), retour chariot (' \ r ') ou nouvelle ligne (' \ n ').

  • La fonction ispunct détermine si son argument est un caractère d'impression autre qu'un espace, un chiffre ou une lettre, tel que $, #, (,), [,], {,},;,: ou%.

  • La fonction isprint détermine si son argument est un caractère qui peut être affiché à l'écran (y compris le caractère espace).

  • La fonction isgraph teste les mêmes caractères que isprint, mais le caractère espace n'est pas inclus.

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

Résultat

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space