|
Karakter- en bitmanipulatie
Kleine en grote letters
Bestudeer het programma OMWISSEL.C voor een voorbeeld van een programma
dat enkele karakter manipulaties doet. Het programma wisselt kleine
letters om in grote en grote letters in kleine. Het laat zien hoe een
viertal funkties, die karakters manipuleren, werken. Het zal niet al te
moeilijk zijn dit programma te begrijpen. De funkties worden alle
aangeroepen in de funktie WisselLettersOm(). Het
hoofdprogramma kennen we uit eerdere voorbeelden en wordt niet verder
toegelicht.
<![CDATA[
#include <stdio.h> /* standard Invoer/Uitvoer header file */
#include <ctype.h> /* standard C datatypes header file */
main ()
{
char best_naam[32]; /* bestandsnaam */
char regel[81]; /* gelezen regel */
FILE *pf; /* pointer naar FILE */
printf ("Tik de naam van een bestand in:\n");
scanf ("%s", best_naam); /* lees bestandsnaam */
pf = fopen (best_naam, "r"); /* open voor lezen */
while ((fgets (regel, 100, pf)) != NULL) {
WisselLettersOm (regel);
printf ("%s", regel);
}
fclose (pf); /* sluit het bestand weer af */
}
WisselLettersOm (ptr) /* Deze funktie maakt van kleine */
char *ptr; /* letters hoofdletters en andersom */
{
while (*ptr) {
if (islower (*ptr)) *ptr = toupper (*ptr);
else if (isupper (*ptr)) *ptr = tolower (*ptr);
ptr++;
} /* endwhile */
}
]]>
Compileer en test dit programma. Neem een willekeurig bestand als
invoer. De vier bedoelde funkties zijn:
| islower() | Is de letter een kleine letter? |
| isupper() | Is de letter een grote letter? |
| tolower() | Maak van de letter een kleine letter. |
| toupper() |
Maak van de letter een grote letter.
|
Klassificatie van tekens
Bestudeer het programma SOORT.C met een voorbeeld hoe je tekens kunt
tellen. We hebben tot nu toe steeds het NewLine karakter (\n) gebruikt.
Er zijn echter nog meer bijzondere tekens. Hier volgt een
opsomming:
| \n | NewLine karakter |
| \t | Tab karakter |
| \b | Backspace karakter |
| \" | Aanhalings teken |
| \\ | Backslash teken |
| \0 | NULL karakter |
Deze tekens kunnen afgedrukt worden of naar een bestand geschreven. De
tekens uit het bovenstaande overzicht met de aanduiding
karakter zijn niet zichtbaar, de tekens met de aanduiding
teken zijn zichtbare tekens. Het Backslash teken (\) voor
de letter is een aanduiding dat het hier om een bijzonder teken gaat.
<![CDATA[
#include <stdio.h> /* standard Invoer/Uitvoer header file */
#include <ctype.h> /* standard C datatypes header file */
main ()
{
char best_naam[32]; /* bestandsnaam */
char regel[81]; /* gelezen regel */
FILE *pf; /* pointer naar FILE */
printf ("Tik de naam van een bestand in:\n");
scanf ("%s", best_naam); /* lees bestandsnaam */
pf = fopen (best_naam, "r"); /* open voor lezen */
while ((fgets (regel, 100, pf)) != NULL)
tel_soorten (regel);
fclose (pf); /* sluit het bestand weer af */
}
tel_soorten (ptr)
char *ptr;
{
static int regelteller = 0;
int spaties, letters, cijfers;
char teken;
letters = cijfers = spaties = 0;
while (*ptr) {
teken = *ptr++;
putchar (teken);
if (isalpha (teken)) letters++;
if (isdigit (teken)) cijfers++;
if (isspace (teken)) spaties++;
} /* endwhile */
printf (" # %04d --- Lt: %d Cf: %d Sp: %d ---\n",
++regelteller, letters, cijfers, spaties-1);
}
]]>
Het programma maakt gebruik van funkties die het soort teken kan
bepalen, met andere woorden tot welke klasse een teken behoort. De
tekens worden door dit programma per regel gelezen en per regel
een voor een beoordeeld.
De letters, cijfers en de spaties worden geteld.
Behoort een teken niet tot een van deze drie klassen dan wordt hij
overgeslagen. Per regel wordt de telling afgedrukt, na de regel zelf.
De drie bedoelde funkties zijn:
| isalpha() | Is het teken een letter (a-z, A-Z) |
| isdigit() | Is het teken een cijfer (0-9) |
| isspace() | Is het teken een spatie (blanco, NewLine of Tab) |
Compileer en test dit programma.
Logische funkties
Bestudeer het programma BITS.C. In dit programma wordt op bit niveau
met de gegevens gewerkt. Het is mogelijk in C de bits individueel te
benaderen. Een bit kan dus van waarde worden veranderd, maar ook alle
bits in een byte en alle bits van een integer kunnen in een keer een
andere waarde krijgen. De operators waarmee dit worden uitgevoerd
zijn:
| & | Logische AND, als beide bits 1 zijn, is het resultaat 1 |
| | | Logische OR, als een of beide bits 1 zijn, is het resultaat 1 |
| ^ | Logische XOR, als een en slechts een van de bits 1 is, is het resultaat 1 |
| ~ | Inversie, een 1 wordt een 0, een 0 wordt een 1 |
<![CDATA[
main ()
{
int index;
char masker;
char nummer[6];
char and, or, xor, inv;
nummer[0] = 0x00;
nummer[1] = 0x11;
nummer[2] = 0x22;
nummer[3] = 0x44;
nummer[4] = 0x88;
nummer[5] = 0xFF;
printf (" Num Msk And Or Xor Inv\n");
printf (" --- --- --- --- --- ---\n");
masker = 0x0F;
for (index = 0; index < 6; index++) {
and = masker & nummer[index];
or = masker | nummer[index];
xor = masker ª nummer[index];
inv = ~ nummer[index];
printf (" %02X %02X %02X %02X %02X %02X\n",
nummer[index], masker,
and, or, xor, inv);
} /* endfor */
printf ("\n");
masker = 0x22;
for (index = 0; index < 6; index++) {
and = masker & nummer[index];
or = masker | nummer[index];
xor = masker ª nummer[index];
inv = ~ nummer[index];
printf (" %02X %02X %02X %02X %02X %02X\n",
nummer[index], masker,
and, or, xor, inv);
} /* endfor */
}
]]>
Het voorbeeld programma gebruikt enkele velden in combinatie met de
bovengenoemde operatoren. De gegevens zijn in het hexadecimale formaat.
Aangenomen wordt dat je vertrouwd bent met het lezen van hexadecimale
getallen. Zo niet dan zul je dat eerst moeten leren, het wordt hier niet
verder behandeld. Het leren omgaan met hexadecimale getallen is geen
leerstof voor deze cursus en wordt bekend verondersteld.
Compileer en test dit programma.
Schuif instructies
De laatste twee operaties die we nog leren zijn de schuif instructies.
In C kun je bits links en/of rechts schuiven. Bestudeer het programma
SCHUIF.C, waarin een voorbeeld staat van hoe bits een of meerdere
posities kunnen worden opgeschoven.
<![CDATA[
main ()
{
int klein, groot, index, aantal;
printf (" Schuif Links Schuif Rechts\n");
printf (" ------------- --------------\n");
for (klein = 1, groot = 0x8000, index = 0; index < 16; index++) {
printf ("%8d %8d %8d %8d\n",
klein, klein << 1, groot, groot >> 1);
klein <<= 1;
groot >>= 1;
} /* endfor */
printf ("\n\n\n");
printf (" Schuif Links Schuif Rechts\n");
printf (" ------------- --------------\n");
aantal = 2;
for (klein = 1, groot = 0x8000, index = 0; index < 8; index++) {
printf ("%8d %8d %8d %8d\n",
klein, klein << aantal, groot, groot >> aantal);
klein <<= aantal;
groot >>= aantal;
} /* endfor */
}
]]>
De twee instructies maken gebruik van de volgende operators:
| << n | Schuif bits n posities naar links |
| >> n | Schuif bits n posities naar rechts |
Ook hier wordt een en ander uitgevoerd met behulp van de hexadecimale
notatie en de resultaten hexadecimaal afgedrukt. Het programma is erg
eenvoudig van opzet en bevat geen moeilijke constructies.
Compileer en test tenslotte dit programma.
|
