Rozdział 4. Używanie pamięci

Potrafisz już napisać i skompilować program wyświetlający napisy w oknie konsoli. Nie jest to może oszałamiająca umiejętność, ale to już coś, jak na początek.

Dobrze by było, gdybyśmy potrafili pobierać dane od użytkownika i robić z nimi coś użytecznego. Ale tym zajmiemy się dopiero w następnym rozdziale, gdzie napiszemy nasz pierwszy interaktywny program, który będzie żądał od użytkownika podania potrzebnych mu informacji.

W tym rozdziale natomiast czeka nas ciężka praca, ponieważ poznamy w nim jedną z fundamentalnych konstrukcji programistycznych — dowiemy się czym są zmienne.

Podstawową funkcją zmiennych w programowaniu jest umożliwienie programiście zapisania czegoś w pamięci komputera, aby móc tego użyć w późniejszym czasie. Zapewne nie raz miałeś w rękach kalkulator. Większość tych urządzeń ma przyciski oznaczone symbolami M+, M- i MC, które służą do zapisywania w pamięci kalkulatora pośrednich wyników obliczeń i pobierania ich z powrotem, gdy są potrzebne. Podobną funkcję pełnią zmienne w komputerach, które tak naprawdę są niczym innym, jak niesamowicie wydajnymi i rozbudowanymi maszynami liczącymi.

Gdy nauczysz się deklarować zmienne, będziesz mógł pisać interaktywne programy proszące użytkowników np. o podanie wieku albo wpisanie imienia i nazwiska.

4.1. Co to jest zmienna

Powyżej przywołałem przykład użycia pamięci kalkulatora do wykonywania obliczeń, ponieważ w świecie informatyki wykorzystywana jest podobna zasada. W komputerze znajdują się pewne urządzenia elektroniczne, w których można zapisywać i przechowywać informacje. Niestety sposób ich działania jest bardzo skomplikowany.

Wystarczy jednak wiedzieć, że zmienna to cząstka pamięci, którą komputer udostępnia nam, abyśmy mogli w niej zapisać swoją wartość. Wyobraź sobie, że wewnątrz komputera znajduje się wielka szafa, zawierająca miliardy maleńkich szufladek, w których możemy przechowywać nasze zmienne.

Pamięć kalkulatora jest bardzo prosta i można w niej przechowywać najwyżej jedną wartość na raz. Zapewne zdajesz sobie sprawę, że pisząc program komputerowy będziesz potrzebować miejsca do jednoczesnego przechowywania wielu różnych wartości. W związku z tym, aby dało się znaleźć wybrane zmienne, muszą one być w jakiś sposób rozróżniane. Do tego służą nazwy zmiennych. Każda zmienna ma swoją etykietę, która jest jak naklejka przyklejona na froncie szufladki.

Kolejną rzeczą, która odróżnia kalkulator od komputera jest to, że w komputerze można przechowywać różne wartości — liczby, litery, słowa, obrazy itd. Są to typy zmiennych. Porównując to z naszą szafą, w niektórych szufladkach przechowujemy butelki, w innych książki itd.

4.1.1. Nazwy zmiennych

Na początek omówimy kwestię nazewnictwa zmiennych. W języku C++ istnieją pewne zasady, których musimy przestrzegać podczas wymyślania nazw dla zmiennych.

• Nazwa zmiennej może składać się wyłącznie z liter, cyfr i znaków podkreślenia.
• Pierwszym znakiem nazwy zmiennej musi być wielka lub mała litera.
• Nie można używać liter z ogonkami i akcentami.
• Nie można używać spacji.

Najlepiej zasady te przyswoić sobie poprzez obejrzenie konkretnych przykładów. Następujące nazwy zmiennych są poprawne: rokZero, raz_dwa_trzy, CYFRA_ZERO. Natomiast wartośćWynikowa i _wynik są niepoprawne.

Jest jeszcze jedna ważna zasada, która dotyczy nie tyle samych nazw zmiennych, co w ogóle wszystkiego, co piszemy w języku C++. W języku tym rozpoznawana jest wielkość liter. W związku z tym cyfraZero, cyfrazero i CYFRAZERO to są trzy różne nazwy.

Ja osobiście trzymam się pewnej powszechnie stosowanej „konwencji”. We wszystkich dużych projektach, w których uczestniczy wielu programistów zasady wydają się bardzo sztywne i przez to trudne do przestrzegania. Dlatego poniżej przedstawiam kilka dodatkowych zasad, których przestrzeganie pozwoli Ci pisać czytelny kod i znajomość których pozwoli Ci bez trudu zrozumieć przykłady prezentowane w dalszych częściach tego kursu.

• Nazwy zmiennych zaczynaj małą literą.
• Jeśli nazwa składa się z kilku słów, słowa te niech będą ze sobą połączone.
• Każde kolejne słowo po pierwszym zaczynaj od wielkiej litery.

Zobaczmy kilka przykładów nazw, jakie można by było nadać zmiennej do przechowywania wieku użytkownika komputera.

• WiekUzytkownika: nie podoba się nam, bo pierwsza litera jest wielka.
• wiek_uzytkownika: nie podoba się nam, bo słowa nie są ze sobą sklejone.
• wiekuzytkownika: nie podoba się nam, bo drugie słowo nie zaczyna się od wielkiej litery.
• wiekUzytkownika: dobrze.

Gorąco zachęcam Cię do przestrzegania tej konwencji. Pisanie kodu w sposób zrozumiały dla innych programistów jest bardzo ważnym elementem pracy programisty.

4.1.2. Typy zmiennych

Przypomnijmy: wcześniej dowiedzieliśmy się, że każda zmienna ma nazwę i typ. Wiemy już jak nadawać nazwy zmiennym, a więc teraz chcielibyśmy poznać ich typy. Komputery uwielbiają wiedzieć, co znajduje się w ich pamięci i dlatego musimy deklarować, jakiego rodzaju dane będą przechowywane w tworzonych przez nas zmiennych. Mogą to być np. liczby, słowa lub litery. Niezależnie od tego, co to ma być, trzeba komputer o tym poinformować.

W poniższej tabeli znajduje się lista typów zmiennych, których można używać w języku C++ (istnieją jeszcze inne typy, ale są one rzadziej używane.).

Gdy wpiszesz nazwę jednego z tych typów w swoim IDE, zauważysz, że zmieni ona kolor. Przypadek typu łańcuchowego jest inny, ale bardziej szczegółowo omówimy to nieco później. Zapewniam Cię, że będzie do czego wracać.

Gdy zatem potrzebujemy zmiennej, najpierw musimy się zastanowić, jakiego typu dane będziemy w niej przechowywać. Jeżeli potrzebujesz miejsca do zapisania liczby użytkowników Twojego programu, użyj typu int lub unsigned int, jeśli chcesz zapisać wagę tucznika, użyj typu double, natomiast aby zapisać imię swojego najlepszego kolegi użyj typu łańcuchowego, czyli string.

A do czego służy typ bool? Nigdy wcześniej o czymś takim nie słyszałem. Typ bool to tzw. typ logiczny. Zmienne tego typu mogą przyjmować tylko dwie wartości oznaczające prawdę (true) lub fałsz (false). Przechowujemy w nich informacje będące odpowiedziami na pytania w rodzaju „czy światło jest zapalone?”, „czy użytkownik może używać tej funkcji?”, „czy hasło jest poprawne?”.

Jeśli zatem musisz zapisać gdzieś odpowiedź na tego rodzaju pytanie, to możliwe, że użycie do tego celu zmiennej logicznej będzie dobrym wyborem.

4.1.3. Deklarowanie zmiennych

Czas przejść do działania i poprosić komputer, aby udostępnił nam jedną ze swoich szufladek na dane. Fachowo czynność tę nazywa się definicją zmiennej.

Aby zdefiniować zmienną, należy określić typ zmiennej, podać jej nazwę oraz wpisać wartość. Jest to bardzo proste. Wymienione informacje piszemy w następującej kolejności:

typ nazwa (wartość);

Można także stosować składnię języka C:

typ nazwa = wartość;

Obie powyższe wersje są równoważne. Zalecam jednak używanie pierwszej z nich z powodów, które staną się jasne nieco później. Drugiego rodzaju notacji nie będziemy używać w dalszej części tego kursu, ale pokazałem ją dlatego, abyś nie miał problemów ze rozumieniem wielu przykładów, jakie można znaleźć w różnych książkach i internecie, w których ta składnia jest właśnie używana.

Wrócimy do naszego podstawowego kodu programu i dodamy do niego zmienną do przechowywania wieku użytkownika.

#include <iostream>
using namespace std;

int main()
{
int wiekUzytkownika (16);
    return 0;
}

Co oznacza instrukcja znajdująca się w szóstym wierszu tego kodu? Za jej pomocą informujemy komputer, że chcemy od niego pożyczyć jedną z jego szufladek o następujących właściwościach:

• Musi nadawać się do przechowywania liczb całkowitych.
• Musi mieć plakietkę określającą jej nazwę wiekUzytkownika.
• Musi zawierać liczbę 16.

Zatem od tego wiersza kodu stajemy się szczęśliwymi posiadaczami szufladki w pamięci komputera.

Ponieważ w trakcie kursu będziemy potrzebować wielu takich szufladek, postaraj się jak najszybciej zapamiętać przedstawioną notację i się do niej przyzwyczaić.

Poniżej znajduje się rysunek, który pomoże Ci dobrze zrozumieć, czym jest zmienna w komputerze.

Duży prostokąt reprezentuje pamięć komputera. Na razie jest ona prawie pusta. Żółty kwadrat to fragment pamięci, w którym wcześniej zapisaliśmy naszą wartość. Jest to nasza szufladka zawierająca liczbę 16 i plakietkę wiekUzytkownika.

Skoro tak nam dobrze idzie, zdefiniujemy jeszcze kilka innych zmiennych.

Kilka dodatkowych definicji zmiennych w języku C++:

#include <iostream>
using namespace std;

int main()
{
    int wiekUzytkownika (16);
    int liczbaZnajomych(432);      // Liczba znajomych użytkownika

    double pi(3.14159);

    bool jestMoimZnajomym (true);    // Czy ten użytkownik jest moim znajomym?

    char litera ('a');

    return 0;
}

W powyższym kodzie należy zwrócić uwagę na dwie rzeczy. Po pierwsze zmienne typu bool mogą mieć tylko jedną z dwóch wartości, true lub false, którą należy wpisać w nawiasie za nazwą zmiennej. Po drugie w przypadku zmiennych typu znakowego, char, należy pamiętać, że będąca ich wartością litera musi znajdować się między apostrofami. Poprawny zapis to char litera('a');, nie zaś char litera(a);. To kolejny powszechnie spotykany błąd, przed którym ja również czasami nie potrafię się ustrzec.

Spójrzmy jeszcze raz na nasz rysunek po uwzględnieniu na nim nowych zmiennych.

Możesz skompilować i przetestować powyższy program. Niestety jak na razie nic konkretnego jeszcze on nie robi. Jeśli czujesz się rozczarowany, to może zainteresuje Cię informacja, że tak naprawdę wbrew pozorom po uruchomieniu tego programu dzieje się bardzo dużo, tylko że tego nie widać. Na razie jednak nie interesuje nas to. Poniżej przedstawiam tylko skrócony opis tych zdarzeń:

1. Program poprosił system operacyjny o dostęp do fragmentu pamięci.
2. System sprawdził czy ma wystarczającą ilość pamięci i wskazał programowi, której szufladki może użyć.
3. Program zapisał w swojej szufladce liczbę 16.
4. Następnie program wykonał te same czynności, aby utworzyć pozostałe zmienne i zapisać w nich wartości.
5. Wykonując ostatni wiersz swojego kodu program opróżnił swoje szufladki i zwrócił je komputerowi.

To wszystko odbywa się bez wyświetlania czegokolwiek na ekranie. To normalne, ponieważ przecież nie napisaliśmy żadnej instrukcji nakazującej cokolwiek wyświetlać.

4.2. Łańcuchy znaków

Składnia definicji łańcuchów jest nieco bardziej skomplikowana, ale to oczywiście nie znaczy, że jest trudna do opanowania. Pierwsze, co należy zrobić, to dodać na początku programu linijkę kodu, za pomocą której poinformujemy kompilator, że w tym programie używane są łańcuchy. Bez tego aplikacja nie zawierałaby wszystkich potrzebnych do działania narzędzi. Kod, który należy dodać, to #include <string>:

Definiowanie łańcucha w języku C++:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string imieUzytkownika ("Albert Einstein");
    return 0;
}

Druga różnica w składni zmiennej łańcuchowej w porównaniu z innymi zmiennymi dotyczy sposobu określania wartości. Jak widać w powyższym przykładzie, wartość zmiennej łańcuchowej powinna znajdować się w podwójnym prostym cudzysłowie. Składnia ta jest podobna do składni definicji zmiennych znakowych, lecz zamiast apostrofów używa się tu cudzysłowów. Dzięki temu środowisko programistyczne wartości zmiennych łańcuchowych i znakowych może oznaczać różnymi kolorami. Nie pomyl apostrofu (') z cudzysłowem ("), jeśli nie chcesz narazić się swojemu kompilatorowi.

4.3. Sztuczka pozwalająca zaoszczędzić miejsce

Zanim przejdziemy dalej, chcę abyś poznał pewną sztuczkę, którą stosują niektórzy programiści. Jeśli chcesz zdefiniować kilka zmiennych tego samego typu, możesz je wszystkie wpisać w jednym wierszu i oddzielić od siebie przecinkami:

Kilka definicji zmiennych w jednym wierszu:

int a(2),b(4),c(-1);  // Definicja trzech zmiennych o nazwach a, b oraz c i wartościach  2, 4 i -1

string imie("Albert"), nazwisko("Einstein"); // Definicja dwóch zmiennych łańcuchowych 

4.4. Deklarowanie zmiennych

Znając podstawowe zagadnienia możemy zgłębić nieco szczegółów. Gdy definiujesz zmienną, program tak naprawdę otrzymuje do wykonania dwie instrukcje:

1. Zażądanie od komputera miejsca w pamięci na zapisanie wartości
2. Wstawienie w to miejsce wartości. Ta czynność nazywa się inicjacją zmiennej.

Działania te są wykonywane automatycznie i nie musimy nic dodatkowego robić, aby spowodować ich wykonanie. Warto jednak znać fachową terminologię i wiedzieć, co jak się nazywa.

Okazuje się zatem, że podczas tworzenia zmiennej nie trzeba od razu podawać jej wartości. Można tylko dokonać alokacji zmiennej, nie inicjując jej. Ta czynność nazywa się deklaracją zmiennej. W tym celu należy wpisać tylko jej typ i nazwę:

typ nazwa;

W programie wyglądałoby to tak:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string imieGracza;
    int liczbaGraczy;
    bool czyWygral;         // Czy ten gracz wygrał?

    return 0;
}

Proste, prawda? Jeśli lubisz schematy, to poniżej przedstawiam jeszcze jeden.

Na powyższym rysunku widać, że w pamięci zajęte są trzy szufladki, z których każda ma swoją tabliczkę. Nowością w tym przypadku jest to, że na razie żadna z nich niczego nie zawiera. W następnym rozdziale dowiesz się, jak zmienić zawartość zmiennej, czyli inaczej mówiąc jak sprawić, aby zamiast znaków zapytania pojawiły się jakieś konkretne wartości.

Czas wykonać jakieś działania przy użyciu zmiennych. W końcu może zapełnimy nasz ziejący pustką ekran.

4.5. Wyświetlanie wartości na ekranie

Wcześniej nauczyliśmy się wyświetlać na ekranie tekst. Mam nadzieję, że jeszcze pamiętasz jak to się robi. Na wszelki wypadek przypomnę. Aby wyświetlić coś na ekranie, trzeba użyć instrukcji cout i dwóch nawiasów ostrych <<. Aby zatem wyświetlić zawartość zmiennej, należy tylko w miejsce tekstu wstawić po prostu nazwę tej zmiennej:

cout << wiekUzytkownika;

Proste, prawda? Poniżej znajduje się kompletny program zawierający powyższą instrukcję.

Przykładowy program wyświetlający zawartość zmiennej:

#include <iostream>
using namespace std;

int main()
{
    int wiekUzytkownika(16);
    cout << "Twój wiek: ";
    cout << wiekUzytkownika;
    return 0;
}

Po skompilowaniu program ten wyświetli na ekranie następujący napis:

Twój wiek: 16

Kod tego programu można trochę skrócić umieszczając kilka instrukcji w jednym wierszu. Ponadto dodamy jeszcze znak nowego wiersza.

Przykładowy program wyświetlający zawartość zmiennej:

#include <iostream>
using namespace std;

int main()
{
    int wiekUzytkownika(16);
    cout << "Twój wiek: " << wiekUzytkownika << endl;
    return 0;
}

Możemy też wyświetlić wartości większej liczby zmiennych:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    int iqUzytkownika(150);
    string imieUzytkownika("Albert Einstein");

    cout << "Nazywasz się " << imieUzytkownika << " i masz iloraz inteligencji " << iqUzytkownika << endl;
    return 0;
}

Powyższy program wyświetli na ekranie następujący napis:

Nazywasz się Albert Einstein i masz iloraz inteligencji 150

W następnym rozdziale pokażę Ci jak zrobić coś jeszcze ciekawszego, tzn. jak pobrać dane wpisane przez użytkownika i zapisać je w zmiennej.

4.6. Referencje

Na zakończenie rozdziału omówimy jeszcze jeden bardzo ważny temat — referencje. Na początku tego rozdziału napisałem, że zmienną można porównać do szufladki w pamięci z naklejoną tabliczką, na której widnieje jej nazwa. W realnym świecie każdemu przedmiotowi możemy nadać wiele nazw i tak samo jest w programowaniu w języku C++ — każdej szufladce w pamięci można przypisać dwie, trzy, cztery itd. tabliczki z nazwą.

W ten sposób uzyskujemy dodatkowe sposoby dostępu do tej samej szufladki w pamięci. To trochę tak, jakbyśmy zmiennej nadawali drugie imię. Fachowo taką dodatkową nazwę zmiennej nazywa się referencją.

Referencje do zmiennej można przedstawić graficznie, jak na poniższym rysunku.

W tym przypadku mamy jedną zmienną, ale z przypisanymi dwiema nazwami. W kodzie źródłowym do tworzenia referencji służy znak &:

int wiekUzytkownika(16);  // Definicja zmiennej
int& mojaZmienna(wiekUzytkownika); // Definicja referencji o nazwie mojaZmienna do zmiennej wiekUzytkownika

W pierwszym wierszu powyższego kodu zarezerwowaliśmy w pamięci szufladkę o nazwie wiekUzytkownika i zapisaliśmy w niej liczbę 16. Natomiast w trzecim wierszu przypisaliśmy tej zmiennej drugą etykietkę. Mamy teraz dwa sposoby dostępu do tego samego miejsca w pamięci komputera.

Mówimy, że mojaZmienna jest referencją do zmiennej wiekUzytkownika.

Sprawdźmy jak to działa. Wyświetlimy zawartość zmiennej wiekUzytkownika na dwa sposoby: normalnie i przy użyciu referencji.

Przykład użycia referencji w języku C++:

#include <iostream>
using namespace std;

int main()
{
    int wiekUzytkownika(18);   // Zmienna do przechowywania wieku użytkownika
    int& mojaReferencja(wiekUzytkownika); // Referencja do zmiennej wiekUzytkownika

    // Od tego miejsca zmiennej wiekUzytkownika i referencji mojaReferencja możemy używać zamiennie.
    // Są to dwie etykiety przypisane tej samej szufladce w pamięci.

    cout << "Masz " << wiekUzytkownika << " lat. (zmienna)"
<< endl; // Stary sposób
    cout << "Masz " << mojaReferencja << " lat. (referencja)"
<< endl;    // Nowy sposób z użyciem referencji

    return 0;
}

Oto wynik działania powyższego programu:

Masz 18 lat. (zmienna)
Masz 18 lat. (referencja)

Zdefiniowanej referencji możemy używać w taki sam sposób, jak samej zmiennej. Nie ma między nimi żadnej różnicy.

Do czego w taki razie to ma służyć? Dobre pytanie. Rzeczywiście, w przedstawionych przykładach spokojnie obeszlibyśmy się bez referencji. Ale wyobraź sobie, że potrzebujemy tej samej zmiennej w dwóch całkiem różnych miejscach programu, które zostały napisane przez różnych programistów. Programista będący autorem pierwszej części ma zamiar pracować na tej zmiennej, natomiast programista drugiej części będzie tylko wyświetlał jej zawartość, a więc wystarczy mu jej alias.

Wydaje Ci się to bez sensu? A jednak referencje są bardzo ważnym elementem języka C++ i będą pojawiać się jeszcze wiele razy w dalszej części tego kursu. Dlatego koniecznie trzeba dobrze zrozumieć ich zastosowanie zanim przejdziemy do bardziej skomplikowanych przykładów kodu.

Powtórzenie

Na zakończenie rozdziału powtórzymy najważniejsze wiadomości:

• Deklaracja zmiennej to czynność polegająca na zażądaniu od komputera, aby pożyczył nam fragment swojej pamięci, żebyśmy mogli w niej coś przechować.
• Do wyświetlania zawartości zmiennych na ekranie służy konstrukcja cout << + nazwaZmiennej.
• Referencja do zmiennej to dodatkowa nazwa zmiennej. Referencje tworzy się za pomocą znaku &, np. int& mojaReferencja(zmienna) — referencja o nazwie mojaReferencja do zmiennej o nazwie zmienna.

Myślę, że tyle informacji jak na jeden rozdział to całkiem sporo. W następnym rozdziale będzie jeszcze ciekawiej, ponieważ nauczysz się odbierać w programie dane od użytkownika i wykonywać na nich działania. Napiszemy też prawdziwy kalkulator.

Tylko dokładnie przestudiuj ten rozdział, aby mieć pewność, że rozumiesz wszystko, co jest związane ze zmiennymi. Od tej pory będą Ci one towarzyszyć każdego dnia i do końca tego kursu.