C Language
- classificazione e conversione dei caratteri

Classificazione dei caratteri letti da un flusso

#include <ctype.h>
#include <stdio.h>

typedef struct {
  size_t space;
  size_t alnum;
  size_t punct;
} chartypes;

chartypes classify(FILE *f) {
  chartypes types = { 0, 0, 0 };
  int ch;

  while ((ch = fgetc(f)) != EOF) {
    types.space += !!isspace(ch);
    types.alnum += !!isalnum(ch);
    types.punct += !!ispunct(ch);
  }

  return types;
}

La funzione classify legge i caratteri da uno stream e conta il numero di spazi, caratteri alfanumerici e di punteggiatura. Evita molte insidie.

• Durante la lettura di un carattere da uno stream, il risultato viene salvato come int , poiché altrimenti ci sarebbe un'ambiguità tra la lettura di EOF (il marker di fine del file) e un carattere con lo stesso pattern di bit.
• Le funzioni di classificazione dei caratteri (ad esempio isspace ) si aspettano che il loro argomento sia rappresentabile come un unsigned char o il valore della macro EOF . Poiché questo è esattamente ciò che restituisce il fgetc , non c'è bisogno di conversione qui.
• Il valore di ritorno delle funzioni di classificazione dei caratteri distingue solo tra zero (significato false ) e non zero (che significa true ). Per il conteggio del numero di occorrenze, questo valore deve essere convertito in 1 o 0, operazione eseguita dalla doppia negazione, !! .

Classificazione dei caratteri da una stringa

#include <ctype.h>
#include <stddef.h>

typedef struct {
  size_t space;
  size_t alnum;
  size_t punct;
} chartypes;

chartypes classify(const char *s) {
  chartypes types = { 0, 0, 0 };
  const char *p;
  for (p= s; p != '\0'; p++) {
    types.space += !!isspace((unsigned char)*p);
    types.alnum += !!isalnum((unsigned char)*p);
    types.punct += !!ispunct((unsigned char)*p);
  }

  return types;
}

La classify la funzione esamina tutti i caratteri di una stringa e conta il numero di spazi, caratteri alfanumerici e di punteggiatura. Evita molte insidie.

• Le funzioni di classificazione dei caratteri (ad esempio isspace ) si aspettano che il loro argomento sia rappresentabile come un unsigned char o il valore della macro EOF .
• L'espressione *p è di tipo char e deve quindi essere convertita per corrispondere alla dicitura precedente.
• Il tipo di char è definito come equivalente al signed char o al unsigned char .
• Quando char è equivalente a unsigned char , non ci sono problemi, dal momento che ogni possibile valore del tipo char è rappresentabile come unsigned char .
• Quando char è equivalente al signed char , deve essere convertito in unsigned char prima di essere passato alle funzioni di classificazione dei caratteri. E sebbene il valore del personaggio possa cambiare a causa di questa conversione, questo è esattamente ciò che si aspettano queste funzioni.
• Il valore di ritorno delle funzioni di classificazione dei caratteri distingue solo tra zero (significato false ) e non zero (che significa true ). Per il conteggio del numero di occorrenze, questo valore deve essere convertito in 1 o 0, operazione eseguita dalla doppia negazione, !! .

introduzione

L'intestazione ctype.h è una parte della libreria C standard. Fornisce funzioni per la classificazione e la conversione di caratteri.

Tutte queste funzioni accettano un parametro, un int che deve essere EOF o rappresentabile come un carattere senza segno.

I nomi delle funzioni di classificazione sono preceduti da "è". Ognuno restituisce un valore intero diverso da zero (VERO) se il carattere passato ad esso soddisfa la condizione correlata. Se la condizione non è soddisfatta, la funzione restituisce un valore zero (FALSE).

Queste funzioni di classificazione funzionano come mostrato, assumendo la locale predefinita C:

int a;
int c = 'A';
a = isalpha(c); /* Checks if c is alphabetic (A-Z, a-z), returns non-zero here. */
a = isalnum(c); /* Checks if c  is alphanumeric (A-Z, a-z, 0-9), returns non-zero here. */
a = iscntrl(c); /* Checks is c is a control character (0x00-0x1F, 0x7F), returns zero here. */
a = isdigit(c); /* Checks if c is a digit (0-9), returns zero here. */
a = isgraph(c); /* Checks if c has a graphical representation (any printing character except space), returns non-zero here. */
a = islower(c); /* Checks if c is a lower-case letter (a-z), returns zero here. */
a = isprint(c); /* Checks if c is any printable character (including space), returns non-zero here. */
a = isupper(c); /* Checks if c is a upper-case letter (a-z), returns zero here. */
a = ispunct(c); /* Checks if c is a punctuation character, returns zero here. */
a = isspace(c); /* Checks if c is a white-space character, returns zero here. */
a = isupper(c); /* Checks if c is an upper-case letter (A-Z), returns non-zero here. */
a = isxdigit(c); /* Checks if c is a hexadecimal digit (A-F, a-f, 0-9), returns non-zero here. */

a = isblank(c); /* Checks if c is a blank character (space or tab), returns non-zero here. */

Ci sono due funzioni di conversione. Questi sono nominati usando il prefisso 'a'. Queste funzioni riprendono lo stesso argomento di quelle sopra. Tuttavia, il valore restituito non è uno zero semplice o diverso da zero ma l'argomento passato è cambiato in qualche modo.

Queste funzioni di conversione funzionano come mostrato, assumendo la locale predefinita C:

int a;
int c = 'A';

/* Converts c to a lower-case letter (a-z). 
 * If conversion is not possible the unchanged value is returned. 
 * Returns 'a' here. 
 */
a = tolower(c);

/* Converts c to an upper-case letter (A-Z). 
 * If conversion is not possible the unchanged value is returned. 
 * Returns 'A' here. 
 */
a = toupper(c);

Le informazioni sottostanti sono citate da cplusplus.com che mappano come l'insieme ASCII di 127 caratteri originale è considerato da ciascuna delle funzioni di tipo di classificazione (a • indica che la funzione restituisce un valore diverso da zero per quel carattere)