8. Αλφαριθμητικά

Σύνοψη Μεμονωμένοι χαρακτήρες, πίνακες χαρακτήρων, είσοδος αλφαριθμητικών με την fgets(), συναρτήσεις αλφαριθμητικών, strlen(), strcat(), strcmp(), sscanf(), sprintf(), strtok(), εφαρμογές με αλφαριθμητικά.

Προαπαιτούμενη γνώση Τύποι δεδομένων, είσοδος/έξοδος, δομές επιλογής και επανάληψης, συναρτήσεις, πίνακες, δομές, δείκτες.

8.1 Εισαγωγή

Τα αλφαριθμητικά είναι ιδιαίτερη περίπτωση μονοδιάστατων πινάκων καθώς αποτελούνται από χαρακτήρες και ο σκοπός τους είναι να αναπαραστήσουν λέξεις και φράσεις. Για παράδειγμα στην ακόλουθη εντολή η έκφραση Hello world είναι ένα αλφαριθμητικό.

printf("Hello world");

Τα αλφαριθμητικά βρίσκονται πάντα μέσα σε διπλά εισαγωγικά και αυτό τα διαχωρίζει από τους απλούς χαρακτήρες που τοποθετούνται εντός μονών εισαγωγικών. Στη συνέχεια θα περιγραφούν οι μεταβλητές χαρακτήρα που αποτελούν βασικό συστατικό των αλφαριθμητικών, ενώ αμέσως μετά θα περιγραφούν τα αλφαριθμητικά και συναρτήσεις της τυπικής βιβλιοθήκης της C που δέχονται ως ορίσματα αλφαριθμητικά.

8.2 Μεταβλητές χαρακτήρα

Οι μεταβλητές χαρακτήρα χρησιμοποιούνται για να δηλώσουν έναν χαρακτήρα όπως είναι π.χ. το 'Α', το '1', το '#' και άλλα. Ο τύπος δεδομένων που χρησιμοποιείται για τέτοιες μεταβλητές είναι ο τύπος char. Μια μεταβλητή char καταλαμβάνει ακριβώς 1 byte στη μνήμη του υπολογιστή. Ένα παράδειγμα εισόδου αλφαριθμητικού από τον χρήστη και εμφάνισης του αποτελέσματος στην οθόνη παρουσιάζεται στον κώδικα 8.1. Για την είσοδο χαρακτήρων αλλά και για την εμφάνισή τους με τις συναρτήσεις scanf() και printf() αντίστοιχα χρησιμοποιείται ο προσδιοριστής %c.

#include <stdio.h>

int main(void) {
  char a = 'a';
  char b = '1';
  printf("a=%c, b=%c\n", a, b);
  printf("Input a value for a char variable: ");
  scanf("%c", &b);
  printf("a=%c, b=%c\n", a, b);
  return 0;
}

Ένα παράδειγμα πιθανής εκτέλεσης του προγράμματος είναι το ακόλουθο:

a=a, b=1
Input a value for a char variable: z
a=a, b=z

Μια ακόμα συνάρτηση που μπορεί να χρησιμοποιηθεί προκειμένου να γίνει ανάγνωση χαρακτήρων είναι η getchar(). Η συνάρτηση αυτή διαβάζει έναν χαρακτήρα από την καθιερωμένη είσοδο και τον επιστρέφει, όπως παρουσιάζεται στον κώδικα 8.2. Στο παράδειγμα αυτό γίνεται ανάγνωση από την καθιερωμένη είσοδο μέχρι ο χρήστης να εισάγει αλλαγή γραμμής. Σε κάθε επανάληψη ο μετρητής count αυξάνεται κατά 1 και στο τέλος εμφανίζεται το πλήθος των χαρακτήρων του κειμένου που εισήγαγε ο χρήστης.

#include <stdio.h>

int main(void) {
  char ch;
  int count = 0;
  printf("Input a line of text: ");
  while ((ch = getchar()) != '\n') {
    count++;
  }
  printf("Total characters in line: %d \n", count);
  return 0;
}

Ακολουθεί ένα παράδειγμα εκτέλεσης του προγράμματος:

Input a line of text: premature optimization is the root of all evil
Total characters in line: 46

Παρόλο που το όνομα του τύπου είναι char, τέτοιες μεταβλητές μπορούν να χρησιμοποιηθούν και για αναπαράσταση ακέραιων αριθμών, όπως φαίνεται στον κώδικα 8.3, όπου οι μεταβλητές τύπου char χρησιμοποιούνται ως ακέραιοι αριθμοί με προσθέσεις, αναθέσεις κ.λπ. Οι δε κωδικοί 65 και 66 που εμφανίζονται για τους χαρακτήρες 'Α' και 'Β' είναι οι αντίστοιχοι κωδικοί αυτών των χαρακτήρων στον πίνακα ASCII.

#include <stdio.h>

int main(void) {
  char letter, next_letter;
  int code, next_code;
  letter = 'A';
  code = letter;
  next_letter = letter + 1;
  next_code = next_letter;
  printf("The first character is %c\n", letter);
  printf("The ASCII code of the first character is %d\n", code);
  printf("The next character is %c\n", next_letter);
  printf("The ASCII code of the first character is %d\n", next_code);
  return 0;
}

Η εκτέλεση του προγράμματος παράγει την ακόλουθη έξοδο:

The first character is A
The ASCII code of the first character is 65
The next character is B
The ASCII code of the first character is 66

8.3 Συναρτήσεις χαρακτήρα

Στον πίνακα ASCII τα κεφαλαία γράμματα του αγγλικού αλφαβήτου βρίσκονται πριν από τα πεζά στις θέσεις 65 έως και 89. Τα πεζά γράμματα βρίσκονται μετά τη θέση 97. Επιπλέον, τα γράμματα είναι συνεχόμενα, που σημαίνει πως για παράδειγμα ο χαρακτήρας 'Β' βρίσκεται μετά τον χαρακτήρα 'Α'. Στον κώδικα 8.4 κάνοντας χρήση αυτής της σειράς, γίνεται μετατροπή κάθε πεζού γράμματος στο αντίστοιχο κεφαλαίο. Η ανάγνωση των γραμμάτων γίνεται επαναληπτικά και σταματά με την είσοδο του χαρακτήρα '#'. Ο έλεγχος για το διάστημα όπου βρίσκεται ένα γράμμα γίνεται με χρήση λογικών τελεστών, μιας και οι μεταβλητές χαρακτήρα είναι και ακέραιες τιμές.

#include <stdio.h>

int main(void) {
  char letter;
  char uppercase;
  printf("Input a sequence of letters ending with #: ");
  do {
    scanf("%c", &letter);
    if (letter >= 'a' && letter <= 'z') {
      uppercase = letter - ('a' - 'A'); // αφαιρεί την τιμή 32
      printf("%c", uppercase);
    }
  } while (letter != '#');
  printf("\n");
  return 0;
}

Ένα παράδειγμα πιθανής εκτέλεσης του προγράμματος είναι το ακόλουθο:

Input a sequence of letters ending with #: abcdefg#
ABCDEFG

Επιπλέον, η τυπική βιβλιοθήκη της C παρέχει μια σειρά από χρήσιμες συναρτήσεις για τον χειρισμό τέτοιων καταστάσεων. Ορισμένες από αυτές τις συναρτήσεις παρουσιάζονται στον πίνακα 8.1. Για τη χρήση τους θα πρέπει να συμπεριληφθεί η ακόλουθη εντολή στην αρχή του προγράμματος:

#include <ctype.h>

Πίνακας 8.1: Συναρτήσεις χειρισμού χαρακτήρων και ελέγχου των τιμών τους.

Συνάρτηση	Σημασία
int isalnum(int x);	Επιστρέφει αληθές αν το x είναι γράμμα ή ψηφίο.
int isalpha(int x);	Επιστρέφει αληθές αν το x είναι γράμμα.
int iscntrl(int x);	Επιστρέφει αληθές αν το x είναι χαρακτήρας ελέγχου.
int isdigit(int x);	Επιστρέφει αληθές αν το x είναι αριθμητικό σύμβολο.
int islower(int x);	Επιστρέφει αληθές αν το x είναι μικρό λατινικό γράμμα.
int isprint(int x);	Επιστρέφει αληθές αν το x είναι εκτυπώσιμος χαρακτήρας.
int ispunct(int x);	Επιστρέφει αληθές αν το x είναι σημείο στίξης.
int isspace(int x);	Επιστρέφει αληθές αν το x είναι κενό.
int isupper(int x);	Επιστρέφει αληθές αν το x είναι κεφαλαίο λατινικό γράμμα.
int isxdigit(int x);	Επιστρέφει αληθές αν το x είναι ένας χαρακτήρας που αντιστοιχεί σε δεκαεξαδικό ψηφίο.
int tolower(int x);	Επιστρέφει το πεζό λατινικό γράμμα που αντιστοιχεί στο κεφαλαίο x.
int toupper(int x);	Επιστρέφει το κεφαλαίο λατινικό γράμμα που αντιστοιχεί στο πεζό x.

Ένα παράδειγμα χρήσης τέτοιων συναρτήσεων παρουσιάζεται στον κώδικα 8.5, όπου ο χρήστης εισάγει μια γραμμή κειμένου με χρήση της συνάρτησης getchar() και γίνεται καταμέτρηση των ψηφίων καθώς και των πεζών γραμμάτων της αγγλικής γλώσσας της εισόδου. Όταν ο χρήστης εισάγει τον χαρακτήρα αλλαγής γραμμής, εμφανίζεται στην οθόνη το ποσοστό των πεζών γραμμάτων καθώς και το ποσοστό των ψηφίων.

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

int main(void) {
  char ch;
  int charcount = 0;
  int digitcount = 0;
  int lowercount = 0;
  printf("Enter a line of text: ");
  while ((ch = getchar()) != '\n') {
    charcount++;
    if (isdigit(ch)) {
      digitcount++;
    }
    if (islower(ch)) {
      lowercount++;
    }
  }
  printf("Total characters in line: %d\n", charcount);
  printf("Digits: %.2lf%%\n", digitcount * 100.0 / charcount);
  printf("Lower letters: %.2lf%%\n", lowercount * 100.0 / charcount);
  return 0;
}

Ακολουθεί ένα παράδειγμα εκτέλεσης του προγράμματος:

Enter a line of text: abcde12345
Total characters in line: 10
Digits: 50.00%
Lower letters: 50.00%

8.4 Πίνακες χαρακτήρων

Τοποθετώντας στη σειρά πολλούς χαρακτήρες σε έναν πίνακα δημιουργείται ένα αλφαριθμητικό για την αναπαράσταση λέξεων και προτάσεων. Ωστόσο, η γλώσσα πρέπει να γνωρίζει πού βρίσκεται το τέλος ενός αλφαριθμητικού μέσα σε έναν πίνακα. Αυτό γίνεται με τη χρήση του ειδικού χαρακτήρα '\0' για τον καθορισμό του τέλους. Προσοχή πρέπει να δοθεί στο γεγονός πως αυτός ο χαρακτήρας (NULL) δεν είναι το '0' αλλά ο χαρακτήρας που βρίσκεται στη θέση 0 του πίνακα ASCII, ο οποίος είναι μη εκτυπώσιμος. Το πρόγραμμα στον κώδικα 8.6 γεμίζει τον πίνακα χαρακτήρων x και στη συνέχεια τον εμφανίζει στην οθόνη.

#include <stdio.h>

int main(void) {
  char x[10];
  x[0] = 'L';
  x[1] = 'E';
  x[2] = 'E';
  x[3] = 'T';
  x[4] = '\0';
  printf("The string is %s\n", x);
  return 0;
}

Για την εμφάνιση του αλφαριθμητικού με τη χρήση της συνάρτησης printf() χρησιμοποιείται ο προσδιοριστής μορφοποίησης %s. Αν και το αλφαριθμητικό έχει δηλωθεί να έχει 10 στοιχεία, στην πραγματικότητα γίνεται εισαγωγή μόνο 4 χαρακτήρων ('L', 'E', 'E', 'T') και του ειδικού χαρακτήρα τερματισμού στο τέλος των χαρακτήρων. Στις υπόλοιπες 5 θέσεις δεν γίνεται κάποια εισαγωγή. Επομένως ο πίνακας x έχει τα περιεχόμενα που φαίνονται στο Σχήμα 8.1.

Φυσικά, αυτός ο τρόπος καθορισμού των περιεχομένων ενός αλφαριθμητικού δεν είναι ιδιαίτερα βολικός, αφού πρέπει ο χρήστης να εισάγει έναν προς έναν τους χαρακτήρες του, καθώς και τον χαρακτήρα τερματισμού. Στο παράδειγμα του κώδικα 8.7 παρουσιάζονται δύο εναλλακτικοί τρόποι που μπορούν να χρησιμοποιηθούν για να καθοριστούν τα περιεχόμενα ενός αλφαριθμητικού. Στην πρώτη περίπτωση ο χρήστης δηλώνει έναν πίνακα χαρακτήρων με 10 θέσεις (word1) και σε αυτόν γίνεται εισαγωγή 6 χαρακτήρων και του χαρακτήρα τερματισμού. Στη δεύτερη περίπτωση αφήνοντας κενή τη διάσταση του πίνακα (word2), το μέγεθος προσδιορίζεται δυναμικά από τον μεταγλωττιστή και ο πίνακας έχει χωρητικότητα 7 + 1 = 8 θέσεων.

#include <stdio.h>

int main(void) {
  char word1[10] = "Simple";
  char word2[] = "Another";
  printf("word1=%s word2=%s \n", word1, word2);
  return 0;
}

8.5 Εισαγωγή αλφαριθμητικών από το πληκτρολόγιο

Για να γίνει εισαγωγή ενός αλφαριθμητικού από το πληκτρολόγιο ο χρήστης έχει τις ακόλουθες επιλογές:

1. Να κάνει εισαγωγή τους χαρακτήρες του αλφαριθμητικού έναν προς έναν. Φυσικά αυτός ο τρόπος είναι αρκετά απλός, αλλά δεν μπορεί να χρησιμοποιηθεί παρά μόνο σε μικρά αλφαριθμητικά και θα πρέπει ο προγραμματιστής να μεριμνήσει ώστε να εισαγάγει τον χαρακτήρα τερματισμού στο τέλος του αλφαριθμητικού.
2. Να κάνει χρήση της συνάρτησης scanf().
3. Να κάνει χρήση της συνάρτησης fgets().

Η απλούστερη επιλογή είναι να εισάγει το αλφαριθμητικό με τη χρήση της συνάρτησης scanf(), όπως παρουσιάζεται στον κώδικα 8.8. Στο πρόγραμμα αυτό η εισαγωγή αλφαριθμητικών γίνεται με τον προσδιοριστή %s αλλά χωρίς τον χαρακτήρα διεύθυνσης &. Δηλαδή η σωστή χρήση είναι scanf("%s",x) και όχι scanf("%s",&x).

#include <stdio.h>

int main(void) {
  char x[100];
  printf("Enter X \n");
  scanf("%99s", x);
  printf("x = %s\n", x);
  return 0;
}

Ωστόσο, η scanf() έχει το πρόβλημα πως μπορεί να διαβάσει μόνο αλφαριθμητικά μιας λέξης και όχι προτάσεις. Αν για παράδειγμα σε αυτό το πρόγραμμα δοθεί ως είσοδος η πρόταση "TODAY IS MONDAY", παρά το ότι οι 99 διαθέσιμες θέσεις του πίνακα x επαρκούν για την αποθήκευσή της, μόνο η λέξη TODAY θα αποθηκευτεί και θα εμφανιστεί στη συνέχεια στην οθόνη. Σε τέτοιες περιπτώσεις, όταν δηλαδή είναι επιθυμητή η είσοδος προτάσεων με κενά, μπορεί να χρησιμοποιηθεί η συνάρτηση fgets() που προσφέρει αυτήν τη δυνατότητα. Ένα παράδειγμα χρήσης της fgets() παρουσιάζεται στον κώδικα 8.9.
Εκτός από την fgets(), παλαιότερα υπήρχε στο πρότυπο της γλώσσας η συνάρτηση gets(). Η gets() αφαιρέθηκε από τη γλώσσα με το πρότυπο C11, αλλά ακόμα συμπεριλαμβάνεται στις υλοποιήσεις των μεταγλωττιστών της C. Το πρόβλημα με την gets() ήταν ότι η είσοδος του χρήστη μπορεί να προκαλούσε το λεγόμενο “buffer overflow”, δηλαδή εγγραφή δεδομένων εκτός των ορίων του πίνακα χαρακτήρων που χρησιμοποιούνταν για την αποθήκευση του αλφαριθμητικού που έδινε ο χρήστης. Για τον λόγο αυτό η μεταγλώττιση κώδικα που περιέχει την gets() επιστρέφει την ακόλουθη προειδοποίηση (warning):

warning: 'gets' is deprecated: This function is provided for compatibility reasons
    ↪ only. Due to security concerns inherent in the design of gets(3), it is highly
    ↪ recommended that you use fgets(3) instead. [‐Wdeprecated ‐declarations]

Περισσότερες πληροφορίες για τη gets() μπορούν να βρεθούν στο ¹.

#include <stdio.h>
#include <string.h>

int main(void) {
  char s1[10], s2[10];
  printf("Input a string: ");
  fgets(s1, 10, stdin);
  s1[strcspn(s1, "\n")] = '\0'; // Αφαιρούμε το χαρακτήρα νέας γραμμής
  fflush(stdin); // Αδειάζουμε τον buffer του stdin
  printf("Input another string: ");
  fgets(s2, 10, stdin);
  s2[strcspn(s2, "\n")] = '\0'; 
  printf("The first string is: %s\n", s1);
  printf("The second string is: %s\n", s2);
  return 0;
}

8.6 Συναρτήσεις αλφαριθμητικών

H C παρέχει μια σειρά από χρήσιμες συναρτήσεις χειρισμού των αλφαριθμητικών που δηλώνονται στο αρχείο επικεφαλίδας string.h καθώς και στο stdio.h. Στη συνέχεια παρουσιάζεται η χρήση μερικών από αυτές τις συναρτήσεις.

8.6.1 Η συνάρτηση strlen()

Σε πολλές περιπτώσεις χρειάζεται ο προγραμματιστής να γνωρίζει πόσοι χαρακτήρες υπάρχουν σε ένα αλφαριθμητικό ή αλλιώς το μήκος του αλφαριθμητικού. Η τιμή αυτή είναι διαφορετική από τη διάσταση του πίνακα. Για παράδειγμα ο πίνακας char x[10] με περιεχόμενο TODAY, έχει διάσταση 10 θέσεων, αλλά ως αλφαριθμητικό έχει μήκος όσο και η λέξη TODAY, δηλαδή 5.
Το μήκος 5 συμπίπτει με τη θέση του χαρακτήρα τερματισμού στον πίνακα και επομένως εύκολα μπορεί να γραφεί μια συνάρτηση που θα εντοπίζει τη θέση του όπως παρουσιάζεται στον κώδικα 8.10. Στη συνάρτηση mystrlen(char x[]) ο μετρητής count αυξάνεται κατά ένα για κάθε θέση του πίνακα μέχρι να βρεθεί ο χαρακτήρας τερματισμού, οπότε η συνάρτηση επιστρέφει το πλήθος των χαρακτήρων του αλφαριθμητικού.

#include <stdio.h>

int mystrlen(const char x[]) {
  int count = 0;
  while (x[count] != '\0') {
    count++;
  }
  return count;
}

int main(void) {
  char x[100];
  printf("Input a line of text: ");
  fgets(x, 100, stdin);
  printf("You have entered: %s", x);
  printf("The length of the text that you entered is: %d\n", mystrlen(x));
  return 0;
}

Ακολουθεί ένα παράδειγμα εκτέλεσης του προγράμματος:

Input a line of text: any fool can use a computer
You have entered: any fool can use a computer
The length of the text that you entered is: 28

Στην τυπική βιβλιοθήκη της C υπάρχει η συνάρτηση strlen(), στην επικεφαλίδα <string.h>, που κάνει ανάλογη εργασία με τη συνάρτηση mystrlen(). Μια ενδεικτική χρήση της παρουσιάζεται στον κώδικα 8.11.

#include <stdio.h>
#include <string.h>

int main(void) {
  char x[100];
  printf("Input a line of text: ");
  fgets(x, 100, stdin);
  printf("You have entered: %s\n", x);
  printf("The length of the text that you entered is: %zu\n", strlen(x));
  return 0;
}

8.6.2 Η συνάρτηση strcat()

Μια πολύ συχνή λειτουργία στον προγραμματισμό είναι η συνένωση αλφαριθμητικών. Για παράδειγμα αν x="GOOD" και y="DAY", τότε η συνένωσή τους παράγει το αλφαριθμητικό GOODDAY. Στη string.h η συνάρτηση που χρησιμοποιείται για να επιτευχθεί συνένωση είναι η strcat(x,y). Η συνάρτηση αυτή συνενώνει το x με το y και το αποτέλεσμα ανατίθεται στο αλφαριθμητικό x. Φυσικά, ο προγραμματιστής πρέπει να έχει δώσει αρκετό χώρο στον πίνακα x, ώστε να επαρκέσει για την αποθήκευση και των δύο αλφαριθμητικών. Ένα παράδειγμα χρήσης της strcat() παρουσιάζεται στον κώδικα 8.12.

#include <stdio.h>
#include <string.h>

int main(void) {
  char x[20], y[10];
  printf("Input text: ");
  fgets(x, 10, stdin); // Διάβασε το πολύ 9 χαρακτήρες από το πληκτρολόγιο
  x[strcspn(x, "\n")] = '\0'; // Αφαιρούμε τον χαρακτήρα νέας γραμμής
  fflush(stdin); // Αδειάζουμε τον buffer του πληκτρολογίου
  printf("Input another text: ");
  fgets(y, 10, stdin);
  y[strcspn(y, "\n")] = '\0'; 
  strcat(x, y);
  printf("The concatenated text is: %s\n", x);
  return 0;
}

Μπορεί να γραφεί μια νέα συνάρτηση που να επιστρέφει το αποτέλεσμα της συνένωσης σε άλλη μεταβλητή. Για παράδειγμα η συνάρτηση μπορεί να καλείται ως concat(z,x,y) και να συνενώνει τα περιεχόμενα των αλφαριθμητικών x και y στη μεταβλητή z. Στο παράδειγμα του κώδικα 8.13 παρουσιάζεται αυτή η εκδοχή.

#include <stdio.h>
#include <string.h>

void concat(char z[], const char x[], const char y[]) {
  int count = 0;
  for (size_t i = 0; i < strlen(x); i++) {
    z[count++] = x[i];
  }
  for (size_t i = 0; i < strlen(y); i++) {
    z[count++] = y[i];
  }
  z[count] = '\0';
}

int main(void) {
  char x[10], y[10], z[50];
  printf("Input text: ");
  fgets(x, 10, stdin);
  fflush(stdin);
  printf("Input another text: ");
  fgets(y, 10, stdin);
  concat(z, x, y);
  printf("The concatenated text is %s\n", z);
  return 0;
}

8.6.3 Η συνάρτηση strcmp()

Για τη λεξικογραφική σύγκριση αλφαριθμητικών η πρότυπη βιβλιοθήκη ορίζει στο string.h τη συνάρτηση strcmp(x,y) που έχει τις ακόλουθες τιμές επιστροφής ανάλογα με το αποτέλεσμα της σύγκρισης των ορισμάτων της:

\[ \text{strcmp}(x, y) = \begin{cases} > 0, & x > y \\ 0, & x = y \\ < 0, & x < y \end{cases} \]

Στο παράδειγμα του κώδικα 8.14 διαβάζονται επαναληπτικά δύο αλφαριθμητικά από το πληκτρολόγιο, μέχρι ο χρήστης να εισαγάγει και τις δύο φορές το ίδιο αλφαριθμητικό.

#include <stdio.h>
#include <string.h>

int main(void) {
  char x[10], y[10];
  do {
    printf("Input a text: ");
    fgets(x, 10, stdin);
    printf("Input another text: ");
    fgets(y, 10, stdin);
  } while (strcmp(x, y) != 0);
  return 0;
}

Ακολουθεί ένα παράδειγμα εκτέλεσης του κώδικα.

Input a text: aa
Input another text: bb
Input a text: aa
Input another text: aa

Η συνάρτηση strcmp() μπορεί να χρησιμοποιηθεί και για την ταξινόμηση ονομάτων που βρίσκονται σε έναν πίνακα. Για να δηλώσουμε έναν πίνακα ονομάτων αρκεί να δηλώσουμε έναν πίνακα δύο διαστάσεων. Για παράδειγμα η char x[5][20]; δηλώνει και ορίζει έναν πίνακα πέντε αλφαριθμητικών, που το καθένα αλφαριθμητικό έχει μέγιστη χωρητικότητα 19 χαρακτήρων. Στο παράδειγμα του κώδικα 8.15 ταξινομούνται σε αύξουσα σειρά 5 ονόματα και εμφανίζονται στην οθόνη.

#include <stdio.h>
#include <string.h>

#define SIZE 5

int main(void) {
  char names[SIZE][20] = {"Dennis", "Ken", "Brian", "Stephen", "Bjarne"};
  char temp[20];
  for (int i = 0; i < SIZE; i++) {
    for (int j = 0; j < SIZE - 1; j++) {
      if (strcmp(names[j], names[j + 1]) > 0) {
        strcpy(temp, names[j]);
        strcpy(names[j], names[j + 1]);
        strcpy(names[j + 1], temp);
      }
    }
  }
  for (int i = 0; i < SIZE; i++) {
    printf("%s\n", names[i]);
  }
  return 0;
}

Η έξοδος του προγράμματος θα είναι η ακόλουθη:

Bjarne
Brian
Dennis
Ken
Stephen

8.6.4 Η συνάρτηση sscanf()

Η συνάρτηση sscanf() μπορεί να χρησιμοποιηθεί για ανάγνωση δεδομένων από ένα αλφαριθμητικό και όχι από το πληκτρολόγιο όπως συμβαίνει με την scanf(). Ένα παράδειγμα χρήσης της sscanf() παρουσιάζεται στον κώδικα 8.16. Στο παράδειγμα αυτό γίνεται ανάγνωση μιας ημερομηνίας από ένα αλφαριθμητικό και όχι από την καθιερωμένη είσοδο.

#include <stdio.h>
#include <string.h>

int main(void) {
  char info[100];
  int day, month, year;
  strcpy(info, "Day:9 Month:10 Year:2017");
  sscanf(info, "Day:%d Month:%d Year:%d", &day, &month, &year);
  printf("The final draft of C17 standard was published in: %d/%d/%d\n", day,
         month, year);
  return 0;
}

Η εκτέλεση του προγράμματος θα εμφανίσει το ακόλουθο μήνυμα:

The final draft of C17 standard was published in: 9/10/2017

8.6.5 Η συνάρτηση sprintf()

Κατ’ αντιστοιχία με τη συνάρτηση sscanf() που χρησιμοποιείται για την ανάγνωση δεδομένων από αλφαριθμητικό, υπάρχει και η συνάρτηση sprintf() που χρησιμοποιείται για την εκτύπωση δεδομένων σε αλφαριθμητικό και όχι στην καθιερωμένη έξοδο. Στο παράδειγμα του κώδικα 8.17 παρουσιάζεται η εκτύπωση ενός πίνακα σε ένα αλφαριθμητικό. Σε πολλές περιπτώσεις, για μεγαλύτερη ταχύτητα, τα αποτελέσματα καταγράφονται πρώτα σε αλφαριθμητικό (άρα στη μνήμη) και στη συνέχεια γράφονται στην οθόνη ή σε αρχεία.

#include <stdio.h>
#include <string.h>

int main(void) {
  char info[200];
  int x[5] = {10, 20, 30, 40, 50};
  strcpy(info, "");
  for (int i = 0; i < 5; i++) {
    sprintf(info, "%sx[%d]=%d\n", info, i, x[i]);
  }
  printf("%s\n", info);
  return 0;
}

Η έξοδος του προγράμματος θα είναι η ακόλουθη:

x[0]=10
x[1]=20
x[2]=30
x[3]=40
x[4]=50

8.6.6 Η συνάρτηση strtok()

Μια ακόμα συνάρτηση που χρησιμοποιείται μάλιστα στην κατασκευή μεταφραστικών προγραμμάτων (π.χ. μεταγλωττιστών) είναι η strtok(). Η συνάρτηση αυτή μπορεί να χρησιμοποιηθεί για τον διαχωρισμό ενός αλφαριθμητικού σε τμήματα με βάση κάποιο αλφαριθμητικό διαχωρισμού. Για παράδειγμα στο αλφαριθμητικό “C is quirky, flawed, and an enormous success.”, ο διαχωριστής , μπορεί να χρησιμοποιηθεί για να διαχωρίσει το αλφαριθμητικό στα τμήματα: “C is quirky”, “flawed” και “and an enormous success”. Στον κώδικα 8.18 παρουσιάζεται η χρήση της strtok() για τον παραπάνω διαχωρισμό. Η συνάρτηση αυτή έχει μια ιδιαιτερότητα. Την πρώτη φορά που θα κληθεί δέχεται ως όρισμα το αλφαριθμητικό που θα χρησιμοποιηθεί για την εξαγωγή της πληροφορίας καθώς και το αλφαριθμητικό διαχωρισμού. Σε κάθε επόμενη κλήση στη θέση του πρώτου ορίσματος τοποθετείται ο δείκτης NULL. Η συνάρτηση επιστρέφει NULL όταν ολοκληρωθεί η διαδικασία διαχωρισμού.

#include <stdio.h>
#include <string.h>

int main(void) {
  char str[80] = "C is quirky, flawed, and an enormous success";
  const char s[2] = ","; // Ο χαρακτήρας διαχωρισμού είναι το κόμμα
  char *token;
  token = strtok(str, s);
  while (token != NULL) {
    printf(" %s\n", token);
    token = strtok(NULL, s);
  }
  return 0;
}

Η έξοδος του προγράμματος είναι η ακόλουθη:

C is quirky
    flawed
    and an enormous success

8.7 Παραδείγματα προγραμμάτων με αλφαριθμητικά

Τα αλφαριθμητικά χρησιμοποιούνται συχνά στον προγραμματισμό διαφόρων εφαρμογών. Ακολουθούν μερικά παραδείγματα χρήσης αλφαριθμητικών.

8.7.1 Ολίσθηση αλφαριθμητικού

Η ολίσθηση ενός αλφαριθμητικού είναι παρόμοια με την ολίσθηση ενός πίνακα αριθμητικών τιμών, με τη διαφορά ότι πρέπει να δοθεί προσοχή έτσι ώστε ο χαρακτήρας τερματισμού '\0' του αλφαριθμητικού να μην αντικατασταθεί από κάποιον άλλο χαρακτήρα του αλφαριθμητικού. Για παράδειγμα η δεξιά ολίσθηση κατά τρεις χαρακτήρες του αλφαριθμητικού "FEATUREBUG" παρουσιάζεται στο Σχήμα 8.2.

Σχήμα 8.2: Κυκλική ολίσθηση του αλφαριθμητικού ”FEATUREBUG” κατά 3 χαρακτήρες προς τα δεξιά.

Στην παραπάνω ολίσθηση οι χαρακτήρες ’G’, ’U’ και ’B’ που θα χάνονταν με την ολίσθηση προς τα δεξιά τοποθετούνται στην αρχή του πίνακα. Η υλοποίηση της δεξιάς ολίσθησης παρουσιάζεται στον κώδικα 8.19.

#include <stdio.h>
#include <string.h>

void shift_right(char x[]) {
  char last = x[strlen(x) - 1];
  for (size_t i = strlen(x) - 1; i > 0; i--) {
    x[i] = x[i - 1];
  }
  x[0] = last;
}

int main(void) {
  char info[100];
  int n;
  printf("Input text: ");
  fgets(info, 100, stdin);
  // αφαίρεση του χαρακτήρα νέας γραμμής από την είσοδο του χρήστη
  info[strcspn(info, "\n")] = '\0';
  printf("How many right shifts do you want to perform? ");
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
    shift_right(info);
  }
  printf("Output text: %s\n", info);
  return 0;
}

Ακολουθεί ένα παράδειγμα εκτέλεσης του προγράμματος:

Input text: FEATUREBUG
How many right shifts do you want to perform? 3
Output text: BUGFEATURE

8.7.2 Αντιστροφή αλφαριθμητικού

Με την αντιστροφή αλφαριθμητικού οι χαρακτήρες που είναι στην αρχή του μετακινούνται στο τέλος και αντίστροφα. Για παράδειγμα η αντιστροφή του αλφαριθμητικού “FEATUREBUG” θα δώσει ως αποτέλεσμα “GUBERUTEAF”, όπως φαίνεται στο Σχήμα 8.3.

Σχήμα 8.3: Αντιστροφή του αλφαριθμητικού ”FEATUREBUG”.

Ουσιαστικά πρέπει να γίνουν αντιμεταθέσεις τιμών ανάμεσα στα στοιχεία, δηλαδή στο παράδειγμα πρέπει να γίνουν οι ακόλουθες αντιμεταθέσεις:

1. Αντιμετάθεση του χαρακτήρα στη θέση 0 με τον χαρακτήρα στη θέση 9.
2. Αντιμετάθεση του χαρακτήρα στη θέση 1 με τον χαρακτήρα στη θέση 8.
3. Αντιμετάθεση του χαρακτήρα στη θέση 2 με τον χαρακτήρα στη θέση 7.
4. Αντιμετάθεση του χαρακτήρα στη θέση 3 με τον χαρακτήρα στη θέση 6.
5. Αντιμετάθεση του χαρακτήρα στη θέση 4 με τον χαρακτήρα στη θέση 5.

Φθάνοντας στη μέση του αλφαριθμητικού σταματούν οι αντιμεταθέσεις, καθώς αν συνεχιστούν θα επαναφέρουν το αλφαριθμητικό στην αρχική του κατάσταση ακυρώνοντας την αντιστροφή. Η υλοποίηση της παραπάνω διαδικασίας για ένα αλφαριθμητικό που δίνει ο χρήστης παρουσιάζεται στον κώδικα 8.20.

#include <stdio.h>
#include <string.h>

void reverse(char x[]) {
  int N = strlen(x);
  for (int i = 0; i < N / 2; i++) {
    char t = x[i];
    x[i] = x[N - i - 1];
    x[N - i - 1] = t;
  }
}

int main(void) {
  char txt[100];
  printf("Input test: ");
  fgets(txt, 100, stdin);
  txt[strcspn(txt, "\n")] = '\0';
  reverse(txt);
  printf("Reversed text: %s\n", txt);
  return 0;
}

Ακολουθεί ένα παράδειγμα εκτέλεσης του προγράμματος:

Input test: The C programming language
Reversed text: egaugnal gnimmargorp C ehT

8.7.3 Μετατροπή δεκαδικού αριθμού σε δεκαεξαδικό

Η μετατροπή αριθμού από μια αριθμητική βάση σε μια άλλη συναντάται συχνά ως πρόβλημα. Ένα παράδειγμα είναι η μετατροπή ενός αριθμού από το γνωστό δεκαδικό σύστημα στο δεκαεξαδικό σύστημα. Το δεκαεξαδικό σύστημα χρησιμοποιεί ως συμβολισμό ψηφίων από τη θέση 10 μέχρι και τη θέση 15 τα σύμβολα A, B, C, D, E, F. Στον κώδικα 8.21 παρουσιάζεται η συνάρτηση dec2hex() που πραγματοποιεί τη ζητούμενη μετατροπή. Σε κάθε επανάληψη ο θετικός ακέραιος αριθμός n διαιρείται με το 16 και τα υπόλοιπα των διαιρέσεων είναι τα ψηφία του νέου αριθμού. Ωστόσο, με αυτήν τη διαδικασία τα ψηφία παράγονται από το πιο σημαντικό προς το λιγότερο σημαντικό και επομένως μετά τις διαιρέσεις απαιτείται η αντιστροφή του παραχθέντος αλφαριθμητικού που γίνεται με τη συνάρτηση reverse() που παρουσιάστηκε στον κώδικα 8.20.

#include <stdio.h>
#include <string.h>

void reverse(char x[]) {
  int N = strlen(x);
  for (int i = 0; i < N / 2; i++) {
    char t = x[i];
    x[i] = x[N - i - 1];
    x[N - i - 1] = t;
  }
}

void dec2hex(int n, char x[]) {
  int i = 0;
  const char charsafter10[] = "ABCDEF";
  while (n != 0) {
    int b = n % 16;
    n = n / 16;
    if (b < 10) {
      x[i++] = b + '0';
    } else {
      x[i++] = charsafter10[b - 10];
    }
  }
  x[i] = '\0';
  reverse(x);
}

int main(void) {
  char s[100];
  int funny[] = {64206, 48879, 12648430, 64222, 61453};
  for (int i = 0; i < 5; i++) {
    dec2hex(funny[i], s);
    printf("Decimal: %d Hexadecimal: %s\n", funny[i], s);
  }
  return 0;
}

Η εκτέλεση του προγράμματος θα δώσει την ακόλουθη έξοδο:

Decimal: 64206 Hexadecimal: FACE
Decimal: 48879 Hexadecimal: BEEF
Decimal: 12648430 Hexadecimal: C0FFEE
Decimal: 64222 Hexadecimal: FADE
Decimal: 61453 Hexadecimal: F00D

8.8 Ασκήσεις

Άσκηση 1
Να γραφεί πρόγραμμα που να διαβάζει από το πληκτρολόγιο ένα αλφαριθμητικό και να αντικαθιστά κάθε σύμβολο με το επόμενό του στον ASCII πίνακα. Για παράδειγμα με είσοδο το "ABC123" θα πρέπει να δημιουργεί το αλφαριθμητικό "BCD234".

Λύση άσκησης 1

#include <stdio.h>
#include <string.h>

void replace_with_next_ascii(char *str) {
    for (int i = 0; str[i] != '\0'; i++) {
        str[i] = str[i] + 1;
    }
}

int main(void) {
    char string[100]; 

    printf("Enter a string: "); 
    fgets(string, sizeof(string), stdin); 
    string[strcspn(string, "\n")] = '\0'; // Αφαιρούμε τον χαρακτήρα νέας γραμμής
    replace_with_next_ascii(string); 
    printf("Modified string: %s\n", string);
    return 0;
}

Άσκηση 2
Να γραφεί πρόγραμμα που να διαβάζει δύο αλφαριθμητικά και να εμφανίζει το πλήθος των χαρακτήρων που είναι κοινά και στα δύο.

Λύση άσκησης 2

#include <stdio.h>
#include <string.h>

// Υπολογίζει τον αριθμό των κοινών χαρακτήρων μεταξύ δύο αλφαριθμητικών
int count_common_chars(const char *str1, const char *str2) {
  int common_chars = 0;
  for (int i = 0; str1[i] != '\0'; i++) {
    for (int j = 0; str2[j] != '\0'; j++) {
      if (str1[i] == str2[j]) {
        common_chars++;
        break;
      }
    }
  }
  return common_chars;
}

int main(void) {
  char str1[100], str2[100];
  printf("Enter first string: ");
  fgets(str1, sizeof(str1), stdin);
  str1[strcspn(str1, "\n")] =
      '\0'; // Αφαιρεί το newline που προστίθεται από το fgets

  printf("Enter second string: ");
  fgets(str2, sizeof(str2), stdin);
  str2[strcspn(str2, "\n")] =
      '\0'; // Αφαιρεί το newline που προστίθεται από το fgets

  printf("Common characters: %d\n", count_common_chars(str1, str2));
  return 0;
}

Άσκηση 3
Nα γραφεί συνάρτηση που να δέχεται ως όρισμα ένα αλφαριθμητικό και έναν χαρακτήρα και να αντικαθιστά στο αλφαριθμητικό κάθε εμφάνιση του χαρακτήρα με το 'Χ'.

Λύση άσκησης 3

#include <stdio.h>
#include <string.h>

// Υπολογίζει τον αριθμό των κοινών χαρακτήρων μεταξύ δύο αλφαριθμητικών
int count_common_chars(const char *str1, const char *str2) {
  int common_chars = 0;
  for (int i = 0; str1[i] != '\0'; i++) {
    for (int j = 0; str2[j] != '\0'; j++) {
      if (str1[i] == str2[j]) {
        common_chars++;
        break;
      }
    }
  }
  return common_chars;
}

int main(void) {
  char str1[100], str2[100];
  printf("Enter first string: ");
  fgets(str1, sizeof(str1), stdin);
  str1[strcspn(str1, "\n")] =
      '\0'; // Αφαιρεί το newline που προστίθεται από το fgets

  printf("Enter second string: ");
  fgets(str2, sizeof(str2), stdin);
  str2[strcspn(str2, "\n")] =
      '\0'; // Αφαιρεί το newline που προστίθεται από το fgets

  printf("Common characters: %d\n", count_common_chars(str1, str2));
  return 0;
}

Άσκηση 4
Να γραφεί συνάρτηση που να δέχεται ως όρισμα ένα αλφαριθμητικό και μια θέση και να διαγράφει τον χαρακτήρα σε εκείνη τη θέση ολισθαίνοντας όλους τους μετέπειτα χαρακτήρες του αλφαριθμητικού προς τα αριστερά.

Λύση άσκησης 4

#include <stdio.h>
#include <string.h>

// Υπολογίζει τον αριθμό των κοινών χαρακτήρων μεταξύ δύο αλφαριθμητικών
int count_common_chars(const char *str1, const char *str2) {
  int common_chars = 0;
  for (int i = 0; str1[i] != '\0'; i++) {
    for (int j = 0; str2[j] != '\0'; j++) {
      if (str1[i] == str2[j]) {
        common_chars++;
        break;
      }
    }
  }
  return common_chars;
}

int main(void) {
  char str1[100], str2[100];
  printf("Enter first string: ");
  fgets(str1, sizeof(str1), stdin);
  str1[strcspn(str1, "\n")] =
      '\0'; // Αφαιρεί το newline που προστίθεται από το fgets

  printf("Enter second string: ");
  fgets(str2, sizeof(str2), stdin);
  str2[strcspn(str2, "\n")] =
      '\0'; // Αφαιρεί το newline που προστίθεται από το fgets

  printf("Common characters: %d\n", count_common_chars(str1, str2));
  return 0;
}

---

1. cppreference.com, η συνάρτηση gets().https://en.cppreference.com/w/c/io/gets. Accessed: 2023-06-01. ↩