Στη γλώσσα C, οι συμβολοσειρές αναπαριστούνται ως πίνακες χαρακτήρων (character arrays) με τον τελευταίο χαρακτήρα να είναι ο χαρακτήρας τερματισμού συμβολοσειράς ('\0'). Η σύμβαση για τον ορισμό μιας συμβολοσειράς στη C είναι η ακόλουθη:
char str[] = "Hello, World!";
Στο παραπάνω παράδειγμα, η μεταβλητή str είναι ένας πίνακας χαρακτήρων που περιέχει τη συμβολοσειρά “Hello, World!”. Ο τερματισμός της συμβολοσειράς γίνεται με τον ειδικό χαρακτήρα '\0' που προστίθεται αυτόματα από τον μεταγλωττιστή.
Οι συμβολοσειρές μπορούν να εκτυπωθούν στην οθόνη χρησιμοποιώντας τη συνάρτηση printf και την ακόλουθη μορφή δείκτη %s:
char str[] = "Hello, World!";
printf("Message: %s", str);
Η έξοδος στην οθόνη θα είναι:
Message: Hello, World!
Έτσι, οι συμβολοσειρές στη γλώσσα C αποτελούνται από πίνακες χαρακτήρων και μπορούν να εκτυπωθούν χρησιμοποιώντας τη συνάρτηση printf.
Να σημειωθεί ότι πρέπει να χρησιμοποιήσετε διπλά εισαγωγικά (“”).
Για να εξαγάγετε τη συμβολοσειρά, μπορείτε να χρησιμοποιήσετε τη συνάρτηση printf () μαζί με τον καθοριστή μορφής% s για να ενημερώσετε τη C ότι τώρα εργαζόμαστε με συμβολοσειρές:
char myString[12] = "Hello World";
printf("My string is: %s", myString);
Στο παραπάνω παράδειγμα, χρησιμοποιείται η συνάρτηση printf () για να εμφανίσει τη συμβολοσειρά myString στην οθόνη. Ο καθοριστής μορφής% s χρησιμοποιείται για να πείτε στη C ότι αντί για έναν αριθμό, θα εμφανίσετε μια συμβολοσειρά.
Δεδομένου ότι οι συμβολοσειρές είναι πραγματικά πίνακες στη C, μπορείτε να αποκτήσετε πρόσβαση σε μια συμβολοσειρά αναφερόμενοι στον αριθμό δείκτη του μέσα σε αγκύλες [].
Στο παρακάτω παράδειγμα εκτυπώνεται ο πρώτος χαρακτήρας (0) στη συμβολοσειρά greetings:
char greetings[6] = "Hello";
printf("The first character in the greetings string is: %c", greetings[0]);
Στο παραπάνω παράδειγμα, η συμβολοσειρά greetings περιέχει το κείμενο “Hello”. Με τη χρήση του greetings[0] εκτυπώνεται ο πρώτος χαρακτήρας της συμβολοσειράς “H”.
[adinserter block=”2″]
Για να αλλάξετε την τιμή ενός συγκεκριμένου χαρακτήρα σε μια συμβολοσειρά, αναφερθείτε στον αριθμό δείκτη και χρησιμοποιήστε μονά εισαγωγικά:
Παράδειγμα:
#include <stdio.h>
int main() {
char greetings[6] = "Hello"; // Δημιουργία πίνακα χαρακτήρων με την αρχική τιμή "Hello"
greetings[0] = 'J'; // Αλλαγή του πρώτου χαρακτήρα σε 'J'
printf("The new string is: %s", greetings); // Εκτύπωση του νέου πίνακα χαρακτήρων
return 0;
}
Ο παραπάνω κώδικας σε C αλλάζει τον πρώτο χαρακτήρα του πίνακα greetings από ‘H’ σε ‘J’ και στη συνέχεια εκτυπώνει τον νέο πίνακα χαρακτήρων. Ο πίνακας greetings περιλαμβάνει 6 θέσεις μνήμης για τους χαρακτήρες του κειμένου “Hello”, με την τελευταία θέση να προστίθεται για τον τερματισμό του πίνακα με έναν ειδικό χαρακτήρα null. Ο κώδικας εκτυπώνει τη νέα τιμή του πίνακα greetings, που είναι “Jello”, με τη χρήση της συνάρτησης printf.
Μπορείτε επίσης να διασχίσετε τους χαρακτήρες μιας συμβολοσειράς, χρησιμοποιώντας έναν βρόχο for:
Παράδειγμα:
#include <stdio.h>
int main() {
char greetings[6] = "Hello"; // Δήλωση και αρχικοποίηση ενός πίνακα χαρακτήρων με το κείμενο "Hello"
int i;
for (i = 0; i < 5; i++) {
printf("%c\n", greetings[i]); // Εκτύπωση του κάθε χαρακτήρα του πίνακα χρησιμοποιώντας τη συνάρτηση printf
}
return 0; // Επιστροφή της τιμής 0 ως ένδειξη επιτυχίας του προγράμματος
}
Ο κώδικας αυτός εκτυπώνει τους χαρακτήρες του πίνακα greetings έναν προς έναν. Αρχικά, δηλώνονται ο πίνακας greetings που περιέχει το κείμενο “Hello” και η μεταβλητή i. Στη συνέχεια, χρησιμοποιείται ο βρόχος for για να επαναληφθεί η εκτέλεση του κομματιού κώδικα μέσα στον βρόχο για τις τιμές του i από 0 έως 4. Κάθε φορά, η συνάρτηση printf εκτυπώνει τον χαρακτήρα του πίνακα greetings που αντιστοιχεί στην τρέχουσα θέση του i. Τελικά, η εκτέλεση τερματίζεται και το πρόγραμμα επιστρέφει την τιμή 0, υποδεικνύοντας επιτυχή ολοκλήρωση.
Αν εκτελέσετε τον παραπάνω κώδικα σε ένα περιβάλλον που υποστηρίζει τη γλώσσα C, το αποτέλεσμα στην οθόνη θα είναι:
H e l l o
Κάθε χαρακτήρας του πίνακα greetings θα εκτυπωθεί σε μια νέα γραμμή, καθώς ο κώδικας περιλαμβάνει την εντολή printf("%c\n", greetings[i]);, όπου %c αναφέρεται σε έναν χαρακτήρα και \n προκαλεί μια νέα γραμμή μετά από κάθε εκτύπωση.
Πρέπει επίσης να σημειώσετε ότι μπορείτε να δημιουργήσετε μια συμβολοσειρά με ένα σύνολο χαρακτήρων. Το παρακάτω παράδειγμα θα δημιουργήσει το ίδιο αποτέλεσμα με το παράδειγμα στην αρχή αυτής της σελίδας:
Παράδειγμα:
char greetings[6] = {'H', 'e', 'l', 'l', 'o', 'char greetings[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("The string is: %s", greetings);'};
printf("The string is: %s", greetings);
Στο παραπάνω παράδειγμα, η συμβολοσειρά greetings δημιουργείται με ένα σύνολο χαρακτήρων. Η μεταβλητή greetings αποτελείται από έναν πίνακα χαρακτήρων με μέγεθος 6. Ο τελευταίος χαρακτήρας του πίνακα είναι ο χαρακτήρας ‘\0’, ο οποίος χρησιμοποιείται για να δείξει ότι η συμβολοσειρά έχει τελειώσει. Η συνάρτηση printf () χρησιμοποιείται για να εκτυπώσει τη συμβολοσειρά.
Η διαφορά μεταξύ των δύο τρόπων δημιουργίας συμβολοσειρών, είναι ότι ο πρώτος τρόπος είναι πιο εύκολος στην εγγραφή, και δεν χρειάζεται να συμπεριλάβετε τον χαρακτήρα \0, καθώς η C θα το κάνει αυτό για εσάς.
Θα πρέπει να σημειώσετε ότι το μέγεθος και των δύο πινάκων είναι το ίδιο: Και οι δύο έχουν 13 χαρακτήρες (ο κενός χώρος μετράει ως χαρακτήρας με τον τρόπο), συμπεριλαμβανομένου του χαρακτήρα \0:
Ένα παράδειγμα θα μπορούσε να είναι η δημιουργία δύο συμβολοσειρών ως εξής:
char str1[] = "Hello World";
char str2[12] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', 'char str1[] = "Hello World";
char str2[12] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0'};'};
Και οι δύο συμβολοσειρές έχουν την ίδια τιμή, αλλά η πρώτη είναι ευκολότερη στην εγγραφή, ενώ η δεύτερη σας επιτρέπει να ελέγχετε απευθείας κάθε χαρακτήρα.
[adinserter block=”3″]
Για να αναγνωρίσει η γλώσσα C τους ειδικούς χαρακτήρες στις συμβολοσειρές, μπορείτε να χρησιμοποιήσετε τον χαρακτήρα κάθετης γραμμής (backslash, ) ακολουθούμενο από έναν χαρακτήρα που καθορίζει τη σημασία του ειδικού χαρακτήρα. Ορισμένοι από τους συνηθέστερους ειδικούς χαρακτήρες στη γλώσσα C είναι:
\n: Νέα γραμμή (newline)\t: Καρτέλα (tab)\b: Πίσω κενό (backspace)\r: Επιστροφή κέρσορα (carriage return)\": Διπλά εισαγωγικά (double quote)\': Μονά εισαγωγικά (single quote)\\: Κάθετη γραμμή (backslash)
Αυτοί οι ειδικοί χαρακτήρες μπορούν να ενσωματωθούν στις συμβολοσειρές και να παρουσιαστούν με επιθυμητό τρόπο κατά την εκτέλεση του προγράμματος.
Μπορείτε να συνδυάσετε τους ειδικούς χαρακτήρες με τα κανονικά γράμματα και αριθμούς για να δημιουργήσετε συμβολοσειρές που περιέχουν ειδικούς χαρακτήρες.
Στη γλώσσα C, ο χαρακτήρας \ (backslash) χρησιμοποιείται ως χαρακτήρας διαφυγής (escape character) για να μετατρέψει ειδικούς χαρακτήρες σε χαρακτήρες στις συμβολοσειρές. Αυτό σημαίνει ότι μπορείτε να χρησιμοποιήσετε τον χαρακτήρα \ πριν από έναν ειδικό χαρακτήρα για να τον αναγνωρίσει ως μέρος της συμβολοσειράς, αντί να ερμηνευτεί ως ειδικός χαρακτήρας.
Για παράδειγμα, ο χαρακτήρας \n αναπαριστά μια νέα γραμμή, και ο χαρακτήρας \ αναπαριστά ένα backslash. Έτσι, αν θέλατε να δημιουργήσετε μια συμβολοσειρά που περιέχει ένα μονάδικο εισαγωγικό, θα μπορούσατε να το κάνετε ως εξής:
char myString[] = "This string contains a single quote: \'";
Με αυτόν τον τρόπο, η C θα αντιληφθεί ότι ο μοναδικός χαρακτήρας εισαγωγικών στη συμβολοσειρά δεν αποτελεί το τέλος της συμβολοσειράς, αλλά είναι ένας χαρακτήρας της συμβολοσειράς.
Το string.h είναι ένα από τα βασικά header αρχεία της γλώσσας C που περιλαμβάνει πολλές χρήσιμες συναρτήσεις για τις συμβολοσειρές.
Ας δούμε μερικές από τις βασικές συναρτήσεις συμβολοσειρών στη C:
strlen(): Επιστρέφει το μήκος μιας συμβολοσειράς.strcpy(): Αντιγράφει τη μια συμβολοσειρά σε μια άλλη.strcat(): Συνενώνει δύο συμβολοσειρές σε μία.strcmp(): Συγκρίνει δύο συμβολοσειρές και επιστρέφει μια τιμή που δείχνει αν είναι ίσες ή όχι.strstr(): Βρίσκει την πρώτη εμφάνιση ενός υποσυνόλου σε μια συμβολοσειρά.
Ας δούμε ένα παράδειγμα για τη χρήση της συνάρτησης strlen():
#include <stdio.h>
#include <string.h>
int main() {
char myString[20] = "Hello, world!";
int length = strlen(myString); // Υπολογισμός μήκους της συμβολοσειράς
printf("The length of the string is: %d", length); // Εκτύπωση του μήκους στην οθόνη
return 0;
}
Ο κώδικας υπολογίζει το μήκος μιας συμβολοσειράς και το εκτυπώνει στην οθόνη. Ακολουθεί μια αναλυτική περιγραφή του κώδικα:
- Οι δηλώσεις
#include <stdio.h>και#include <string.h>εισάγουν τις απαραίτητες βιβλιοθήκες για την είσοδο/έξοδο και την επεξεργασία συμβολοσειρών αντίστοιχα. - Η συνάρτηση
mainείναι η κύρια συνάρτηση του προγράμματος που περιέχει τον εκτελέσιμο κώδικα. - Ορίζεται ένας πίνακας χαρακτήρων
myStringμε χωρητικότητα 20 και αρχική τιμή “Hello, world!”. - Η συνάρτηση
strlenχρησιμοποιείται για να υπολογιστεί το μήκος της συμβολοσειράςmyStringκαι αποθηκεύεται στη μεταβλητήlength. - Η συνάρτηση
printfχρησιμοποιείται για να εκτυπωθεί το μήνυμα “The length of the string is: ” ακολουθούμενο από την τιμή της μεταβλητήςlength. - Το πρόγραμμα τερματίζει με την εντολή
return 0;, η οποία υποδεικνύει ότι το πρόγραμμα ολοκληρώθηκε με επιτυχία.
Το αποτέλεσμα που θα εμφανιστεί στην οθόνη είναι:
The length of the string is: 13
Η συνάρτηση strlen() επιστρέφει το μήκος μιας συμβολοσειράς. Ας δούμε ένα παράδειγμα:
#include <stdio.h>
#include <string.h>
int main() {
char myString[20] = "Hello, world!"; // Δημιουργία ενός πίνακα χαρακτήρων με την αρχική τιμή "Hello, world!"
int length = strlen(myString); // Υπολογισμός του μήκους του πίνακα χαρακτήρων με τη χρήση της συνάρτησης strlen()
printf("The length of the string is: %d", length); // Εκτύπωση του μήκους του πίνακα χαρακτήρων
return 0;
}
Ο παραπάνω κώδικας γράφει το μήνυμα “Hello, world!” σε έναν πίνακα χαρακτήρων myString. Στη συνέχεια, χρησιμοποιεί τη συνάρτηση strlen() για να υπολογίσει το μήκος του πίνακα myString. Το μήκος αποθηκεύεται στη μεταβλητή length. Τέλος, η εντολή printf() εκτυπώνει το μήκος του πίνακα με τη χρήση του μηνύματος “The length of the string is: ” που ακολουθείται από την τιμή της μεταβλητής length.
Αυτός ο κώδικας θα εκτυπώσει το μήκος της συμβολοσειράς “Hello, world!”, δηλαδή 13.
Η συνάρτηση sizeof() χρησιμοποιείται για να επιστρέψει το μέγεθος μιας μεταβλητής ή ενός πίνακα σε bytes. Είναι σημαντικό να σημειωθεί ότι η sizeof() συμπεριλαμβάνει και τον χαρακτήρα \0 που χρησιμοποιείται για να σηματοδοτήσει το τέλος της συμβολοσειράς, ενώ η συνάρτηση strlen() δεν τον υπολογίζει στο μήκος της συμβολοσειράς.
[adinserter block=”4″]
Είναι σημαντικό να γνωρίζει κάποιος τη διαφορά μεταξύ του μήκους ενός πίνακα χαρακτήρων και του μεγέθους της αντίστοιχης συμβολοσειράς. Αυτή η διαφορά μπορεί να προκαλέσει προβλήματα κατά την ανάγνωση ή εγγραφή συμβολοσειρών στη μνήμη. Επιπλέον, μπορεί να επηρεάσει το μέγεθος του αντίστοιχου πίνακα που χρησιμοποιείται για να αποθηκεύσει τη συμβολοσειρά. Κατά τη δήλωση ενός πίνακα χαρακτήρων, το μέγεθος του πίνακα πρέπει να είναι αρκετά μεγάλο για να χωρέσει τη συμβολοσειρά καθώς και τον τερματιστικό χαρακτήρα ‘\0’. Αν ο πίνακας δεν είναι αρκετά μεγάλος, μπορεί να προκληθούν προβλήματα όταν γίνεται αντιγραφή ή επεξεργασία της συμβολοσειράς.
Ας δούμε ένα παράδειγμα για να καταλάβουμε τη διαφορά μεταξύ της συνάρτησης sizeof() και strlen():
#include <stdio.h>
#include <string.h>
int main() {
char myString[] = "Hello"; // Δήλωση ενός πίνακα χαρακτήρων με την αρχική τιμή "Hello"
int size = sizeof(myString); // Υπολογισμός του μεγέθους του πίνακα χαρακτήρων
int length = strlen(myString); // Υπολογισμός του μήκους του πίνακα χαρακτήρων
printf("The size of the string is: %d\n", size); // Εκτύπωση του μεγέθους του πίνακα χαρακτήρων
printf("The length of the string is: %d\n", length); // Εκτύπωση του μήκους του πίνακα χαρακτήρων
return 0;
}
Ο παραπάνω κώδικας γράφεται σε C και πραγματοποιεί τις εξής ενέργειες:
- Συμπεριλαμβάνει τις απαραίτητες βιβλιοθήκες για τη χρήση των συναρτήσεων
printfκαιstrlen. - Δηλώνει έναν πίνακα χαρακτήρων με την αρχική τιμή “Hello”.
- Υπολογίζει το μέγεθος του πίνακα χαρακτήρων με τη χρήση της συνάρτησης
sizeof. - Υπολογίζει το μήκος του πίνακα χαρακτήρων με τη χρήση της συνάρτησης
strlen. - Εκτυπώνει το μέγεθος του πίνακα χαρακτήρων χρησιμοποιώντας τη συνάρτηση
printf. - Εκτυπώνει το μήκος του πίνακα χαρακτήρων χρησιμοποιώντας τη συνάρτηση
printf. - Επιστρέφει την τιμή 0 για να υποδηλώσει επιτυχή ολοκλήρωση του προγράμματος.
Η παραπάνω εφαρμογή θα εκτυπώσει:
The size of the string is: 6 The length of the string is: 5
Παρατηρούμε ότι το μέγεθος της συμβολοσειράς είναι 6, ενώ το μήκος της συμβολοσειράς είναι 5. Αυτό συμβαίνει επειδή το μέγεθος του πίνακα που χρησιμοποιείται για να αποθηκεύσει τη συμβολοσειρά περιλαμβάνει επίσης τον χαρακτήρα \0 που χρησιμοποιείται για να σηματοδοτήσει το τέλος της συμβολοσειράς.
Για να συνενώσετε (concatenate) δύο συμβολοσειρές στη C, μπορείτε να χρησιμοποιήσετε τη συνάρτηση strcat().
Η συνάρτηση strcat() δέχεται δύο ορίσματα: την πρώτη συμβολοσειρά στην οποία θέλετε να προσθέσετε τη δεύτερη συμβολοσειρά. Η δεύτερη συμβολοσειρά προστίθεται στο τέλος της πρώτης συμβολοσειράς. Η πρώτη συμβολοσειρά πρέπει να έχει αρκετό χώρο για να χωρέσει τη δεύτερη συμβολοσειρά, συμπεριλαμβανομένου του τελικού χαρακτήρα \0 που σηματοδοτεί το τέλος της συμβολοσειράς.
Δείτε ένα παράδειγμα:
#include <stdio.h>
#include <string.h>
int main() {
char str1[20] = "Hello"; // Δήλωση και αρχικοποίηση του πρώτου πίνακα χαρακτήρων
char str2[20] = " World"; // Δήλωση και αρχικοποίηση του δεύτερου πίνακα χαρακτήρων
strcat(str1, str2); // Συνένωση των δύο πινάκων χαρακτήρων
printf("%s\n", str1); // Εκτύπωση του συνενωμένου πίνακα χαρακτήρων
return 0;
}
Ο κώδικας αυτός σε γλώσσα C συνενώνει δύο πίνακες χαρακτήρων str1 και str2 χρησιμοποιώντας τη συνάρτηση strcat(). Η strcat() επικολλά το περιεχόμενο του str2 στο τέλος του str1. Στη συνέχεια, με τη χρήση της printf() εκτυπώνεται το συνενωμένο αποτέλεσμα str1.
Η παραπάνω εφαρμογή θα εκτυπώσει:
Hello World
Παρατηρούμε ότι η συνάρτηση strcat() προσθέτει τη δεύτερη συμβολοσειρά (” World”) στο τέλος της πρώτης συμβολοσειράς (“Hello”), και εκτυπώνει την πλήρη συμβολοσειρά “Hello World”.
Για να αντιγράψετε την τιμή μιας συμβολοσειράς σε μια άλλη, μπορείτε να χρησιμοποιήσετε τη συνάρτηση strcpy().
[adinserter block=”5″]
Η συνάρτηση strcpy() χρησιμοποιείται για την αντιγραφή μιας συμβολοσειράς πηγής σε μια συμβολοσειρά προορισμού. Απαιτεί δύο ορίσματα: τη συμβολοσειρά προορισμού και τη συμβολοσειρά πηγής. Η τιμή της συμβολοσειράς πηγής αντιγράφεται στη συμβολοσειρά προορισμού. Πρέπει να εξασφαλιστεί ότι η συμβολοσειρά προορισμού έχει αρκετό χώρο για να χωρέσει τη συμβολοσειρά πηγής, συμπεριλαμβανομένου του τελικού χαρακτήρα \0 που σηματοδοτεί το τέλος της συμβολοσειράς.
Αναλυτικότερα, η συνάρτηση strcpy() προσπελαύνει τους χαρακτήρες της συμβολοσειράς πηγής έναν έναν και τους αντιγράφει στην αντίστοιχη θέση της συμβολοσειράς προορισμού, μέχρι να εντοπίσει τον τελικό χαρακτήρα \0. Έπειτα, προσθέτει τον τελικό χαρακτήρα \0 στο τέλος της συμβολοσειράς προορισμού για να σηματοδοτήσει το τέλος της.
Είναι σημαντικό να προσέξουμε ότι η συμβολοσειρά προορισμού πρέπει να έχει αρκετό μέγεθος για να χωρέσει την πλήρη συμβολοσειρά πηγής, διαφορετικά μπορεί να προκληθεί υπέρβαση των ορίων μνήμης (buffer overflow).
Παράδειγμα:
#include <stdio.h>
#include <string.h>
int main() {
char str1[20] = "Hello"; // Δημιουργία ενός πίνακα χαρακτήρων str1 με χωρητικότητα 20 και αρχική τιμή "Hello"
char str2[20]; // Δημιουργία ενός κενού πίνακα χαρακτήρων str2 με χωρητικότητα 20
strcpy(str2, str1); // Αντιγραφή της περιεχομένης του πίνακα str1 στον πίνακα str2
printf("%s\n", str2); // Εκτύπωση του περιεχομένου του πίνακα str2
return 0; // Ολοκλήρωση του προγράμματος
}
Ο παραπάνω κώδικας σε C αντιγράφει το περιεχόμενο του πίνακα str1 στον πίνακα str2 χρησιμοποιώντας τη συνάρτηση strcpy. Η συνάρτηση strcpy αντιγράφει το περιεχόμενο ενός πίνακα χαρακτήρων σε έναν άλλο πίνακα. Στη συνέχεια, χρησιμοποιείται η συνάρτηση printf για να εκτυπωθεί το περιεχόμενο του πίνακα str2. Η εντολή printf("%s\n", str2) χρησιμοποιείται για την εκτύπωση ενός αλφαριθμητικού (πίνακα χαρακτήρων) στην οθόνη, με την αντικατάσταση του %s από το περιεχόμενο του πίνακα str2. Τέλος, ο κώδικας επιστρέφει την τιμή 0, υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε με επιτυχία.
Η παραπάνω εφαρμογή θα εκτυπώσει:
Hello
Παρατηρούμε ότι η συνάρτηση strcpy() αντιγράφει την τιμή της συμβολοσειράς προέλευσης (“Hello”) στη συμβολοσειρά προορισμού (str2), και εκτυπώνει τη συμβολοσειρά προορισμού.
Για να συγκρίνετε δύο αλφαριθμητικά στη C, μπορείτε να χρησιμοποιήσετε τη συνάρτηση strcmp().
Η συνάρτηση αυτή επιστρέφει την τιμή 0 εάν τα δύο αλφαριθμητικά είναι ίσα, διαφορετικά επιστρέφει μια τιμή που δεν είναι 0.
Ας δούμε ένα παράδειγμα χρησιμοποιώντας τη συνάρτηση strcmp() στη C:
#include <stdio.h>
#include <string.h>
int main() {
char str1[20] = "Hello";
char str2[20] = "World";
// Σύγκριση των δύο συμβολοσειρών
if (strcmp(str1, str2) == 0) {
printf("The two strings are equal\n");
}
else {
printf("The two strings are not equal\n");
}
return 0;
}
Ο παραπάνω κώδικας σε C πραγματοποιεί τη σύγκριση δύο συμβολοσειρών str1 και str2 χρησιμοποιώντας τη συνάρτηση strcmp από τη βιβλιοθήκη string.h.
Αρχικά, ορίζονται δύο πίνακες χαρακτήρων str1 και str2, οι οποίοι περιέχουν τις συμβολοσειρές “Hello” και “World” αντίστοιχα.
Έπειτα, γίνεται έλεγχος εάν οι δύο συμβολοσειρές είναι ίδιες με τη χρήση της συνάρτησης strcmp. Η strcmp επιστρέφει 0 αν οι δύο συμβολοσειρές είναι ίδιες.
Αν οι συμβολοσειρές είναι ίδιες, εκτυπώνεται το μήνυμα “The two strings are equal” στην οθόνη. Αν δεν είναι ίδιες, εκτυπώνεται το μήνυμα “The two strings are not equal”.
Στο τέλος, η main συνάρτηση επιστρέφει την τιμή 0, υποδηλώνοντας ότι ο κώδικας εκτελέστηκε χωρίς σφάλματα.
Αν εκτελέσετε τον παραπάνω κώδικα, το αποτέλεσμα που θα εμφανιστεί στην οθόνη θα εξαρτηθεί από τη συγκεκριμένη υλοποίηση της γλώσσας C που χρησιμοποιείτε.
Αν οι δύο συμβολοσειρές str1 και str2 είναι ίδιες, τότε το αποτέλεσμα που θα εμφανιστεί στην οθόνη θα είναι:
The two strings are equal
Αν οι δύο συμβολοσειρές δεν είναι ίδιες, τότε το αποτέλεσμα που θα εμφανιστεί στην οθόνη θα είναι:
The two strings are not equal
Ανάλογα με το αν οι συμβολοσειρές είναι ίδιες ή όχι, το αποτέλεσμα θα διαφέρει.