Linii. Intrare/ieșire șir. I/O formatat. Procesarea șirurilor folosind funcții standard ale limbajului C. Lucrul cu memoria.
1.1. Declararea și inițializarea șirurilor de caractere.
Un șir este o matrice de caractere care se termină cu caracterul gol „\0”. Șirul este declarat ca o matrice obișnuită de caractere, de exemplu,
char s1; // șir lung de nouă caractere
char *s2; // pointer către șir
Diferența dintre pointerii s1 și s2 este că pointerul s1 este o constantă numită, iar pointerul s2 este o variabilă.
Constantele șirurilor de caractere sunt cuprinse între ghilimele duble, spre deosebire de caracterele, care sunt cuprinse între ghilimele simple. De exemplu,
„Acesta este un șir.”
Lungimea unei constante șir nu poate depăși 509 caractere conform standardului. Cu toate acestea, multe implementări permit lungimi mai mari ale șirurilor.
La inițializarea șirurilor, este mai bine să nu specificați dimensiunea matricei; compilatorul va face acest lucru calculând lungimea șirului și adăugând unul la acesta. De exemplu,
char s1 = „Acesta este un șir.”;
În limbajul de programare C, există un număr mare de funcții pentru lucrul cu șiruri de caractere, ale căror prototipuri sunt descrise în fișierele de antet stdlib.h și string.h. Lucrul cu aceste funcții va fi discutat în paragrafele următoare.
1.2. Intrare/ieșire șir.
Pentru a introduce un șir din consolă, utilizați funcția
char* gets(char *str);
care scrie un șir la adresa str și returnează adresa șirului introdus. Funcția oprește introducerea dacă întâlnește un caracter „\n” sau EOF (sfârșitul fișierului). Caracterul newline nu este copiat. Un octet zero este plasat la sfârșitul liniei de citire. Dacă are succes, funcția returnează un pointer la linia citită, iar dacă nu are succes, NULL.
Pentru a scoate un șir în consolă, utilizați funcția standard
int pune (const char *s);
care, dacă are succes, returnează un număr nenegativ, iar dacă nu are succes, returnează EOF.
Prototipurile funcțiilor gets and puts sunt descrise în fișierul antet stdio.h.
#include
printf("Șir de intrare: ");
1.3. I/O formatat.
Pentru introducerea datelor formatate din consolă, utilizați funcția
int scanf (const char *format, ...);
care, dacă are succes, returnează numărul de unități de date citite, iar dacă nu are succes, returnează EOF. Parametrul format trebuie să indice șirul de formatat, care conține specificațiile formatului de intrare. Numărul și tipurile de argumente care urmează șirul de format trebuie să se potrivească cu numărul și tipurile de formate de intrare specificate în șirul de format. Dacă această condiție nu este îndeplinită, atunci rezultatul funcției este imprevizibil.
Un spațiu, „\t” sau „\n” într-un șir de format descrie unul sau mai multe caractere goale din fluxul de intrare, care includ caracterele: spațiu, „\t”, „\n”, „\v”, '\f'. Funcția scanf omite caracterele goale din fluxul de intrare.
Caracterele literale dintr-un șir de format, cu excepția caracterului %, necesită ca exact aceleași caractere să apară în fluxul de intrare. Dacă nu există un astfel de caracter, funcția scanf se oprește. Funcția scanf omite caracterele literale.
În general, specificația formatului de intrare arată astfel:
%[*] [lățime] [modificatoare].
Simbolul „*” denotă omisiune la introducerea unui câmp definit de această specificație;
- ‘lățime’ definește numărul maxim de caractere introduse conform acestei specificații;
Tipul poate lua următoarele valori:
c – matrice de caractere,
s – un șir de caractere, liniile sunt separate prin caractere goale,
d – întreg cu semn de 10 s/s,
i – întreg cu semn, sistemul numeric depinde de primele două cifre,
u – întreg fără semn la 10 s/s,
o – întreg fără semn în 8 s/s,
x, X – întreg fără semn la 16 s/s,
e, E, f, g, G – număr flotant,
p – pointer la pointer,
n – pointer către un număr întreg,
[…] – o serie de caractere scanate, de exemplu, .
În acest din urmă caz, din fluxul de intrare vor fi introduse numai caracterele cuprinse între paranteze drepte. Dacă primul caracter din paranteze pătrate este „^”, atunci sunt introduse numai acele caractere care nu sunt în matrice. Intervalul de caractere din matrice este specificat folosind simbolul „-”. Când introduceți caractere, sunt introduse și caracterele goale de început și octetul nul final al șirului.
Modificatorii pot lua următoarele valori:
h – număr întreg scurt,
l, L – întreg lung sau flotant,
și sunt folosite numai pentru numere întregi sau flotante.
Următorul exemplu arată utilizări ale funcției scanf. Rețineți că specificatorul de format, începând cu introducerea numărului flotant, este precedat de un caracter spațiu.
#include
printf("Introduceți un număr întreg: ");
scanf("%d", &n);
printf("Introduceți un dublu: ");
scanf(" %lf", &d);
printf("Introduceți un caracter: ");
scanf(" %c", &c);
printf("Introduceți un șir: ");
scanf(" %s", &s);
Rețineți că în acest program numărul în virgulă mobilă este inițializat. Acest lucru se face astfel încât compilatorul să includă biblioteca pentru a sprijini lucrul cu numere flotante. Dacă nu se face acest lucru, va apărea o eroare în timpul rulării la introducerea unui număr flotant.
Pentru ieșirea formatată a datelor către consolă, utilizați funcția
int printf (const char *format, ...);
care, dacă are succes, returnează numărul de unități de date de ieșire, iar dacă nu are succes, returnează EOF. Parametrul format este un șir de format care conține specificații pentru formatele de ieșire. Numărul și tipurile de argumente care urmează șirul de format trebuie să se potrivească cu numărul și tipurile de specificații de format de ieșire specificate în șirul de format. În general, specificația formatului de ieșire arată astfel:
%[steaguri] [lățime] [.precizie] [modificatoare].
- ‘steaguri’ sunt diferite simboluri care specifică formatul de ieșire;
- „lățimea” definește numărul minim de caractere ieșite conform acestei specificații;
- ‘.precision’ definește numărul maxim de caractere afișate;
- ‘modificatorii’ specifică tipul de argumente;
- „tip” specifică tipul argumentului.
Pentru a scoate numere întregi cu semn, se folosește următorul format de ieșire:
%[-] [+ | spațiu] [lățime] [l] d
- – aliniere stânga, implicit – dreapta;
+ – este afișat semnul ‘+’, rețineți că pentru numerele negative este afișat întotdeauna semnul ‘-’;
‘spațiu’ – un spațiu este afișat la poziția caracterului;
d – int tipul de date.
Pentru a scoate numere întregi fără semn, utilizați următorul format de ieșire:
%[-] [#] [lățime] [l]
# – 0 inițial este afișat pentru numerele din 8 c/c sau inițial 0x sau 0X pentru numerele din 16 c/c,
l – modificator de tip de date lung;
u – întreg în 10c/c,
o – întreg în 8 c/c,
x, X – întreg la 16 c/c.
Următorul format de ieșire este utilizat pentru a afișa numere în virgulă mobilă:
%[-] [+ | spațiu] [lățime] [.precizie]
„precizie” - indică numărul de cifre după virgulă pentru formatele f, e și E sau numărul de cifre semnificative pentru formatele g și G. Numerele sunt rotunjite. Precizia implicită este de șase cifre zecimale;
f – numărul punctului fix,
e – un număr în formă exponențială, exponentul este notat cu litera „e”,
E – un număr în formă exponențială, exponentul este notat cu litera „E”,
g – cel mai scurt dintre formatele f sau g,
G – cel mai scurt dintre formatele f sau G.
printf ("n = %d\n f = %f\n e = %e\n E = %E\n f = %.2f", -123, 12.34, 12.34, 12.34, 12.34);
// afișează: n = 123 f = 12,340000 e = 1,234000e+001 E = 1,234000E+001 f = 12,34
1.4. Formatarea șirurilor.
Există variante ale funcțiilor scanf și printf care sunt concepute pentru a formata șiruri și sunt numite sscanf și, respectiv, sprintf.
int sscanf (const char *str, const char *format, ...);
citește datele din șirul specificat de str, conform șirului de format specificat de format. Dacă are succes, returnează numărul de date citite, iar dacă nu are succes, returnează EOF. De exemplu,
#include
char str = "a 10 1.2 String Nicio intrare";
sscanf(str, „%c %d %lf %s”, &c, &n, &d, s);
printf("%c\n", c); // imprimă: a
printf("%d\n", n); // imprimări: 10
printf("%f\n", d); // imprimări: 1,200000
printf("%s\n", s); // imprimă: String
int sprintf (char *buffer, const char *format, ...);
formatează șirul în conformitate cu formatul specificat de parametrul format și scrie rezultatul rezultat în tamponul matricei de caractere. Funcția returnează numărul de caractere scrise în bufferul matricei de caractere, excluzând octetul nul final. De exemplu,
#include
char str = "c = %c, n = %d, d = %f, s = %s";
char s = „Acesta este un șir.”;
sprintf(buffer, str, c, n, d, s);
printf("%s\n", buffer); // afișează: c = c, n = 10, d = 1,200000, s = Acesta este un șir
1.5. Convertiți șirurile de caractere în date numerice.
Prototipurile de funcții pentru conversia șirurilor de caractere în date numerice sunt date în fișierul antet stdlib.h, care trebuie inclus în program.
Pentru a converti un șir într-un număr întreg, utilizați funcția
int atoi (const char *str);
char *str = „-123”;
n = atoi(str); // n = -123
Pentru a converti un șir într-un număr întreg lung, utilizați funcția
long int atol (const char *str);
care, dacă are succes, returnează întregul în care este convertit șirul str, iar dacă nu are succes, returnează 0. De exemplu,
char *str = „-123”;
n = atol(str); // n = -123
Pentru a converti un șir într-un număr dublu, utilizați funcția
double atof(const char *str);
care, dacă are succes, returnează un număr flotant de tip double, în care este convertit șirul str, iar dacă nu are succes, returnează 0. De exemplu,
char *str = „-123.321”;
n = atof(str); // n = -123,321
Următoarele funcții îndeplinesc funcții similare cu atoi, atol, atof, dar oferă funcționalități mai avansate.
long int strtol (const char *str, char **endptr, int bază);
convertește șirul str într-un număr int lung, pe care îl returnează. Parametrii acestei funcții au următoarele scopuri.
Dacă baza este 0, atunci conversia depinde de primele două caractere ale str:
Dacă primul caracter este un număr de la 1 la 9, atunci se presupune că numărul este reprezentat în 10 c/c;
Dacă primul caracter este cifra 0 și al doilea caracter este o cifră de la 1 la 7, atunci se presupune că numărul este reprezentat în 8 c/c;
Dacă primul caracter este 0 și al doilea este „X” sau „x”, atunci se presupune că numărul este reprezentat în 16 c/c.
Dacă baza este un număr între 2 și 36, atunci acea valoare este considerată baza sistemului numeric și orice caracter din afara sistemului numeric încetează conversia. În sistemele numerice de la baza 11 la baza 36, simbolurile „A” la „Z” sau „a” la „z” sunt folosite pentru a reprezenta cifre.
Valoarea argumentului endptr este stabilită de funcția strtol. Această valoare conține un indicator către caracterul care a oprit conversia șirului de caractere. Funcția strtol returnează numărul convertit dacă are succes și 0 dacă nu are succes. De exemplu,
n = strtol („12a”, &p, 0);
printf("n = %ld, %stop = %c, n, *p); // n = 12, stop = a
n = strtol ("012b", &p, 0);
printf("n = %ld, %stop = %c, n, *p); // n = 10, stop = b
n = strtol („0x12z”, &p, 0);
printf("n = %ld, %stop = %c, n, *p); // n = 18, stop = z
n = strtol („01117”, &p, 0);
printf("n = %ld, %stop = %c, n, *p); // n = 7, stop = 7
unsigned long int strtol (const char *str, char **endptr, int bază);
funcționează similar cu funcția strtol, dar convertește reprezentarea simbolică a unui număr într-un număr de tip unsigned long int.
dublu strtod (const char *str, char **endptr);
Transformă reprezentarea simbolică a unui număr într-un dublu.
Toate funcțiile enumerate în acest paragraf nu mai funcționează atunci când întâlnesc primul caracter care nu se potrivește cu formatul numărului în cauză.
În plus, dacă valoarea caracterului unui număr depășește intervalul de valori acceptabile pentru tipul de date corespunzător, atunci funcțiile atof, strtol, strtoul, strtod setează valoarea variabilei errno la ERANGE. Variabila errno și constanta ERANGE sunt definite în fișierul antet math.h. În acest caz, funcțiile atof și strtod returnează valoarea HUGE_VAL, funcția strtol returnează valoarea LONG_MAX sau LONG_MIN, iar funcția strtoul returnează valoarea ULONG_MAX.
Funcțiile non-standard itoa, ltoa, utoa, ecvt, fcvt și gcvt pot fi utilizate pentru a converti datele numerice în șiruri de caractere. Dar este mai bine să folosiți funcția standard sprintf în aceste scopuri.
1.6. Funcții standard pentru lucrul cu șiruri.
Această secțiune discută funcțiile pentru lucrul cu șiruri de caractere, ale căror prototipuri sunt descrise în fișierul antet string.h.
1. Comparație de șiruri. Funcțiile strcmp și strncmp sunt folosite pentru a compara șiruri.
int strcmp (const char *str1, const char *str2);
compară lexicografic șirurile str1, str2 și returnează –1, 0 sau 1 dacă str1 este, respectiv, mai mic, egal sau mai mare decât str2.
int strncmp (const char *str1, const char *str2, size_t n);
compară lexicografic cel mult primele n caractere din șirurile str1 și str2. Funcția returnează -1, 0 sau 1 dacă primele n caractere din str1 sunt, respectiv, mai mici, egale sau mai mari decât primele n caractere din str2.
// exemplu de comparare a șirurilor
#include
#include
char str1 = "aa bb";
char str2 = "aa aa";
char str3 = "aa bb cc";
printf("%d\n", strcmp(str1, str3)); // imprimă: -1
printf("%d\n", strcmp(str1, str1)); // imprimă: -0
printf("%d\n", strcmp(str1, str2)); // se imprimă: 1
printf("%d\n", strncmp(str1, str3, 5)); // imprimă: 0
2. Copierea liniilor. Funcțiile strcpy și strncpy sunt folosite pentru a copia șiruri.
char *strcpy (char *str1, const char *str2);
copiează șirul str2 în șirul str1. Întregul șir str2 este copiat, inclusiv octetul nul final. Funcția returnează un pointer către str1. Dacă liniile se suprapun, rezultatul este imprevizibil.
char *strncpy (char *str1, const char *str2, size_t n);
copiază n caractere din șirul str2 în șirul str1. Dacă str2 conține mai puțin de n caractere, atunci ultimul octet zero este copiat de câte ori este necesar pentru a extinde str2 la n caractere. Funcția returnează un pointer către șirul str1.
char str2 = "Copiați șirul.";
strcpy(str1, str2);
printf(str1); // imprimă: Copiați șirul.
4. Corzi de legătură. Funcțiile strcat și strncat sunt folosite pentru a concatena șiruri într-un singur șir.
char* strcat (char *str1, const char *str2);
adaugă șirul str2 la șirul str1, cu octetul zero final al șirului str1 șters. Funcția returnează un pointer către șirul str1.
char* strncat (char *str1, const char *str2, size_t n);
adaugă n caractere din șirul str2 la șirul str1, cu octetul zero de la urmă al șirului str1 șters. Funcția returnează un pointer către șirul str1. dacă lungimea șirului str2 este mai mică decât n, atunci sunt atașate numai caracterele incluse în șirul str2. După concatenarea șirurilor, un octet nul este întotdeauna adăugat la str1. Funcția returnează un pointer către șirul str1.
#include
#include
char str1 = „Șir”;
char str2 = "catenare";
char str3 = "Da Nu";
strcat(str1, str2);
printf("%s\n", str1); // printează: String catenation
strncat(str1, str3, 3);
printf("%s\n", str1); // imprimă: String catenation Da
5. Căutați un caracter într-un șir. Pentru a căuta un caracter într-un șir, utilizați funcțiile strchr, strrchr, strspn, strcspn și strpbrk.
char* strchr (const char *str, int c);
caută prima apariție a caracterului specificat de c în șirul str. Dacă are succes, funcția returnează un pointer la primul caracter găsit, iar dacă nu are succes, NULL.
char* strrchr (const char *str, int c);
caută ultima apariție a caracterului specificat de c în șirul str. Dacă are succes, funcția returnează un pointer la ultimul caracter găsit, iar dacă nu are succes, NULL.
#include
#include
char str = "Căutare Char";
printf("%s\n", strchr(str, "r")); // imprimă: r căutare
printf("%s\n", strrchr(str, "r")); // tipărituri: rch
size_t strspn (const char *str1, const char *str2);
returnează indexul primului caracter din str1 care nu este în str2.
size_t strcspn (const char *str1, const char *str2);
returnează indexul primului caracter din str1 care apare în str2.
char str = "123 abc";
printf ("n = %d\n", strspn (str, "321"); // afișează: n = 3
printf ("n = %d\n", strcspn (str, "cba"); // afișează: n = 4
char* strpbrk (const char *str1, const char *str2);
găsește primul caracter din șirul str1 care este egal cu unul dintre caracterele din șirul str2. Dacă are succes, funcția returnează un pointer la acest caracter, iar dacă nu are succes, NULL.
char str = "123 abc";
printf("%s\n", strpbrk(str, "bca")); // imprimă: abc
6. Comparație de șiruri. Funcția strstr este folosită pentru a compara șiruri.
char* strstr (const char *str1, const char *str2);
găsește prima apariție a lui str2 (fără octetul nul final) în str1. Dacă are succes, funcția returnează un pointer către subșirul găsit, iar dacă nu are succes, NULL. Dacă pointerul str1 indică un șir de lungime zero, atunci funcția returnează pointerul str1.
char str = "123 abc 456;
printf ("%s\n", strstr (str, "abc"); // print: abc 456
7. Analizarea unui șir în jetoane. Funcția strtok este folosită pentru a analiza un șir în token-uri.
char* strtok (char *str1, const char *str2);
returnează un pointer la următorul token (cuvânt) din șirul str1, în care delimitatorii jetonului sunt caractere din șirul str2. Dacă nu mai există jetoane, funcția returnează NULL. La primul apel la funcția strtok, parametrul str1 trebuie să indice un șir care este tokenizat, iar la apelurile ulterioare acest parametru trebuie setat la NULL. După găsirea unui token, funcția strtok scrie un octet nul după acest token în locul delimitatorului.
#include
#include
char str = "12 34 ab cd";
p = strtok(str, " ");
printf("%s\n", p); // tipărește valorile într-o coloană: 12 34 ab cd
p = strtok(NULL, " ");
8. Determinarea lungimii unui șir. Funcția strlen este utilizată pentru a determina lungimea unui șir.
size_t strlen (const char *str);
returnează lungimea șirului, ignorând ultimul octet nul. De exemplu,
char str = "123";
printf("len = %d\n", strlen(str)); // imprimă: len = 3
1.7. Funcții pentru lucrul cu memoria.
Fișierul antet string.h descrie, de asemenea, funcții pentru lucrul cu blocuri de memorie, care sunt similare cu funcțiile corespunzătoare pentru lucrul cu șiruri.
void* memchr (const void *str, int c, size_t n);
caută prima apariție a caracterului specificat de c în n octeți ai șirului str.
int memcmp (const void *str1, const void *str2, size_t n);
compară primii n octeți ai șirurilor str1 și str2.
void* memcpy (const void *str1, const void *str2, size_t n);
copiază primii n octeți din șirul str1 în șirul str2.
void* memmove (const void *str1, const void *str2, size_t n);
copiează primii n octeți de la str1 la str2, asigurându-se că șirurile care se suprapun sunt gestionate corect.
void* memset (const void *str, int c, size_t n);
copiază caracterul specificat de c în primii n octeți ai str.
Etichete: liniile C. Matrice Char.
Coarde în C. Introducere.
Acesta este un articol introductiv despre șirurile C. O descriere mai detaliată și exemple vor veni când vom învăța cum să lucrăm cu memoria și pointerii. Într-un computer, toate valorile sunt stocate ca numere. Și linii, de asemenea, nu există simboluri sau litere acolo. Un termen este o matrice de numere. Fiecare număr corespunde unui anumit caracter, care este preluat din tabelul de codificare. Când este afișat pe ecran, simbolul este afișat într-un anumit mod.
Matricele de tip char sunt folosite pentru a stoca șiruri. Repet încă o dată - tipul char este numeric, stochează un octet de date. Dar, conform tabelului de codificare, fiecare dintre aceste numere este asociat cu un caracter. Și în direcția opusă - fiecare caracter este determinat de numărul său de serie din tabelul de codificare.
De exemplu
#include
Am creat două variabile, una de tip char, alte int. Litera „A” are o valoare numerică de 65. Este o literă, nu un șir și, prin urmare, este înconjurată de ghilimele simple. O putem imprima ca scrisoare
Printf("afișare ca caracter %c\n", c);
Apoi va fi scos
A
Dacă îl scoateți ca număr, va fi
65
Puteți face același lucru cu numărul 65, care este stocat într-o variabilă ca int.
Caracterele speciale au, de asemenea, propriul număr
#include
Aici semnalul sonor va fi mai întâi „ieșit”, apoi valoarea sa numerică, apoi din nou semnalul sonor.
Un șir în C este o matrice de tip char, al cărui ultimul element stochează caracterul terminal „\0”. Valoarea numerică a acestui caracter este 0, deci putem spune că tabloul se termină cu zero.
De exemplu
#include
Cheia %s a fost folosită pentru ieșire. În acest caz, linia este imprimată până la primul caracter terminal, deoarece funcția printf nu cunoaște dimensiunea matricei de cuvinte.
Daca in acest exemplu nu puneti
Cuvânt = "\0";
atunci va fi scos un șir de caractere de lungime arbitrară până când este întâlnit primul octet umplut cu zerouri.
#include
În acest caz, totul este corect. Șirul „ABC” se termină cu zero și inițializam matricea de cuvinte cu el. Șirul de text este inițializat literă cu literă, toate caracterele rămase, după cum urmează din capitolul despre matrice, sunt umplute cu zerouri.
Rânduri de lectură
Pentru a solicita un șir de la utilizator, trebuie să creați un buffer. Mărimea tamponului trebuie selectată în prealabil, astfel încât cuvântul introdus să se potrivească în ea. La citirea liniilor, există pericolul ca utilizatorul să introducă mai multe date decât permite tamponul. Aceste date vor fi citite și plasate în memorie și vor suprascrie valorile altor persoane. În acest fel, puteți efectua un atac prin înregistrarea octeților necesari, în care, de exemplu, merită să mergeți la o secțiune de cod cu un program rău intenționat sau să înregistrați date.
#include
În acest caz, numărul de caractere introduse este limitat la 19, iar dimensiunea bufferului este cu 1 mai mare, deoarece este necesar să stocați caracterul terminal. Să scriem un program simplu care cere utilizatorului un șir și returnează lungimea acestuia.
#include
Deoarece valoarea numerică a caracterului „\0” este zero, putem scrie
While (buffer != 0) (len++; )
Sau, chiar mai scurt
While (buffer) (len++; )
Acum să scriem un program care cere utilizatorului două cuvinte și le compară
#include
Deoarece fiecare literă are o valoare numerică, acestea pot fi comparate între ele ca numere. În plus, de obicei (dar nu întotdeauna!) literele din tabelele de codificare sunt aranjate alfabetic. Prin urmare, sortarea după valoare numerică va fi și sortată alfabetic.
Biblioteca de funcții C și C++ include un set bogat de funcții de procesare a șirurilor și a caracterelor. Funcțiile șiruri de caractere operează pe matrice de caractere terminate cu caractere nule. În limbajul C, pentru a utiliza funcții șir, trebuie să includeți un fișier antet la începutul modulului de program
Deoarece limbajele C și C++ nu controlează automat încălcarea limitelor lor atunci când efectuează operațiuni cu matrice, toată responsabilitatea pentru depășirea matricei cade pe umerii programatorului. Neglijarea acestor subtilități poate duce la blocarea programului.
În C și C++, caracterele imprimabile sunt caracterele afișate pe terminal. În mediile ASCII, acestea sunt situate între spațiu (0x20) și tilde (OxFE). Caracterele de control au valori cuprinse între zero și Ox1F; acestea includ și simbolul DEL(Ox7F).
Din punct de vedere istoric, argumentele funcțiilor de caractere au fost valori întregi, dintre care a fost folosit doar octetul mic. Funcțiile de caractere își convertesc automat argumentele în caracter nesemnat. Desigur, sunteți liber să apelați aceste funcții cu argumente de caractere, deoarece caracterele sunt ridicate automat la rangul de numere întregi atunci când funcția este apelată.
În titlu
C99 a adăugat calificativul de restricție la unii parametri ai mai multor funcții definite inițial în C89. La revizuirea fiecărei astfel de funcții, va fi dat prototipul său folosit în mediul C89 (precum și în mediul C++), iar parametrii cu atributul restrict vor fi notați în descrierea acestei funcții.
Lista de funcții
Verificați afilierea
isalnum - Verificarea dacă un caracter este alfanumeric
isalpha - Verificarea dacă un simbol aparține literelor
isblank - Verificați dacă există un caracter gol
iscntrl - Verificarea dacă un simbol aparține simbolurilor de control
isdigit - Verificarea dacă un caracter este digital
isgraph - Verifică dacă un caracter este imprimabil, dar nu un spațiu
islower - Verifică dacă un caracter este scris cu minuscule
isprint - Verificarea dacă un caracter este imprimabil
ispunct - Verificarea dacă un simbol aparține semnelor de punctuație
isspace - Verifică dacă un caracter este un caracter alb
isupper - Verifică dacă un caracter este cu majuscule
isxdigit - Verifică dacă un caracter este hexazecimal
Lucrul cu matrice de caractere
memchr - Caută într-o matrice pentru a găsi prima apariție a unui caracter
memcmp - Compară un număr specificat de caractere din două matrice
memcpy - Copiază caracterele dintr-o matrice în alta
memmove - Copiază caracterele dintr-o matrice în alta, ținând cont de suprapunerea matricei
memset - Completează un număr specificat de caractere dintr-o matrice cu un număr dat
Manipularea șirurilor
strcat - Adaugă o copie a unui singur șir la un șir dat
strchr - Returnează un pointer la prima apariție a octetului inferior al parametrului dat
strcmp - Compară două șiruri în ordine lexicografică
strcoll - Compară un șir cu altul în funcție de parametrul setlocale
strcpy - Copiază conținutul unui șir în altul
strcspn - Returnează un șir care nu conține caracterele specificate
strerror - Returnează un pointer către un șir care conține un mesaj de eroare de sistem
strlen - Returnează lungimea terminată în nul a unui șir
Nu întâmplător am plasat subiectul despre șiruri în secțiunea „Matrice”. Deoarece un șir este în esență o matrice de caractere. Iată un exemplu:
char str = "Acesta este doar un șir";
Pentru o mai bună înțelegere, aceeași linie poate fi scrisă astfel:
char str = ("E","t","o"," ","p","r","o","s","t","o","s", „t”, „r”, „o”, „k”, „a”);
Acestea. încă aceeași matrice, constând doar din caractere. Prin urmare, puteți lucra cu el, la fel ca și cu matricele întregi.
Acum hai să încercăm lucrați cu șiruri în c. În lecțiile introductive, am învățat că simbolurile aparțin unor tipuri întregi, adică. fiecare caracter are propria sa valoare numerică. Iată un exemplu și soluția lui:
- trebuie să convertiți cuvântul introdus în majuscule:
#include
#include
Int main()
{
char str = "sergey";
str[i] -= 32;
}
pentru (int i=0; str[i] != "\0";i++)(
printf("%c", str[i]);
}
getch();
Returnează 0;
}
Pentru a obține codul unui număr, pur și simplu utilizați specificatorul %d în funcția printf. Da, și încă un punct important: sfârșitul oricărui linii este un terminator nul, care este notat cu un caracter special - „\0”.
O altă modalitate de a specifica un șir este de a-l declara folosind char*. Iată un exemplu:
char *str = „sârmă”;
Acestea. un pointer către un șir este creat și localizat undeva în memorie.
Și iată cum puteți introduce șiruri prin operatorul scanf, care ne este deja familiar:
char str; scanf("%s", str);
Există două subtilități aici:
- semnul de preluare a adresei nu este necesar aici, deoarece numele matricei, după cum știm deja, este adresa
- Lungimea șirului de intrare nu trebuie să depășească 15 caractere, deoarece ultimul trebuie să fie un terminator nul. Mai mult decât atât, compilatorul însuși va completa acest simbol după ultimul simbol introdus.
Deoarece limbajul C este un limbaj structural, există deja funcții încorporate pentru lucrul cu sforiși cu simboluri. Pentru a procesa șiruri de caractere va trebui să includeți fișierul: ctype.h. Fișierul conține funcții pentru determinarea formatului de majuscule și caractere. Practic, tot ce trebuie să știți despre un personaj se poate face folosind funcțiile din fișierul ctype.h
Uneori poate fi necesar să convertiți un șir într-un alt tip de date. Pentru a converti șirurile în alte tipuri, există biblioteca stdlib. Iată funcțiile sale:
- int atoi (char *str)
- atol lung (char *str)
- dublu atof (char *str)
Uneori, aceste funcții sunt foarte utile, de exemplu, atunci când trebuie să extrageți anul sau valoarea digitală dintr-un șir. Lucrul cu șiruri în c (si) este un subiect foarte important, așa că încercați să înțelegeți această lecție.
Ultima actualizare: 31.10.2015
Concatenare
Concatenarea sau unirea șirurilor se poate face folosind fie operatorul +, fie metoda Concat:
String s1 = „bună ziua”; șir s2 = „lume”; șir s3 = s1 + " " + s2; // rezultat: string "hello world" string s4 = String.Concat(s3, "!!!"); // rezultat: șirul „hello world!!!” Console.WriteLine(s4);
Metoda Concat este o metodă statică a clasei String care ia ca parametri două șiruri. Există și alte versiuni ale metodei care iau un număr diferit de parametri.
Metoda Join poate fi folosită și pentru a uni șiruri de caractere:
String s5 = „măr”; șir s6 = „o zi”; șir s7 = „păstrează”; string s8 = „un medic”; șir s9 = „departe”; valorile șirului = șir nou ( s5, s6, s7, s8, s9 ); String s10 = String.Join(" ", valori); // rezultat: șirul „măr pe zi ține un doctor departe”
Metoda Join este, de asemenea, statică. Versiunea metodei folosite mai sus ia doi parametri: un șir separator (în acest caz un spațiu) și o matrice de șiruri care vor fi concatenate și separate de separator.
Comparație de șiruri
Pentru a compara șirurile de caractere, utilizați metoda de comparare statică:
String s1 = „bună ziua”; șir s2 = „lume”; int rezultat = String.Compare(s1, s2); dacă (rezultat<0) { Console.WriteLine("Строка s1 перед строкой s2"); } else if (result >0) ( Console.WriteLine("Linia s1 vine după linia s2"); ) else ( Console.WriteLine ("Liniile s1 și s2 sunt identice"); ) // rezultatul va fi "Linia s1 înainte de linia s2"
Această versiune a metodei Compare are două șiruri de caractere și returnează un număr. Dacă primul șir este alfabetic mai mare decât al doilea, atunci este returnat un număr mai mic decât zero. În caz contrar, se returnează un număr mai mare decât zero. Și al treilea caz - dacă șirurile sunt egale, atunci numărul 0 este returnat.
În acest caz, deoarece caracterul h este alfabetic mai mare decât caracterul w, prima linie va fi mai mare.
Căutați într-un șir
Folosind metoda IndexOf, putem determina indexul primei apariții a unui singur caracter sau subșir dintr-un șir:
String s1 = „bună lume”; char ch = "o"; int indexOfChar = s1.IndexOf(ch); // egal cu 4 Console.WriteLine(indexOfChar); șir subString = „wor”; int indexOfSubstring = s1.IndexOf(subString); // egal cu 6 Console.WriteLine(indexOfSubstring);
Metoda LastIndexOf funcționează într-un mod similar, cu excepția faptului că găsește indexul ultimei apariții a unui caracter sau subșir dintr-un șir.
Un alt grup de metode vă permite să aflați dacă un șir începe sau se termină cu un anumit subșir. Metodele StartsWith și EndsWith sunt concepute pentru aceasta. De exemplu, avem o sarcină de a șterge toate fișierele cu extensia .exe dintr-un folder:
Calea șirului = @"C:\SomeDir"; fișiere șir = Directory.GetFiles(cale); pentru (int i = 0; i< files.Length; i++) { if(files[i].EndsWith(".exe")) File.Delete(files[i]); }
Împărțirea șirurilor
Folosind funcția Split, putem împărți un șir într-o matrice de subșiruri. Funcția Split ia ca parametru o matrice de caractere sau șiruri de caractere, care va servi drept delimitatori. De exemplu, să numărăm numărul de cuvinte dintr-un termen împărțindu-l la caractere cu spații albe:
String text = „Și de aceea s-a întâmplat totul”; cuvinte șir = text.Split(car nou (" " )); foreach (șir de caractere în cuvinte) ( Console.WriteLine(s); )
Aceasta nu este cea mai bună modalitate de a împărți după spații, deoarece am putea avea mai multe spații consecutive în șirul de intrare și matricea rezultată ar conține și spații, deci este mai bine să folosiți o altă versiune a metodei:
String words = text.Split(new char ( " " ), StringSplitOptions.RemoveEmptyEntries);
Al doilea parametru StringSplitOptions.RemoveEmptyEntries spune că toate subșirurile goale ar trebui eliminate.
Tăierea unei linii
Pentru a decupa caracterele de început sau de sfârșit, utilizați funcția Trim:
String text = „bună lume”; text = text.Trim(); // rezultat "hello world" text = text.Trim(new char ("d", "h" )); // rezultat „ello lume”
Funcția Trim, fără parametri, decupează spațiile de început și de final și returnează șirul tăiat. Pentru a specifica în mod explicit ce caractere de început și de sfârșit ar trebui tăiate, putem transmite o matrice a acelor caractere la funcție.
Această funcție are analogi parțial: funcția TrimStart decupează caracterele de început, iar funcția TrimEnd decupează caracterele de sfârșit.
Funcția Substring vă permite să tăiați o anumită parte a unui șir:
String text = „Bună ziua”; // tăiat pornind de la al treilea caracter text = text.Substring(2); // rezultat „ziua bună” Console.WriteLine(text); // taie primul la ultimele două caractere text = text.Substring(0, text.Length - 2); // rezultat "roshy de" Console.WriteLine(text);
Funcția Substring returnează și șirul trunchiat. Prima versiune folosită folosește ca parametru indexul, începând de la care șirul trebuie tăiat. A doua versiune folosește doi parametri - indicele de pornire a tăierii și lungimea părții tăiate a șirului.
Introduce
Pentru a insera un rând în altul, utilizați funcția Inserare:
String text = „Bună ziua”; string subString = „minunat”; text = text.Insert(8, subString); Console.WriteLine(text);
Primul parametru din funcția Insert este indexul la care ar trebui inserat subșirul, iar al doilea parametru este subșirul în sine.
Eliminarea rândurilor
Metoda Remove ajută la eliminarea unei părți a unui șir:
String text = „Bună ziua”; // indexul ultimului caracter int ind = text.Lungime - 1; // decupează ultimul caracter text = text.Remove(ind); Console.WriteLine(text); // decupează primele două caractere text = text.Remove(0, 2);
Prima versiune a metodei Remove preia un index în șir, începând de la care toate caracterele trebuie eliminate. A doua versiune ia încă un parametru - câte caractere ar trebui eliminate.
Înlocuire
Pentru a înlocui un caracter sau subșir cu altul, utilizați metoda Înlocuire:
String text = „ziua bună”; text = text.Inlocuire("bine", "rau"); Console.WriteLine(text); text = text.Replace("o", ""); Console.WriteLine(text);
În al doilea caz de utilizare a funcției Înlocuire, un șir de un caracter „o” este înlocuit cu un șir gol, adică este de fapt eliminat din text. Această metodă facilitează ștergerea textului specific din rânduri.
Schimbă cazul
Pentru a converti un șir în litere mari și mici, utilizați funcțiile ToUpper() și, respectiv, ToLower():
String hello = „Bună lume!”; Console.WriteLine(hello.ToLower()); // Salut Lume! Console.WriteLine(hello.ToUpper()); // SALUT LUME!
