Πράξεις C με συμβολοσειρά. Χορδές σε C. Εισαγωγή

Σε ένα πρόγραμμα, οι συμβολοσειρές μπορούν να οριστούν ως εξής:

• ως σταθερές συμβολοσειράς.
• ως πίνακες χαρακτήρων?
• μέσω ενός δείκτη σε έναν τύπο χαρακτήρα.
• σαν συστοιχίες χορδών.

Επιπλέον, πρέπει να παρέχεται εκχώρηση μνήμης για την αποθήκευση της συμβολοσειράς.

Οποιαδήποτε ακολουθία χαρακτήρων που περικλείεται σε διπλά εισαγωγικά "" αντιμετωπίζεται ως σταθερά χορδής.

Για σωστή έξοδο, οποιαδήποτε συμβολοσειρά πρέπει να τελειώνει με τον μηδενικό χαρακτήρα "\0", η ακέραια τιμή του οποίου είναι 0. Όταν δηλώνετε μια συμβολοσειρά σταθερή, ο μηδενικός χαρακτήρας προστίθεται αυτόματα σε αυτήν. Έτσι, μια ακολουθία χαρακτήρων, η οποία είναι μια σταθερά συμβολοσειράς, θα τοποθετηθεί στη μνήμη RAM του υπολογιστή, συμπεριλαμβανομένου του μηδενικού byte.

Διαδοχικά κελιά RAM εκχωρούνται για την αποθήκευση της συμβολοσειράς. Άρα μια συμβολοσειρά είναι μια σειρά χαρακτήρων. Εκχωρείται 1 byte για την αποθήκευση του κώδικα κάθε χαρακτήρα στη συμβολοσειρά.

Για να τοποθετηθούν ορισμένοι χαρακτήρες υπηρεσίας σε μια σταθερά συμβολοσειράς, χρησιμοποιούνται συνδυασμοί χαρακτήρων. Επομένως, εάν χρειάζεται να συμπεριλάβετε έναν χαρακτήρα διπλού εισαγωγικού σε μια συμβολοσειρά, πρέπει να προηγείται ένας χαρακτήρας ανάστροφης κάθετο: ‘\”’ .

Οι σταθερές συμβολοσειράς βρίσκονται στη στατική μνήμη. Η αρχική διεύθυνση μιας ακολουθίας χαρακτήρων σε διπλά εισαγωγικά αντιμετωπίζεται ως διεύθυνση μιας συμβολοσειράς. Οι σταθερές συμβολοσειράς χρησιμοποιούνται συχνά για να παρέχουν αλληλεπίδραση χρήστη σε συναρτήσεις όπως η printf().

Κατά τον καθορισμό πίνακας χαρακτήρωνπρέπει να πείτε στον μεταγλωττιστή το απαιτούμενο μέγεθος μνήμης.

char m;

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

char m2=;
char m3=( "T", "i", "x", "i", "e", ", "d", "o", "l", "i", "n", "s", ", "p ", "o", "l", "n", "y", ", "s", "v", "e", "zh", "e", "y", ", "m", "g", "l", "o", "y", "\0"};

Σε αυτήν την περίπτωση, τα ονόματα m2 και m3 είναι δείκτες στα πρώτα στοιχεία των πινάκων:

• m2 ισοδυναμεί με &m2
• m2 ισοδυναμεί με "G"
• m2 ισοδυναμεί με "o"
• m3 ισοδυναμεί με &m3
• m3 ισοδυναμεί με 'x'

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

char m2= «Οι βουνοκορφές κοιμούνται στο σκοτάδι της νύχτας».;

Για να ορίσετε μια συμβολοσειρά μπορείτε να χρησιμοποιήσετε δείκτη προς τον τύπο χαρακτήρα.

char *m4;

Σε αυτήν την περίπτωση, κατά τη δήλωση ενός πίνακα, στη μεταβλητή m4 μπορεί να εκχωρηθεί η διεύθυνση του πίνακα:

m4 = m3;
*m4 ισοδυναμεί με m3="T"
*(m4+1) ισοδυναμεί με m3="and"

Εδώ το m3 είναι μια σταθερά δείκτη. Δεν μπορείτε να αλλάξετε το m3, καθώς αυτό θα σήμαινε αλλαγή της θέσης (διεύθυνσης) του πίνακα στη μνήμη, σε αντίθεση με το m4.

Για έναν δείκτη, μπορείτε να χρησιμοποιήσετε τη λειτουργία αύξησης (μεταβείτε στον επόμενο χαρακτήρα):

Πίνακες συμβολοσειρών χαρακτήρων

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

χαρ *ποιητής = ( "Ο ποιητής πέθανε!", "- ένας σκλάβος της τιμής -",
"Έπεσε", "συκοφαντήθηκε από φήμες..."};

Σε αυτήν την περίπτωση, ο ποιητής είναι ένας πίνακας που αποτελείται από τέσσερις δείκτες σε συμβολοσειρές χαρακτήρων. Κάθε συμβολοσειρά χαρακτήρων είναι ένας πίνακας χαρακτήρων, επομένως υπάρχουν τέσσερις δείκτες πίνακα. Ο δείκτης ποιητής αναφέρεται στην πρώτη γραμμή:
*ποιητήςισοδύναμος "Π",
*ποιητής[l]ισοδύναμος "-" .

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

char ποιητής?

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

Δωρεάν συστοιχία

Περιγραφή

char *poet;

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

Λειτουργίες συμβολοσειρών

Οι περισσότερες πράξεις C που ασχολούνται με συμβολοσειρές λειτουργούν με δείκτες. Για να τοποθετήσετε μια σειρά χαρακτήρων στη μνήμη RAM, πρέπει:

• να διαθέσει ένα μπλοκ μνήμης RAM για τον πίνακα.
• αρχικοποιήστε τη συμβολοσειρά.

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

όνομα χαρακτήρα;
όνομα = (char *)malloc(10);
scanf("%9s" , όνομα);

Η συνάρτηση scanf() χρησιμοποιείται για την εισαγωγή μιας συμβολοσειράς και η συμβολοσειρά που εισάγεται δεν μπορεί να υπερβαίνει τους 9 χαρακτήρες. Ο τελευταίος χαρακτήρας θα περιέχει "\0" .

Λειτουργίες εισαγωγής συμβολοσειράς

Η συνάρτηση scanf() μπορεί να χρησιμοποιηθεί για την εισαγωγή μιας συμβολοσειράς. Ωστόσο, η scanf() έχει σχεδιαστεί για να ανακτά μια λέξη αντί για μια συμβολοσειρά. Εάν χρησιμοποιείτε τη μορφή "%s" για εισαγωγή, η γραμμή εισάγεται πριν (αλλά δεν περιλαμβάνει) τον επόμενο κενό χαρακτήρα, ο οποίος μπορεί να είναι κενό, καρτέλα ή νέα γραμμή.

Για να εισαγάγετε μια συμβολοσειρά, συμπεριλαμβανομένων των διαστημάτων, χρησιμοποιήστε τη συνάρτηση

char * παίρνει (char *);

ή το αντίστοιχο

char * gets_s(char *);

Ένας δείκτης στη συμβολοσειρά που θα εισαχθεί μεταβιβάζεται ως όρισμα στη συνάρτηση. Η συνάρτηση ζητά από το χρήστη να εισαγάγει μια συμβολοσειρά, την οποία τοποθετεί σε έναν πίνακα μέχρι να πατήσει ο χρήστης Εισαγω.

Λειτουργίες εξόδου συμβολοσειράς

Για την έξοδο συμβολοσειρών, μπορείτε να χρησιμοποιήσετε τη συνάρτηση που συζητήσαμε προηγουμένως

printf("%s" , str); // str - δείκτης σε συμβολοσειρά

ή σε συντομευμένη μορφή

printf(str);

Η συνάρτηση μπορεί επίσης να χρησιμοποιηθεί για την έξοδο συμβολοσειρών

int puts (char *s);

που εκτυπώνει τη συμβολοσειρά s και μετακινεί τον κέρσορα σε νέα γραμμή (σε αντίθεση με την printf() ). Η συνάρτηση puts() μπορεί επίσης να χρησιμοποιηθεί για την έξοδο σταθερών συμβολοσειρών που περικλείονται σε εισαγωγικά.

Λειτουργία εισαγωγής χαρακτήρων

Η συνάρτηση μπορεί να χρησιμοποιηθεί για την εισαγωγή χαρακτήρων

char getchar();

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

Λειτουργία εξόδου χαρακτήρων

Η συνάρτηση μπορεί να χρησιμοποιηθεί για την έξοδο χαρακτήρων

char putchar(char);

που επιστρέφει την τιμή του χαρακτήρα που θα εκτυπωθεί και εκτυπώνει τον χαρακτήρα που μεταβιβάστηκε ως όρισμα στην οθόνη.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#περιλαμβάνω
#περιλαμβάνω
#περιλαμβάνω
int main() (
char s, sym;
int count, i;
system("chcp 1251" );
system("cls" );
printf( "Εισαγάγετε τη συμβολοσειρά:");
gets_s(s);
printf( "Εισαγωγή χαρακτήρα:");
sym = getchar();
καταμέτρηση = 0;
για (i = 0; s[i] != "\0" ; i++)
{
αν (s[i] == sym)
count++;
}
printf("Σε γραμμή\n" );
βάζει(ες); // Έξοδος μιας συμβολοσειράς
printf("χαρακτήρας" );
putchar(sym); // Έξοδος του συμβόλου
printf( "συμβαίνει %d φορές", μετρώ);
getchar(); getchar();
επιστροφή 0;
}

Αποτέλεσμα εκτέλεσης

Κύριες λειτουργίες της τυπικής συμβολοσειράς βιβλιοθήκης.h

Οι κύριες συναρτήσεις της τυπικής συμβολοσειράς βιβλιοθήκης.h δίνονται στον πίνακα.

Λειτουργία	Περιγραφή
char *strcat(char *s1, char *s2)	προσθέτει το s2 στο s1, επιστρέφει το s1
char *strncat(char *s1, char *s2, int n)	προσθέτει το πολύ n χαρακτήρες s2 στο s1, τελειώνει τη συμβολοσειρά με "\0", επιστρέφει s1
char *strсpy(char *s1, char *s2)	αντιγράφει τη συμβολοσειρά s2 στη συμβολοσειρά s1, συμπεριλαμβανομένου του "\0", επιστρέφει το s1
); strncpy(m3, m1, 6); // δεν προσθέτει "\0" στο τέλος της γραμμής βάζει( "Αποτέλεσμα strncpy(m3, m1, 6)"); puts(m3); strcpy(m3, m1); βάζει( "Αποτέλεσμα strcpy(m3, m1)"); puts(m3); βάζει( "Το αποτέλεσμα του strcmp(m3, m1) είναι"); printf("%d" , strcmp(m3, m1)); strncat(m3, m2, 5); βάζει( "Αποτέλεσμα strncat(m3, m2, 5)"); puts(m3); strcat(m3, m2); βάζει( "Αποτέλεσμα strcat(m3, m2)"); puts(m3); βάζει( "Ο αριθμός των χαρακτήρων στη συμβολοσειρά m1 είναι strlen(m1) : "); printf("%d\n" , strlen(m1)); _strnset(m3, "f" , 7); βάζει( "Αποτέλεσμα strnset(m3, "f" , 7)"); puts(m3); _strset(m3, "k" ); βάζει( "Αποτέλεσμα strnset(m3, "k" )"); puts(m3); getchar(); επιστροφή 0; } Αποτέλεσμα εκτέλεσης

Ετικέτες: Γ γραμμές. Συστοιχία χαρακτήρων.

Χορδές σε C. Εισαγωγή.

Αυτό είναι ένα εισαγωγικό άρθρο για τις χορδές C. Μια πιο λεπτομερής περιγραφή και παραδείγματα θα έρθουν όταν μάθουμε πώς να εργαζόμαστε με τη μνήμη και τους δείκτες. Σε έναν υπολογιστή, όλες οι τιμές αποθηκεύονται ως αριθμοί. Και γραμμές επίσης, δεν υπάρχουν σύμβολα ή γράμματα εκεί. Ένας όρος είναι ένας πίνακας αριθμών. Κάθε αριθμός αντιστοιχεί σε έναν συγκεκριμένο χαρακτήρα, ο οποίος λαμβάνεται από τον πίνακα κωδικοποίησης. Όταν εμφανίζεται στην οθόνη, το σύμβολο εμφανίζεται με συγκεκριμένο τρόπο.
Πίνακες του τύπου char χρησιμοποιούνται για την αποθήκευση συμβολοσειρών. Επαναλαμβάνω για άλλη μια φορά - ο τύπος χαρακτήρων είναι αριθμητικός, αποθηκεύει ένα byte δεδομένων. Αλλά σύμφωνα με τον πίνακα κωδικοποίησης, καθένας από αυτούς τους αριθμούς σχετίζεται με έναν χαρακτήρα. Και προς την αντίθετη κατεύθυνση - κάθε χαρακτήρας καθορίζεται από τον αύξοντα αριθμό του στον πίνακα κωδικοποίησης.
Για παράδειγμα

#περιλαμβάνω #περιλαμβάνω void main() ( char c = "A"; int i = 65; printf("εμφάνιση ως char %c\n", c); printf("εμφάνιση ως int %d\n", c); printf(" εμφάνιση ως χαρακτήρας %c\n", i); printf("εμφάνιση ως χαρακτήρας %d\n", i); getch(); )

Δημιουργήσαμε δύο μεταβλητές, μία τύπου απανθρακώνω, άλλα ενθ. Το γράμμα "Α" έχει αριθμητική τιμή 65. Είναι γράμμα, όχι συμβολοσειρά, και επομένως περιβάλλεται από μονά εισαγωγικά. Μπορούμε να το εκτυπώσουμε ως γράμμα

Printf("εμφάνιση ως χαρακτήρα %c\n", c);

Στη συνέχεια θα βγει στην έξοδο
ΕΝΑ
Εάν το βγάλετε ως αριθμό, θα είναι
65
Μπορείτε να κάνετε το ίδιο με τον αριθμό 65, ο οποίος είναι αποθηκευμένος σε μια μεταβλητή όπως ενθ.
Οι ειδικοί χαρακτήρες έχουν επίσης τον δικό τους αριθμό

#περιλαμβάνω #περιλαμβάνω void main() ( printf("%c", "\a"); printf("%d", "\a"); printf("%c", 7); getch(); )

Εδώ θα «εξάγεται» πρώτα το ηχητικό σήμα, μετά η αριθμητική του τιμή και μετά πάλι το ηχητικό σήμα.
Μια συμβολοσειρά στο C είναι ένας πίνακας τύπου απανθρακώνω, το τελευταίο στοιχείο του οποίου αποθηκεύει τον τερματικό χαρακτήρα "\0". Η αριθμητική τιμή αυτού του χαρακτήρα είναι 0, οπότε μπορούμε να πούμε ότι ο πίνακας τελειώνει με μηδέν.
Για παράδειγμα

#περιλαμβάνω #περιλαμβάνω void main() ( char word; word = "A"; word = "B"; word = "C"; word = "\0"; //word = 0; ισοδύναμο με printf("%s", word) getch();

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

Word = "\0";

τότε θα βγει μια συμβολοσειρά χαρακτήρων αυθαίρετου μήκους μέχρι να συναντηθεί το πρώτο byte γεμάτο με μηδενικά.

#περιλαμβάνω #περιλαμβάνω void main() ( char word = "ABC"; char text = ("H", "E", "L", "L", "O"); printf("%s\n", word); printf ("%s", κείμενο);

Σε αυτή την περίπτωση, όλα είναι σωστά. Η συμβολοσειρά "ABC" τελειώνει σε μηδέν και αρχικοποιούμε τον πίνακα λέξεων με αυτήν. Η συμβολοσειρά κειμένου αρχικοποιείται γράμμα προς γράμμα, όλοι οι υπόλοιποι χαρακτήρες, όπως προκύπτει από το κεφάλαιο για τους πίνακες, είναι γεμάτοι με μηδενικά.

Διαβάζοντας γραμμές

Για να ζητήσετε μια συμβολοσειρά από τον χρήστη, πρέπει να δημιουργήσετε ένα buffer. Το μέγεθος της προσωρινής μνήμης πρέπει να επιλεγεί εκ των προτέρων, έτσι ώστε η εισαγόμενη λέξη να ταιριάζει σε αυτό. Κατά την ανάγνωση γραμμών, υπάρχει ο κίνδυνος ο χρήστης να εισάγει περισσότερα δεδομένα από όσα επιτρέπει η προσωρινή μνήμη. Αυτά τα δεδομένα θα διαβαστούν και θα τοποθετηθούν στη μνήμη και θα αντικαταστήσουν τις τιμές άλλων ανθρώπων. Με αυτόν τον τρόπο, μπορείτε να πραγματοποιήσετε μια επίθεση καταγράφοντας τα απαραίτητα byte, στα οποία, για παράδειγμα, αξίζει να μεταβείτε σε μια ενότητα κώδικα με ένα κακόβουλο πρόγραμμα ή να καταγράψετε δεδομένα.

#περιλαμβάνω #περιλαμβάνω void main() ( char buffer; scanf("%19s", buffer); printf("%s", buffer); getch(); )

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

#περιλαμβάνω #περιλαμβάνω void main() ( char buffer; unsigned len = 0; scanf("%127s", buffer); while (buffer != "\0") ( len++; ) printf("length(%s) == %d" , buffer, len);

Δεδομένου ότι η αριθμητική τιμή του χαρακτήρα "\0" είναι μηδέν, μπορούμε να γράψουμε

Ενώ (buffer != 0) (len++; )

Ή, ακόμα πιο κοντό

Ενώ (buffer) (len++; )

Τώρα ας γράψουμε ένα πρόγραμμα που ζητά από τον χρήστη δύο λέξεις και τις συγκρίνει

#περιλαμβάνω #περιλαμβάνω /* Το αποτέλεσμα της σύγκρισης θα είναι ο αριθμός 0 εάν οι λέξεις είναι ίσες με 1 εάν η πρώτη λέξη είναι μεγαλύτερη από τη δεύτερη σε λεξικογραφική σειρά -1 εάν η δεύτερη λέξη είναι μεγαλύτερη */ void main() ( char firstWord; / /Πρώτη λέξη char secondWord;< 128; i++) { if (firstWord[i] >secondWord[i]) ( //Περισσότερα ακόμα κι αν η δεύτερη λέξη έχει ήδη τελειώσει, γιατί //τότε τελειώνει με μηδέν cmpResult = 1; break; ) αλλιώς αν (firstWord[i]< secondWord[i]) { cmpResult = -1; break; } } printf("%d", cmpResult); getch(); }

Δεδομένου ότι κάθε γράμμα έχει μια αριθμητική αξία, μπορούν να συγκριθούν μεταξύ τους ως αριθμοί. Επιπλέον, συνήθως (αλλά όχι πάντα!) τα γράμματα στους πίνακες κωδικοποίησης ταξινομούνται αλφαβητικά. Επομένως, η ταξινόμηση κατά αριθμητική τιμή θα είναι επίσης αλφαβητική.

Το σύγχρονο πρότυπο C++ ορίζει μια κλάση με συναρτήσεις και ιδιότητες (μεταβλητές) για την οργάνωση της εργασίας με συμβολοσειρές (στην κλασική γλώσσα C δεν υπάρχουν συμβολοσειρές ως τέτοιες, υπάρχουν μόνο πίνακες χαρακτήρων χαρακτήρων):

#περιλαμβάνω

#περιλαμβάνω

#περιλαμβάνω

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

Χρήση χώρου ονομάτων std;

Διαφορετικά, θα πρέπει να καθορίσετε τον περιγραφέα κλάσης std::string παντού αντί για συμβολοσειρά .

Παρακάτω είναι ένα παράδειγμα προγράμματος που λειτουργεί με συμβολοσειρά (δεν λειτουργεί σε παλαιότερους μεταγλωττιστές συμβατούς με C!):

#περιλαμβάνω #περιλαμβάνω #περιλαμβάνω χρησιμοποιώντας namespace std? int main() ( string s = "Test"; s.insert(1,"!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->erase(s2->end()); cout<< s2->c_str(); cin.get(); επιστροφή 0; )

Τα κύρια χαρακτηριστικά που έχει η κλάση χορδών:

• προετοιμασία με μια σειρά χαρακτήρων (ενσωματωμένος τύπος συμβολοσειράς) ή άλλο αντικείμενο τύπου string . Ένας ενσωματωμένος τύπος δεν έχει τη δεύτερη δυνατότητα.
• αντιγραφή μιας γραμμής στην άλλη. Για έναν ενσωματωμένο τύπο πρέπει να χρησιμοποιήσετε τη συνάρτηση strcpy().
• πρόσβαση σε μεμονωμένους χαρακτήρες μιας συμβολοσειράς για ανάγνωση και γραφή. Σε έναν ενσωματωμένο πίνακα, αυτό γίνεται χρησιμοποιώντας μια λειτουργία ευρετηρίου ή έμμεση διευθυνσιοδότηση χρησιμοποιώντας έναν δείκτη.
• συγκρίνοντας δύο χορδές για ισότητα. Για έναν ενσωματωμένο τύπο, χρησιμοποιούνται οι συναρτήσεις της οικογένειας strcmp().
• συνένωση (σύνδεση) δύο χορδών, παράγοντας το αποτέλεσμα είτε ως τρίτη χορδή είτε αντί μιας από τις αρχικές. Για έναν ενσωματωμένο τύπο, χρησιμοποιείται η συνάρτηση strcat(), αλλά για να λάβετε το αποτέλεσμα σε μια νέα γραμμή, πρέπει να χρησιμοποιήσετε τις συναρτήσεις strcpy() και strcat() διαδοχικά και επίσης να φροντίσετε την εκχώρηση μνήμης.
• ενσωματωμένα μέσα για τον προσδιορισμό του μήκους μιας συμβολοσειράς (συναρτήσεις μέλους τάξης size() και l ength()). Ο μόνος τρόπος για να μάθετε το μήκος μιας συμβολοσειράς ενσωματωμένου τύπου είναι να το υπολογίσετε χρησιμοποιώντας τη συνάρτηση strlen().
• ικανότητα να ανακαλύψετε εάν μια συμβολοσειρά είναι κενή.

Ας δούμε αυτά τα βασικά χαρακτηριστικά με περισσότερες λεπτομέρειες.

Αρχικοποίηση συμβολοσειρώνόταν περιγράφει και μήκος χορδής(μη συμπεριλαμβανομένου του τερματισμού null terminator):

String st("Η συμβολοσειρά μου\n"); cout<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

Η συμβολοσειρά μπορεί επίσης να είναι κενή:

String st2;

Για να το ελέγξω είναι κενή η γραμμή, μπορείτε να συγκρίνετε το μήκος του με 0:

Αν (! st.size()) // κενό

ή χρησιμοποιήστε τη μέθοδο vala(), η οποία επιστρέφει true για μια κενή συμβολοσειρά και false για μια μη κενή συμβολοσειρά:

Αν (st.empty()) // κενό

Η τρίτη μορφή δημιουργίας συμβολοσειράς αρχικοποιεί ένα αντικείμενο τύπου string με ένα άλλο αντικείμενο του ίδιου τύπου:

Συμβολοσειρά st3(st);

Η συμβολοσειρά st3 αρχικοποιείται με τη συμβολοσειρά st . Πώς μπορούμε να τα βεβαιώσουμε αυτά οι γραμμές ταιριάζουν? Ας χρησιμοποιήσουμε τον τελεστή σύγκρισης (==):

Αν (st == st3) // η προετοιμασία λειτούργησε

Πως αντιγράψτε τη μια γραμμή στην άλλη? Χρησιμοποιώντας τον κανονικό τελεστή εκχώρησης:

St2 = st3; // αντιγράψτε το st3 στο st2

Για συνένωση χορδώνχρησιμοποιείται ο τελεστής πρόσθεσης (+) ή ο τελεστής προσθήκης συν εκχώρησης (+=). Ας δοθούν δύο γραμμές:

Συμβολοσειρά s1("γεια, "); string s2("world\n");

Μπορούμε να πάρουμε μια τρίτη συμβολοσειρά που αποτελείται από μια συνένωση των δύο πρώτων, ως εξής:

Συμβολοσειρά s3 = s1 + s2;

Αν θέλουμε να προσθέσουμε s2 στο τέλος του s1, θα πρέπει να γράψουμε:

S1 += s2;

Η λειτουργία πρόσθεσης μπορεί να συνδέσει αντικείμενα κλάσης σειράόχι μόνο μεταξύ τους, αλλά και με ενσωματωμένες χορδές τύπου. Μπορείτε να ξαναγράψετε το παραπάνω παράδειγμα έτσι ώστε οι ειδικοί χαρακτήρες και τα σημεία στίξης να αντιπροσωπεύονται από τον ενσωματωμένο τύπο char * και οι σημαντικές λέξεις να αντιπροσωπεύονται από αντικείμενα της συμβολοσειράς κλάσης:

Const char *pc = ", "; string s1("γεια"); string s2("world"); συμβολοσειρά s3 = s1 + pc + s2 + "\n"; cout<< endl << s3;

Τέτοιες εκφράσεις λειτουργούν επειδή ο μεταγλωττιστής "ξέρει" πώς να μετατρέπει αυτόματα αντικείμενα του ενσωματωμένου τύπου σε αντικείμενα της κλάσης συμβολοσειράς. Είναι επίσης δυνατό να αντιστοιχίσετε απλώς μια ενσωματωμένη συμβολοσειρά σε ένα αντικείμενο συμβολοσειράς:

Συμβολοσειρά s1; const char *pc = "ένας πίνακας χαρακτήρων"; s1 = pc; // Σωστά

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

Char *str = s1; // σφάλμα μεταγλώττισης

Για να εκτελέσετε αυτήν τη μετατροπή, πρέπει να καλέσετε ρητά μια συνάρτηση μέλους που ονομάζεται c_str() ("συμβολοσειρά C"):

Const char *str = s1.c_str();

Η συνάρτηση c_str() επιστρέφει έναν δείκτη σε έναν πίνακα χαρακτήρων που περιέχει τη συμβολοσειρά του αντικειμένου συμβολοσειράς όπως θα εμφανιζόταν στον ενσωματωμένο τύπο συμβολοσειράς. Η λέξη-κλειδί const εδώ αποτρέπει την "επικίνδυνη" δυνατότητα στα σύγχρονα οπτικά περιβάλλοντα άμεσης τροποποίησης των περιεχομένων ενός αντικειμένου μέσω ενός δείκτη.

ΠΡΟΣ ΤΗΝ μεμονωμένους χαρακτήρεςΈνα αντικείμενο τύπου string , όπως ένας ενσωματωμένος τύπος, μπορεί να προσπελαστεί χρησιμοποιώντας τη λειτουργία ευρετηρίου. Για παράδειγμα, εδώ είναι ένα κομμάτι κώδικα που αντικαθιστά όλες τις τελείες με υπογράμμιση:

String str("www.disney.com"); int size = str.size(); για (int i = 0; i< size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;

Replace(str.begin(), str.end(), ".", "_");

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

#περιλαμβάνω

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

Παρακάτω είναι μια σύντομη περιγραφή των κύριων τελεστών και των λειτουργιών της κλάσης συμβολοσειρών στον πίνακα που οδηγούν σε περιγραφές στη ρωσική γλώσσα στο Διαδίκτυο. Μια πιο πλήρης λίστα με τις δυνατότητες της κλάσης συμβολοσειρών μπορεί να βρεθεί, για παράδειγμα, στη Wikipedia ή στον ιστότοπο cplusplus.com.

Καθορισμός χαρακτήρων σε μια συμβολοσειρά
χειριστής=	εκχωρεί τιμές σε μια συμβολοσειρά
αναθέτω	αντιστοιχίζει χαρακτήρες σε μια συμβολοσειρά
Πρόσβαση σε μεμονωμένους χαρακτήρες
στο	λήψη του καθορισμένου χαρακτήρα και έλεγχος εάν το ευρετήριο είναι εκτός ορίων
χειριστής	λήψη του καθορισμένου χαρακτήρα
εμπρός	να πάρει τον πρώτο χαρακτήρα
πίσω	να πάρει τον τελευταίο χαρακτήρα
δεδομένα	επιστρέφει έναν δείκτη στον πρώτο χαρακτήρα της συμβολοσειράς
c_str	επιστρέφει μη τροποποιήσιμοένας πίνακας χαρακτήρων C που περιέχει τους χαρακτήρες της συμβολοσειράς
Έλεγχος χωρητικότητας γραμμής
αδειάζω	ελέγχει εάν μια συμβολοσειρά είναι κενή
Μέγεθος μήκος	επιστρέφει τον αριθμό των χαρακτήρων σε μια συμβολοσειρά
μέγιστο_μέγεθος	επιστρέφει τον μέγιστο αριθμό χαρακτήρων
Αποθεματικό	κρατά αποθηκευτικό χώρο
Λειτουργίες χορδών
Σαφή	διαγράφει τα περιεχόμενα μιας συμβολοσειράς
εισάγετε	εισαγωγή χαρακτήρων
εξάλειψη	διαγραφή χαρακτήρων
push_back	προσθέτοντας έναν χαρακτήρα στο τέλος μιας συμβολοσειράς
pop_back	αφαιρεί τον τελευταίο χαρακτήρα
προσαρτώ
χειριστής+=	προσθέτει χαρακτήρες στο τέλος μιας συμβολοσειράς
συγκρίνω	συγκρίνει δύο χορδές
αντικαθιστώ	αντικαθιστά κάθε εμφάνιση του καθορισμένου χαρακτήρα
υποστρ	επιστρέφει μια υποσυμβολοσειρά
αντίγραφο	αντιγράφει χαρακτήρες
αλλαγή μεγέθους	αλλάζει τον αριθμό των αποθηκευμένων χαρακτήρων
Αναστείλετε το AdBlock σε αυτόν τον ιστότοπο. Έτσι, χορδές στη γλώσσα C. Δεν υπάρχει ξεχωριστός τύπος δεδομένων για αυτά, όπως γίνεται σε πολλές άλλες γλώσσες προγραμματισμού. Στο C, μια συμβολοσειρά είναι ένας πίνακας χαρακτήρων. Για να επισημάνετε το τέλος μιας γραμμής, χρησιμοποιείται ο χαρακτήρας "\0", τον οποίο συζητήσαμε στο τελευταίο μέρος αυτού του μαθήματος. Δεν εμφανίζεται στην οθόνη με κανέναν τρόπο, επομένως δεν θα μπορείτε να το δείτε. Δημιουργία και αρχικοποίηση μιας συμβολοσειράς Δεδομένου ότι μια συμβολοσειρά είναι ένας πίνακας χαρακτήρων, η δήλωση και η προετοιμασία μιας συμβολοσειράς είναι παρόμοιες με παρόμοιες πράξεις με μονοδιάστατους πίνακες. Ο παρακάτω κώδικας απεικονίζει τους διαφορετικούς τρόπους προετοιμασίας συμβολοσειρών. Λίστα 1. Char str; char str1 = ("Y", "o", "n", "g", "C", "o", "d", "e", "r", "\0"); char str2 = "Γεια σου!"; char str3 = "Γεια σου!"; Εικ.1 Δήλωση και αρχικοποίηση συμβολοσειρών Στην πρώτη γραμμή δηλώνουμε απλώς έναν πίνακα δέκα χαρακτήρων. Δεν είναι καν χορδή, γιατί... δεν υπάρχει κανένας μηδενικός χαρακτήρας \0 σε αυτό, προς το παρόν είναι απλώς ένα σύνολο χαρακτήρων. Δεύτερη γραμμή. Ο απλούστερος τρόπος για άμεση προετοιμασία. Δηλώνουμε κάθε σύμβολο ξεχωριστά. Το κύριο πράγμα εδώ είναι να μην ξεχάσετε να προσθέσετε τον μηδενικό χαρακτήρα \0. Η τρίτη γραμμή είναι ανάλογη με τη δεύτερη γραμμή. Δώστε προσοχή στην εικόνα. Επειδή Υπάρχουν λιγότεροι χαρακτήρες στη γραμμή στα δεξιά από όσα στοιχεία στον πίνακα, τα υπόλοιπα στοιχεία θα γεμίσουν με \0 . Τέταρτη γραμμή. Όπως μπορείτε να δείτε, δεν προσδιορίζεται μέγεθος εδώ. Το πρόγραμμα θα το υπολογίσει αυτόματα και θα δημιουργήσει μια σειρά χαρακτήρων του απαιτούμενου μήκους. Σε αυτήν την περίπτωση, ο μηδενικός χαρακτήρας \0 θα εισαχθεί τελευταίος. Πώς να βγάζετε μια συμβολοσειρά Ας επεκτείνουμε τον παραπάνω κώδικα σε ένα πλήρες πρόγραμμα που θα εμφανίζει τις δημιουργημένες γραμμές στην οθόνη. Λίστα 2. #περιλαμβάνω int main(void) ( char str; char str1 = ("Y", "o", "n", "g", "C", "o", "d", "e", "r"," \0"); char str2 = "Γεια σου!"; char str3 = "Γεια σου!"; for(int i = 0; i< 10; i = i + 1) printf("%c\t",str[i]); printf("\n"); puts(str1); printf("%s\n",str2); puts(str3); return 0; } Εικ.2 Διάφοροι τρόποι εμφάνισης μιας συμβολοσειράς στην οθόνη Όπως μπορείτε να δείτε, υπάρχουν αρκετοί βασικοί τρόποι εμφάνισης μιας συμβολοσειράς στην οθόνη. χρησιμοποιήστε τη συνάρτηση printf με τον προσδιοριστή %s χρησιμοποιήστε τη συνάρτηση puts χρησιμοποιήστε τη συνάρτηση fputs, προσδιορίζοντας την τυπική ροή εξόδου ως stdout ως δεύτερη παράμετρο. Η μόνη απόχρωση είναι με τις συναρτήσεις puts και fputs. Σημειώστε ότι η συνάρτηση puts τυλίγει την έξοδο στην επόμενη γραμμή, αλλά η συνάρτηση fputs όχι. Όπως μπορείτε να δείτε, το συμπέρασμα είναι αρκετά απλό. Εισαγωγή χορδών Η είσοδος συμβολοσειράς είναι λίγο πιο περίπλοκη από την έξοδο. Ο απλούστερος τρόπος θα ήταν ο εξής: Λίστα 3. #περιλαμβάνω int main(void) (char str; gets(str); puts(str); return 0; ) Η συνάρτηση gets διακόπτει το πρόγραμμα, διαβάζει μια συμβολοσειρά χαρακτήρων που εισάγονται από το πληκτρολόγιο και την τοποθετεί σε έναν πίνακα χαρακτήρων, το όνομα του οποίου μεταβιβάζεται στη συνάρτηση ως παράμετρος. Η συνάρτηση gets εξέρχεται με τον χαρακτήρα που αντιστοιχεί στο πλήκτρο enter και γράφεται στη συμβολοσειρά ως μηδενικός χαρακτήρας. Παρατηρήσατε τον κίνδυνο; Εάν όχι, τότε ο μεταγλωττιστής θα σας προειδοποιήσει ευγενικά για αυτό. Το πρόβλημα είναι ότι η συνάρτηση gets εξέρχεται μόνο όταν ο χρήστης πατήσει enter. Αυτό είναι γεμάτο με το γεγονός ότι μπορούμε να προχωρήσουμε πέρα ​​από τον πίνακα, στην περίπτωσή μας - εάν έχουν εισαχθεί περισσότεροι από 20 χαρακτήρες. Παρεμπιπτόντως, τα σφάλματα υπερχείλισης buffer θεωρούνταν προηγουμένως ο πιο συνηθισμένος τύπος ευπάθειας. Βρίσκονται ακόμα σήμερα, αλλά η χρήση τους για να χακάρετε προγράμματα έχει γίνει πολύ πιο δύσκολη. Τι έχουμε λοιπόν; Έχουμε μια εργασία: να γράψουμε μια συμβολοσειρά σε έναν πίνακα περιορισμένου μεγέθους. Δηλαδή, πρέπει με κάποιο τρόπο να ελέγχουμε τον αριθμό των χαρακτήρων που εισάγει ο χρήστης. Και εδώ μας βοηθάει η συνάρτηση fgets: Λίστα 4. #περιλαμβάνω int main(void) (char str; fgets(str, 10, stdin); puts(str); return 0; ) Η συνάρτηση fgets παίρνει τρία ορίσματα ως είσοδο: τη μεταβλητή στην οποία θα γράψει τη συμβολοσειρά, το μέγεθος της συμβολοσειράς που θα γραφτεί και το όνομα της ροής από την οποία θα ληφθούν τα δεδομένα για εγγραφή στη συμβολοσειρά, σε αυτήν την περίπτωση το stdin. Όπως γνωρίζετε ήδη από το Μάθημα 3, το stdin είναι η τυπική ροή εισόδου που συνήθως σχετίζεται με το πληκτρολόγιο. Δεν είναι καθόλου απαραίτητο τα δεδομένα να προέρχονται από τη ροή stdin στο μέλλον θα χρησιμοποιούμε επίσης αυτή τη λειτουργία για την ανάγνωση δεδομένων από αρχεία. Εάν κατά την εκτέλεση αυτού του προγράμματος εισάγουμε μια συμβολοσειρά μεγαλύτερη από 10 χαρακτήρες, μόνο 9 χαρακτήρες από την αρχή και μια αλλαγή γραμμής θα συνεχίσει να γράφεται στον πίνακα, τα fgets θα «κόψουν» τη συμβολοσειρά στο απαιτούμενο μήκος. Σημειώστε ότι η συνάρτηση fgets δεν διαβάζει 10 χαρακτήρες, αλλά 9! Όπως θυμόμαστε, στις συμβολοσειρές ο τελευταίος χαρακτήρας δεσμεύεται για τον μηδενικό χαρακτήρα. Ας το ελέγξουμε. Ας τρέξουμε το πρόγραμμα από την τελευταία λίστα. Και εισάγετε τη γραμμή 1234567890. Η γραμμή 123456789 θα εμφανιστεί στην οθόνη. Εικ. 3 Παράδειγμα της συνάρτησης fgets Γεννιέται το ερώτημα. Πού πήγε ο δέκατος χαρακτήρας; Και θα απαντήσω. Δεν έχει εξαφανιστεί, παραμένει στη ροή εισόδου. Εκτελέστε το παρακάτω πρόγραμμα. Λίστα 5. #περιλαμβάνω int main(void) (char str; fgets(str, 10, stdin); puts(str); int h = 99; printf("do %d\n", h); scanf("%d",&h) printf("μετά %d\n", h); Ιδού το αποτέλεσμα της δουλειάς της. Εικ.4 Μη κενή buffer stdin Επιτρέψτε μου να εξηγήσω τι συνέβη. Καλέσαμε τη συνάρτηση fgets. Άνοιξε τη ροή εισόδου και περίμενε να εισάγουμε τα δεδομένα. Εισαγάγαμε 1234567890\n από το πληκτρολόγιο (\n Εννοώ πατώντας το πλήκτρο Enter). Αυτό πήγε στη ροή εισόδου stdin. Η συνάρτηση fgets, όπως αναμενόταν, πήρε τους πρώτους 9 χαρακτήρες 123456789 από τη ροή εισόδου, πρόσθεσε τον μηδενικό χαρακτήρα \0 σε αυτούς και τον έγραψε στη συμβολοσειρά str . Απομένουν ακόμη 0\n στη ροή εισόδου. Στη συνέχεια δηλώνουμε τη μεταβλητή h. Εμφανίζουμε την αξία του στην οθόνη. Στη συνέχεια καλούμε τη συνάρτηση scanf. Εδώ αναμένεται να μπούμε σε κάτι, αλλά... υπάρχει 0\n στη ροή εισόδου, τότε η συνάρτηση scanf το αντιλαμβάνεται ως είσοδο μας και γράφει 0 στη μεταβλητή h. Στη συνέχεια το εμφανίζουμε στην οθόνη. Αυτή, φυσικά, δεν είναι ακριβώς η συμπεριφορά που περιμένουμε. Για να αντιμετωπίσουμε αυτό το πρόβλημα, πρέπει να καθαρίσουμε το buffer εισόδου αφού έχουμε διαβάσει την είσοδο του χρήστη από αυτό. Για αυτό χρησιμοποιείται μια ειδική λειτουργία flush. Έχει μόνο μία παράμετρο - τη ροή που πρέπει να διαγραφεί. Ας διορθώσουμε το τελευταίο παράδειγμα έτσι ώστε να λειτουργεί προβλέψιμα. Λίστα 6. #περιλαμβάνω int main(void) (char str; fgets(str, 10, stdin); fflush(stdin); // διαγραφή της ροής εισόδου puts(str); int h = 99; printf("do %d\n", h ) ; scanf("%d",&h); Τώρα το πρόγραμμα θα λειτουργεί όπως θα έπρεπε. Εικ.4 Πλύση του buffer stdin με τη συνάρτηση flush Συνοψίζοντας, μπορούν να σημειωθούν δύο γεγονότα. Πρώτα. Προς το παρόν δεν είναι ασφαλές να χρησιμοποιήσετε τη συνάρτηση gets, επομένως συνιστάται η χρήση της συνάρτησης fgets παντού. Δεύτερος. Μην ξεχάσετε να διαγράψετε το buffer εισόδου εάν χρησιμοποιείτε τη συνάρτηση fgets. Αυτό ολοκληρώνει τη συζήτηση σχετικά με την εισαγωγή χορδών. Προχώρα. Σε αυτό το μάθημα θα συζητήσουμε τις συμβολοσειρές τύπου C, μπορεί να έχετε ήδη δει αυτές τις χορδές στον ιστότοπό μας ή σε οποιοδήποτε άλλο εγχειρίδιο. Στην πραγματικότητα, οι συμβολοσειρές C είναι απλώς πίνακες χαρακτήρων, αλλά, με τις δικές τους ιδιαιτερότητες, έτσι γνωρίζουμε πάντα πού βρίσκεται το τέλος της γραμμής. Σε αυτό το άρθρο θα εξετάσουμε διάφορες λειτουργίες για την εργασία με συμβολοσειρές, για παράδειγμα, εσείς - αντιγράψτε, συνενώστε, λάβετε το μήκος μιας συμβολοσειράς. Τι είναι οι χορδές; Σημειώστε ότι μαζί με τις συμβολοσειρές τύπου C, οι οποίες είναι ουσιαστικά απλοί πίνακες, υπάρχουν και κυριολεκτικά συμβολοσειρών, όπως αυτό το "literal" . Στην πραγματικότητα, τόσο οι συμβολοσειρές όσο και οι κυριολεξίες είναι απλώς σύνολα χαρακτήρων που βρίσκονται δίπλα-δίπλα στη μνήμη του υπολογιστή. Αλλά υπάρχει ακόμα μια διαφορά μεταξύ πινάκων και literals: τα literals δεν μπορούν να αλλάξουν και οι συμβολοσειρές μπορούν. Οποιαδήποτε συνάρτηση λαμβάνει μια συμβολοσειρά τύπου C μπορεί επίσης να λάβει ένα κυριολεκτικό ως παράμετρο. Υπάρχουν επίσης ορισμένες οντότητες στο C που μπορεί να μοιάζουν με συμβολοσειρές ενώ στην πραγματικότητα δεν είναι. Μιλάω για χαρακτήρες τώρα, περικλείονται σε μονά εισαγωγικά, ορίστε ένα παράδειγμα - "α", όπως μπορείτε να δείτε, αυτό δεν είναι συμβολοσειρά. Ένας χαρακτήρας μπορεί, σε μια συγκεκριμένη θέση, να εκχωρηθεί σε μια συμβολοσειρά, αλλά οι χαρακτήρες δεν μπορούν να υποβληθούν σε επεξεργασία ως συμβολοσειρά. Αν θυμάστε, οι πίνακες λειτουργούν σαν δείκτες, οπότε αν περάσετε έναν χαρακτήρα σε μια συμβολοσειρά, θα θεωρηθεί σφάλμα. Από τα παραπάνω, θα έπρεπε να έχετε συνειδητοποιήσει ότι οι συμβολοσειρές είναι πίνακες χαρακτήρων και οι κυριολεκτικές συμβολοσειρές είναι λέξεις που περιβάλλονται από διπλά εισαγωγικά. Εδώ είναι ένα άλλο παράδειγμα κυριολεκτικού: "Αυτή είναι μια στατική συμβολοσειρά" Έχετε ξεχάσει την ιδιαιτερότητα των χορδών, που αναφέρθηκε λίγο πιο πάνω; Έτσι, οι συμβολοσειρές C πρέπει πάντα να τελειώνουν με έναν μηδενικό χαρακτήρα, κυριολεκτικά "\0". Επομένως, για να δηλώσετε μια συμβολοσειρά που αποτελείται από 49 γράμματα, πρέπει να κρατήσετε ένα επιπλέον κελί για τον μηδενικό χαρακτήρα: Char myString; Όπως μπορείτε να δείτε από το παράδειγμα, το μήκος του πίνακα είναι 50 χαρακτήρες, 49 από τους οποίους θα είναι μια γραμμή και ένας, ο τελευταίος θα είναι μηδενικός χαρακτήρας. Είναι σημαντικό να θυμάστε ότι πρέπει να υπάρχει πάντα ένας μηδενικός χαρακτήρας στο τέλος των γραμμών C, όπως ακριβώς υπάρχει μια τελεία στο τέλος κάθε πρότασης. Αν και ο μηδενικός χαρακτήρας δεν εμφανίζεται όταν εξάγεται η συμβολοσειρά, εξακολουθεί να καταλαμβάνει χώρο στη μνήμη. Έτσι, τεχνικά, σε μια σειρά από πενήντα στοιχεία, θα μπορούσατε να αποθηκεύσετε μόνο 49 γράμματα επειδή απαιτείται ο τελευταίος χαρακτήρας για τον τερματισμό της συμβολοσειράς. Επιπλέον, οι δείκτες μπορούν επίσης να χρησιμοποιηθούν ως συμβολοσειρά. Εάν διαβάσετε το άρθρο για το , μπορείτε να κάνετε κάτι σαν αυτό: Char *myString; // δείκτης τύπου char myString = malloc(sizeof(*myString) * 64); // εκχώρηση μνήμης Σε αυτό το παράδειγμα, έχουμε εκχωρήσει 64 θέσεις μνήμης για τον πίνακα myString. Για να ελευθερώσετε μνήμη, χρησιμοποιήστε τη συνάρτηση free(). Δωρεάν (myString); Χρήση συμβολοσειρών Οι συμβολοσειρές είναι χρήσιμες όταν χρειάζεται να εκτελέσετε διάφορες λειτουργίες σε πληροφορίες κειμένου. Για παράδειγμα, εάν θέλετε ο χρήστης να εισάγει ένα όνομα σε ένα πρόγραμμα, θα χρησιμοποιούσατε μια συμβολοσειρά. Η χρήση scanf() για την εισαγωγή μιας συμβολοσειράς λειτουργεί, αλλά μπορεί να οδηγήσει σε υπερχείλιση buffer. Εξάλλου, η συμβολοσειρά εισόδου μπορεί να είναι μεγαλύτερη από το μέγεθος της συμβολοσειράς buffer. Υπάρχουν διάφοροι τρόποι επίλυσης αυτού του προβλήματος, αλλά ο απλούστερος τρόπος είναι να χρησιμοποιήσετε το , το οποίο δηλώνεται στο αρχείο κεφαλίδας . Κατά την ανάγνωση εισόδου από τον χρήστη, θα διαβάσει όλους τους χαρακτήρες εκτός από τον τελευταίο. Μετά από αυτό, ένας μηδενικός τερματιστής θα τοποθετηθεί στο τέλος της γραμμής ανάγνωσης. Η συνάρτηση fgets() θα διαβάζει χαρακτήρες μέχρι ο χρήστης να πατήσει Enter. Ας δούμε ένα παράδειγμα χρήσης fgets(): #περιλαμβάνω int main() ( char myString; // long string printf("Εισαγάγετε μια μεγάλη συμβολοσειρά: "); fgets(myString, 100, stdin); // διαβάστε τη συμβολοσειρά από τη ροή εισόδου printf("Εισαγάγατε την ακόλουθη συμβολοσειρά: %s", myString); Η πρώτη παράμετρος στο fgets() είναι μια συμβολοσειρά, η δεύτερη παράμετρος είναι το μέγεθος της συμβολοσειράς και η τρίτη παράμετρος είναι ένας δείκτης στη ροή δεδομένων εισόδου. Αποτέλεσμα του προγράμματος: <ВВОД>... Όπως μπορείτε να δείτε, από την έξοδο του προγράμματος, ένας χαρακτήρας νέας γραμμής - "\n" - εισήλθε στη γραμμή εισόδου. Αυτό συνέβη επειδή η fgets() μέτρησε το πάτημα του κουμπιού Enter στη συμβολοσειρά myString και ολοκλήρωσε την εργασία της. Αυτό σημαίνει ότι μπορεί να χρειαστεί να αφαιρέσετε με μη αυτόματο τρόπο τον χαρακτήρα της νέας γραμμής. Ένας τρόπος για να γίνει αυτό είναι η απαρίθμηση χαρακτήρα προς χαρακτήρα. Ας τροποποιήσουμε το πρόγραμμα και ας αφαιρέσουμε τον χαρακτήρα νέας γραμμής: #περιλαμβάνω int main() ( char myString; // long string printf("Enter a long string: "); fgets(myString, 100, stdin); // διάβασε μια συμβολοσειρά από τη ροή εισόδου int i; for (i = 0; Εγώ< 100; i++) { if (myString[i] == "\n") { myString[i] = "\0"; break; } } printf("Вы ввели следующую строку: %s", myString); getchar(); } Λάβετε υπόψη ότι εάν η συμβολοσειρά εισαγωγής περιέχει λιγότερους από 100 χαρακτήρες, τότε ένας χαρακτήρας νέας γραμμής θα συμπεριληφθεί επίσης στη συμβολοσειρά. Επομένως, μπορούμε να αφαιρέσουμε αυτόν τον χαρακτήρα χρησιμοποιώντας απλή ωμή δύναμη. Προσθέσαμε έναν βρόχο στο πρόγραμμα στον οποίο κάνουμε βρόχο μέσα από τους χαρακτήρες της συμβολοσειράς, γραμμές 12-19. Και όταν συναντάμε έναν χαρακτήρα νέας γραμμής, τον αντικαθιστούμε με έναν μηδενικό χαρακτήρα, γραμμή 16. Αποτέλεσμα του προγράμματος: Εισαγάγετε μια μεγάλη γραμμή: Η μοίρα αφήνει το σημάδι της Έχετε εισαγάγει την ακόλουθη γραμμή: Η μοίρα αφήνει το σημάδι της Για να κλείσετε αυτό το παράθυρο, κάντε κλικ<ВВОД>... Αυτα για τωρα. Στο επόμενο άρθρο θα σας πω για ειδικές λειτουργίες για εργασία με χορδές. P.S.: Σε όλους μας αρέσει να παρακολουθούμε διαφορετικές εγγραφές βίντεο, αλλά μερικές φορές συμβαίνει ότι δεν είναι πάντα δυνατή η αναπαραγωγή ορισμένων μορφών αρχείων βίντεο. Έτσι, μπορείτε να λύσετε αυτό το πρόβλημα χρησιμοποιώντας το πρόγραμμα - xilisoft converter ultimate. Μπορείτε εύκολα να μετατρέψετε βίντεο από μια μορφή σε άλλη. Επιπλέον, αυτό το πρόγραμμα μπορεί επίσης να μετατρέψει αρχεία ήχου και κινούμενες εικόνες. Έχετε ερωτήσεις; Ονομα ΗΛΕΚΤΡΟΝΙΚΗ ΔΙΕΥΘΥΝΣΗ * Μήνυμα * Στείλετε Αναφέρετε ένα τυπογραφικό λάθος Κείμενο που θα σταλεί στους συντάκτες μας: Το σχόλιό σας (προαιρετικό): Στείλετε Ματαίωση