Lekcja 17LEKCJA 17
Przechowywanie tekstów (string) i operacje na nich
Teksty (ang. string) przechowują informacje takie jak nazwy plików, tytuły
książek, nazwiska pracowników i inne ciągi znaków. Większość programów
napisanych w C++ szeroko wykorzystuje teksty. Jak zobaczysz, C++ przechowuje
teksty jako tablice typu char zakończone znakiem pustym NULL (znak o kodzie
ASCII 0). Podczas tej lekcji dokładnie przedstawimy teksty. Dowiesz się, w jaki
sposób przechowywać teksty i operować na nich i jak korzystać z funkcji
biblioteki run-time, które operują na tekstach. Pod koniec tej lekcji będziesz
rozumiał następujące zagadnienia podstawowe:
Aby zadeklarować tekst, musisz zadeklarować tablicę typu char.
Aby przypisać tekstowi znaki, przypisujesz po prostu znaki elementom tablicy.
Programy w C++ zaznaczają ostatni symbol tekstu znakiem pustym NULL (znak o
kodzie ASCII 0).
Możesz w swoich programach inicjalizować teksty przy ich deklaracji.
Programy mogą przekazywać funkcjom teksty w taki sam sposób jak tablice.
Większość bibliotek run-time C++ daje Ci do dyspozycji zbiór funkcji
operujących na tekstach.
Programy w C++ przechowują teksty jako tablice typu char. Większość programów w
C++ szeroko wykorzystuje teksty. Testując programy przedstawione podczas tej
lekcji będziesz mógł się przekonać, czy dobrze wszystko rozumiesz. Jak
zobaczysz, operowanie na tekstach jest bardzo podobne do operowania na innych
tablicach, a to umiesz z lekcji 16.


Deklarowanie tekstu w programie
Programy napisane w C++ szeroko wykorzystują teksty do przechowywania nazwisk
użytkowników, nazw plików i innych informacji składających się ze znaków. Aby
zadeklarować tekst w programie, musisz po prostu zadeklarować tablicę typu char
o rozmiarze wystarczająco dużym, by mogła przechowywać potrzebne znaki. Na
przykład poniższa deklaracja tworzy zmienną tekstową pod nazwą nazwa_pliku,
która może przechowywać 64 znaki (w tym znak pusty).
char nazwa_pliku[64];

Jak widać na rysunku 5, ta deklaracja tworzy tablicę indeksowaną od
nazwa_pliku[0] do nazwa_pliku[63].
Rysunek 5.
W C++ teksty są tablicami znaków



Podstawowa różnica między tekstami i innymi tablicami polega na tym, jak C++
zaznacza ostatni element tablicy. Jak zobaczysz, programy w C++ reprezentują
koniec tekstu przy użyciu znaku pustego NULL, który w C++ jest znakiem
specjalnym '\O'. Gdy przypisujesz znaki tekstowi, to musisz za ostatnim znakiem
umieszczać symbol '\O'. Na przykład przedstawiony poniżej program ALFABET.CPP
przypisuje w pętli for zmiennej tekstowej alfabet kolejne znaki od A do Z.
Następnie dołącza do zmiennej znak pusty i wyświetla zmienną za pośrednictwem
strumienia cout:
#include

void main(void)
{
char alfaber[27]; //26 liter plus znak NULL
char litera;
int indeks;

for (litera = 'A', indeks = 0; litera <= 'Z'; litera++, indeks++)
alfabet[indeks] = litera;

alfabet[indeks] = NULL;

cout << "Litery alfabetu: " << alfabet;
}

Jak widzimy, ten program dołącza do tekstu znak NULL, który wskazuje koniec
testu:
alfabet[indeks] = NULL;

Strumień wyjściowy cout wyświetla znaki tekstu po jednym, aż do napotkania znaku
NULL. Krótko mówiąc, symbol NULL informuje program o końcu tekstu.
Przyjrzyj się dobrze pętli for w przedstawionym programie. Jak widzisz, pętla
nadaje wartości początkowe i zwiększa dwie zmienne (litera i indeks). Gdy w
pętli inicjalizowana lub zwiększana jest więcej niż jedna zmienna, to należy
rozdzielać te operacje przy użyciu przecinków:
for (litera = 'A', indeks = 0; litera <= 'Z'; litera++, indeks++)



C++ automatycznie dołącza NULL do stałych tekstowych
We wszystkich programach utworzonych podczas czytania tej książki używaliśmy
stałych tekstowych umieszczanych w cudzysłowach, np.
"To jest tała typu tekst."

Gdy tworzysz stałą tekstową, to kompilator języka C++ automatycznie dołącza na
jej końcu znak NULL, jak widać na rysunku 6.
Rysunek 6.
Kompilator języka C++ automatycznie dołącza na końcu stałej tekstowej znak NULL






Gdy w programach wyświetlasz teksty przy użyciu strumienia wyjściowego cout, to
strumień cout wykorzystuje dołączany przez kompilator znak NULL do ustalenia,
kiedy ma przestać wyświetlać ciąg znaków.
Używanie znaku NULL
Tekst (string) jest tablicą znaków zakończoną symbolem NULL ('\O'). Deklarując
tekst tworzysz tablicę typu char. Gdy później w programie przypisujesz tekstowi
znaki, to jesteś odpowiedzialny za dołączenie symbolu NULL oznaczającego koniec
tekstu.
Gdy używasz stałych tekstowych ujętych w cudzysłowy, to kompilator języka C++
automatycznie dołącza na ich końcu znak NULL. Większość funkcji C++ wykorzystuje
ten symbol do ustalenia ostatniego znaku tekstu.
Przedstawiony poniżej program PETLANULL.CPP jest nieznaczną modyfikacją
poprzedniego programu. Wyświetla on znaki tekstu alfabet w pętli for:
#include

void main(void)
{
char alfabet[27]; //26 liter plus znak NULL
char litera;
int indeks;

for (litera = 'A', indeks = 0; litera <= 'Z'; litera++, indeks++)
alfabet[indeks] = litera;

alfabet[indeks] = NULL;

for (index = 0; alfabet[indeks] != NULL; index++)
cout << alfabet[indeks];

cout << endl;
}

Jak widzimy, w jednym obrocie pętli for jest sprawdzany jeden znak tekstu. Jeśli
ten znak jest różny od symbolu NULL (oznaczającego koniec tekstu), to pętla go
wyświetla, zwiększa indeks i powtarza proces.


W jaki sposób 'A' różni się od "A"
Analizując programy w C++ możesz napotykać znaki ujęte w apostrofy (np. 'A') i
znaki w cudzysłowach ("A"). Symbol w apostrofach to stała znakowa. Kompilator
języka C++ przydziela w pamięci komputera tylko jeden bajt, w którym ma być
przechowywana stała znakowa. Natomiast znak w cudzysłowach to stała tekstowa,
czyli dany znak oraz symbol NULL (dołączany przez kompilator). W związku z tym
kompilator przydziela temu tekstowi dwa bajty. Rysunek 7 pokazuje, w jaki sposób
kompilator C++ umieszcza w pamięci stałą znakową 'A' i stałą tekstową "A".
Rysunek 7.
Jak kompilator C++ umieszcza w pamięci stałą znakową 'A' i stałą tekstową "A"




Inicjalizowanie tekstów
Jak wiesz z lekcji 16, można w C++ nadawać tablicy wartość początkową przy
deklaracji. Teksty C++ nie stanowią pod tym względem wyjątku. Aby
zainicjalizować tekst przy deklaracji, po prostu podajesz odpowiedni ciąg znaków
ujęty w cudzysłowy, tak jak tutaj:
char tytul[64] = "Wygraj z C++";

Jeśli liczba znaków w tekście przypisywanym zmiennej jest mniejsza od rozmiaru
tablicy, to większość kompilatorów C++ przypisuje pozostałym elementom tablicy
symbol NULL. Analogicznie, jak dla pozostałych tablic, jeśli nie podajesz w
deklaracji rozmiaru tablicy tekstowej, której nadajesz wartość początkową, to
kompilator C++ przydzieli jej tyle pamięci, ile jest potrzebne na przechowywanie
podanych znaków i znaku NULL:
char tytul[] = "Wygraj z C++";

Przedstawiony poniżej program INITEKST.CPP nadaje tekstowi wartość początkową
przy deklaracji:
#include

void main(void)
{
char tytul[64] = "Wygraj z C++";
char lekcja[64] =
"Przechowywanie tekstów (string) i operacje na nich";

cout << "Książka: " << tytul << endl;
cout << "Lekcja: " << lekcja << endl;
}

W wielu programach, które przedstawimy w dalszej części tej książki, teksty będą
inicjalizowane w ten sposób. A teraz w ramach ćwiczeń zmień kilkakrotnie znaki
przypisywane przez ten program tekstom i zobacz, jak program będzie działać.


Przekazywanie tekstów funkcjom
Przekazywanie tekstu funkcji jest bardzo podobne do przekazywania tablicy jako
parametru. W nagłówku funkcji musisz tylko podać typ tablicy (char), a za nim
nawiasy kwadratowe. Nie trzeba tym razem podawać rozmiaru tablicy. Na przykład
przedstawiony poniżej program PISZTEKS.CPP wyświetla na ekranie tekst przy
użyciu funkcji pisz_tekst:
#include

void pisz_tekst (char tekst[])
{
cout << tekst << endl;
}

void main(void)
{
pisz_tekst ("Cześć C++!");
pisz_tekst ("Ocalenie dzięki C++");
}

Jak widzimy, funkcja pisz_tekst traktuje parametr tekstowy jako tablicę:
void pisz_tekst (char tekst[])

Ponieważ symbol NULL oznacza koniec tekstu. funkcji nie jest potrzebny parametr
określający liczbę elementów tablicy. Funkcja może przecież ustalić, który znak
jest ostatni wyszukując w tablicy symbol NULL.
Jak już wiesz, funkcje C++ często wykorzystują znak NULL do ustalenia końca
tekstu. Przedstawiony poniżej program DLTEKSTU.CPP tworzy funkcję dlug_tekstu,
która wyszukuje w tekście znak NULL i ustala w ten sposób liczbę znaków w tym
tekście. Następnie funkcja zwraca do programu długość tekstu przy użyciu
instrukcji return. Program przekazuje funkcji różne teksty i wyświetla na
ekranie ich długości:
#include

int dlug_tekstu (char tekst[])
{
int i;

for (i = 0; tekst[i] != '\0'; i++); /*Przechodzenie w pętli
znaków tekstu. Poza tym
pętla nic nie robi.*/
return (i); //Długość tekstu
}

void main(void)
{
char tytul[64] = "Wygraj z C++";
char lekcja[64] =
"Przechowywanie tekstów (string) i operacje na nich";

cout << "Tekst " << tytul << " zawiera " << dlug_tekstu(tytul) <<
" znaków" << endl;

cout << "Tekst " << lekcja << " zawiera " << dlug_tekstu(lekcja) <<
" znaków" << endl;
}

Jak widzimy, funkcja zaczyna od pierwszego (o indeksie 0) znaku tekstu i
sprawdza każdy element aż do napotkania symbolu NULL. W innych programach w C++
często będziesz spotykać się z funkcjami, które ten sposób wyszukują w tekstach
znak NULL.


Korzystaj z faktu, że NULL to znak ASCII o kodzie 0
Jak już wiesz, symbol NULL to znak o kodzie ASCII 0. Podczas lekcji 7 mówiliśmy,
że w C++ wartość 0 reprezentuje fałsz. W związku z tym, ponieważ znak NULL jest
równy 0, można uprościć wiele operacji pętli. Na przykład wiele funkcji
analizuje kolejne znaki tekstów v.; poszukiwaniu symbolu NULL. Następująca pętla
for ilustruje, w jaki sposób program może wyszukiwać znak NULL w tekście:
for (indeks = 0; tekst[indeks] != NULL; indeks++)
;

Ponieważ znak NULL jest równy 0, to w wielu programach pętle przeszukujące tekst
są uproszczone do takiej postaci:
for (indeks = 0; tekst[indeks] ; indeks++)
;

W tym przykładzie pętla jest wykonywana tak długo, jak długo znak tekst [indeks]
nie jest równy NULL (0 czyli fałsz).


Korzystanie z funkcji biblioteki run-time
Z lekcji 11 wiesz, że większość kompilatorów daje Ci do dyspozycji uniwersalny
zbiór funkcji noszący nazwę biblioteki run-time. Możesz w niej znaleźć wiele
różnych funkcji operujących na tekstach. Na przykład funkcja strupr zamienia
małe litery w tekście na duże. Analogicznie funkcja strlen zwraca liczbę znaków
tekstu, a funkcja strlwr zamienia duże litery tekstu na małe. W większości
bibliotek run-time znajdziesz funkcje wyszukujące w tekstach podane znaki.
Przedstawiony poniżej program STRUPR.CPP pokazuje, w jaki sposób korzystać z
funkcji strup i strlwr:
#include
#include //Prototypy funkcji operujących na tekstach

void main(void)
{
char tytul[64] = "Wygraj z C++";
char lekcja[64] =
"Przechowywanie tekstów (string) i operacje na nich";

cout << "Duże litery: " << strupr (tytul) << endl;
cout << "Małe litery: " << strlwr (lekcja) << endl;
}

Korzystając z funkcji operowania na tekstach biblioteki run-time możesz
zaoszczędzić wiele czasu programowania. Poświęć teraz nieco czasu na
wydrukowanie pliku nagłówkowego string.h i zobacz, jakie funkcje dla tekstów
oferuje biblioteka twojego kompilatora.
Musisz przestrzegać reguł gry
Jak już mówiliśmy, większość funkcji operujących na tekstach działa w oparciu o
założenie, że ostatnim znakiem tekstów jest NULL. Jeśli w programach
przypisujesz tekstom znaki, to musisz w nich umieszczać znak NULL na końcu
tekstów. Jeśli nie będziesz konsekwentnie przestrzegać tej zasady, to funkcje
operujące na tekstach nie będą działać.


Zapamiętaj
Większość programów w C++ szeroko wykorzystuje teksty (ciągi znaków). Podczas
tej lekcji dowiedziałeś się, w jaki sposób operować na tekstach. Podczas lekcji
18 nauczysz się, jak przechowywać informacje różnych typów w strukturach języka
C++. Przy użyciu struktur możesz przechowywać jako jedną zmienną takie dane jak
nazwisko pracownika, jego wiek, zarobki i numer telefonu. Zanim jednak
przejdziemy do następnej lekcji upewnij się, że opanowałeś już następujące
zagadnienia podstawowe:
Tekst (string) to tablica znaków zakończona znakiem ASCII 0, zwanym NULL.
Aby utworzyć w programie tekst, należy zadeklarować tablicę typu char.
Musisz w programie umieszczać znak NULL na końcu tekstów (nie dotyczy to
stałych tekstowych).
Dla stałych tekstowych umieszczonych w cudzysłowach kompilator C++
automatycznie dołącza do nich znak NULL.
Możesz tekstom przypisywać wartość początkową przy ich deklaracji, podając
odpowiednie znaki w cudzysłowach.
Większość kompilatorów daje Ci do dyspozycji obszerny zbiór bibliotecznych
funkcji operujących na tekstach.



WsteczSpis treściDalej



Wyszukiwarka

Podobne podstrony:
Kris Jamsa Wygraj Z C lekcja32
Kris Jamsa Wygraj Z C lekcja 5
Kris Jamsa Wygraj Z C lekcja23
Kris Jamsa Wygraj Z C lekcja38
Kris Jamsa Wygraj Z C lekcja35
Kris Jamsa Wygraj Z C lekcja20
Kris Jamsa Wygraj Z C lekcja27
Kris Jamsa Wygraj Z C lekcja34
Kris Jamsa Wygraj Z C lekcja17
Kris Jamsa Wygraj Z C lekcja25
Kris Jamsa Wygraj Z C lekcja14
Kris Jamsa Wygraj Z C lekcja36
Kris Jamsa Wygraj Z C lekcja 4
Kris Jamsa Wygraj Z C lekcja33
Kris Jamsa Wygraj Z C lekcja 7
Kris Jamsa Wygraj Z C lekcja30
Kris Jamsa Wygraj Z C lekcja12
Kris Jamsa Wygraj Z C lekcja28
Kris Jamsa Wygraj Z C lekcja 6

więcej podobnych podstron