source
bool Calculator::Execute (Input const & input)
{
int token = input.Token ();
bool status = false; // zakładamy pojawienie się błędu
if (token == tokError)
{
cout << "Nieznany zeton\n";
}
else if (token == tokNumber)
{
if (_stack.IsFull ())
{
cout << "Stos jest pelny!\n";
}
else
{
_stack.Push (input.Number ());
status = true; // sukces
}
}
else
{
assert (token == '+' || token == '-'
|| token == '*' || token == '/');
if (_stack.IsEmpty ())
{
cout << "Stack is empty\n";
}
else
{
int num2 = _stack.Pop ();
int num1;
// Przypadek specjalny - na stosie jest tylko jedna liczba:
// traktujemy ja jednocześnie jako lewy i prawy argument operatora.
if (_stack.IsEmpty ())
num1 = num2;
else
num1 = _stack.Pop ();
_stack.Push (Calculate (num1, num2, token));
status = true;
}
}
return status;
}
|
W powyższym kodzie wykorzystaliśmy rozszerzoną wersję instrukcji warunkowej if -- instrukcję if/else. Treść instrukcji, znajdującej się za słowem kluczowym else, wykonywana jest tylko wtedy, gdy nie był spełniony warunek wykonania odpowiedniej instrukcji if (w języku polskim if można czytać "jeśli", a else -- "w przeciwnym wypadku", przyp. tłum.).
Instrukcje if/else można ze sobą łączyć w większą całość:
if (A)
... // jeśli A
else if (B)
... // jeśli nie-A i tak-B
else if (C)
... // jeśli nie-A i nie-B i tak-C
else
... // jeśli nie-A i nie-B i nie-C
|
Metoda Calculate jest nową metodą klasy Calculator. Ponieważ będziemy się nią posługiwać wyłącznie w implementacji kalkulatora, jej definicję umieściliśmy w sekcji prywatnej. Metoda ta ma trzy argumenty (liczba, liczba, żeton) i zwraca jako swoją wartość wynik działania arytmetycznego. Powodem zapisania kodu wyznaczającego wynik działania w osobnej metodzie było zbytnie rozrośnięcie się kodu metody Execute. Metoda Calculate ma ściśle określone przeznaczenie i jest w dużym stopniu niezależna od reszty programu. Zaimplementowałem ją przy pomocy jednej, złożonej instrukcji if/else.
int Calculator::Calculate (int num1, int num2, int token) const
{
int result;
if (token == '+')
result = num1 + num2;
else if (token == '-')
result = num1 - num2;
else if (token == '*')
result = num1 * num2;
else if (token == '/')
{
if (num2 == 0)
{
cout << "Dzielenie przez zero\n";
result = 0;
}
else
result = num1 / num2;
}
return result;
}
|
Proszę zwrócić uwagę na sposób posługiwania się w programie literałami znakowymi, np.
'+', '-', '*', '/' |
Literały znakowe otaczamy pojedynczymi cudzysłowami (jak już wiemy, podwójnymi znakami cudzysłowu otaczamy literały napisowe). W naszym programie zamiast przypisać żetonom operatorowym pewne specjalne wartości, po prostu skorzystaliśmy z wartości odpowiednich literałów znakowych (wartości kodów ASCII).
Przyjrzyjmy się teraz zmodyfikowanej definicji klasy Calculator.
class Calculator
{
public:
bool Execute ( Input& input );
// Metoda GetStack udostępnia stos
IStack const & GetStack () const { return _stack; }
private:
int Calculate (int n1, int n2, int token) const;
IStack _stack;
};
|
Po napisaniu pełnej implementacji klasy Calculator możemy teraz do naszego programu dołączyć napisane w poprzednich rozdziałach implementacje klas IStack i StackSeq, rozszerzyć tymczasową implementację klasy Input (chodzi tu o rzetelną implementację jej metod Token i Number), całość skompilować i przetestować.
Implementacja klasy Input
Obecnie przystępujemy do napisania rzeczywistej implementacji klasy Input. Jednocześnie nadszedł czas, by nasz projekt podzielić na kilka plików. Zdecydowałem, że program będzie się składał z trzech plików nagłówkowych -- calc.h, stack.h, input.h -- oraz trzech plików implementacyjnych -- calc.cpp, stack.cpp i input.cpp. Ogólnie rzecz biorąc, żeby z kilku plików źródłowych można było utworzyć program wykonywalny, należy skorzystać ze specjalnego programu, zwanego konsolidatorem (ang. linker). Na szczęście użytkownicy zintegrowanych środowisk programistycznych mogą uprościć sobie ten proces, tworząc po prostu tzw. projekt i dodając do niego wszystkie pliki, wchodzących w skład programu. Po wykonaniu tej czynności program wykonywalny można utworzyć (ang. build) jednym kliknięciem myszki. Szczegółowe omówienie pracy z projektami znajdzie Czytelnik w instrukcji obsługi swojego środowiska programistycznego.
Doświadczenie uczy, że im więcej w projekcie mamy plików nagłówkowych, tym większa szansa, że ten sam plik włączymy gdzieś dwukrotnie. Jak to możliwe? Przypuśćmy, że plik input.h włączamy do programu wewnątrz pliku calc.h. Następnie oba te pliki nagłówkowe włączamy w pliku calc.cpp. I mamy kłopot. Kompilator zobaczy bowiem dwie definicje klasy Input (co prawda są identyczne, ale dla kompilatora nie ma to żadnego znaczenia). Przed takim konfliktem można się zabezpieczyć, stosując w plikach nagłówkowych dyrektywy kompilacji warunkowej.W tym celu całą treść pliku input.h umieszczamy wewnątrz bloku #if...#endif.
#if !defined input_h ... #endif |
Kompilator przetworzy instrukcje, zawarte pomiędzy tymi dyrektywami preprocesora tylko wtedy, gdy nie zdefiniowano jeszcze symbolu input_h. Dowcip polega na tym, że przy pierwszej próbie przetworzenia tego pliku symbol input_h nie jest zdefiniowany. Dlatego gdy kompilator po raz pierwszy dotrze do dyrektywy #include "input.h", posłusznie przetworzy całą zawartość pliku input.h. Jednakże pierwszą czynnością, którą wykonujemy w bloku if...endif jest zdefiniowanie symbolu input_h
#define input_h
|
Dlatego, gdy kompilator kolejny raz dotrze do dyrektywy #include "input.h", stwierdzi, że symbol input_h już zdefiniowano, więc w pliku "input.h" pominie wszystkie instrukcje zawarte pomiędzy dyrektywami #if !defined input_h i #endif
#if !defined input_h // zabezpieczenie przed wielokrotnym włączeniem #define input_h const int maxBuf = 100; // Możliwe żetony: tokNumber, tokError, +, -, *, /. const int tokNumber = 1; const int tokError = 2; // Klasa Input pobiera dane z stdin i zamienia je na żeton (token). class Input { public: Input (); int Token () const { return _token; } int Number () const; private: int _token; char _buf [maxBuf]; }; #endif // input_h |
Zwróćmy uwagę na modyfikator const w deklaracjach metod Token i Number. Mimo iż ogólnie rzecz biorąc ogranicza on dostęp do tych metod, jednak nie dotyczy to kalkulatora, który posługuje się obiektem klasy Input za pośrednictwem stałej (const) referencji. Natomiast składowa _buf służy jako bufor przechowujący wprowadzony przez użytkownika łańcuch znaków.
W pliku input.cpp włączamy dwa standardowe pliki nagłówkowe.
#include <cctype> #include <cstdlib> |
Plik cctype zawiera definicje (bardzo efektywnych) makr, służących do rozpoznawania rodzaju znaków. Na przykład makro isdigit zwraca true, jeżeli znak odpowiada jednej z cyfr dziesiętnych ('0',...,'9'), w przeciwnym przypadku jego wartością jest false. Drugi plik, cstdlib, zawiera deklarację funkcji atoi, która służy do konwersji łańcucha znaków ASCII na odpowiadającą jej liczbę całkowitą. Więcej informacji o tych i podobnych im funkcjach znajduje się w opisie biblioteki standardowej. Znajdziemy go w systemie pomocy online, instrukcji obsługi kompilatora lub w innych książkach.
Input::Input ()
{
cin >> _buf;
// zazwyczaj żeton można zidentyfikować już na po przeczytaniu pierwszego znaku
int c = _buf [0];
if (isdigit (c))
_token = tokNumber;
else if (c == '+' || c == '*' || c == '/')
_token = c;
else if (c == '-') // uwzględniamy liczby ujemne
{
if (isdigit (_buf [1])) // sprawdzamy następny znak
_token = tokNumber;
else
_token = c;
}
else
_token = tokError;
}
|
Konstruktor klasy Input odczytuje ze standardowego strumienia wejściowego wiersz tekstu i umieszcza go w buforze znaków. To jeszcze jedna niesamowita sztuczka, którą potrafi wykonać obiekt std::cin (oczywiście na bieżącym etapie konstrukcji programu nawet nie myślimy o tym, co mogłoby się zdarzyć, gdyby w buforze zabrakło miejsca na cały napis; wciąż bowiem tworzymy kod na poziomie programisty niedzielnego).
Rodzaj żetonu określamy na podstawie pierwszego znaku w buforze. Proszę zwrócić uwagę na szczególny sposób przetwarzania znaku "minus". Może on bowiem oznaczać zarówno minus unarny (np w wyrażeniu -7), jak i binarny (np. w wyrażeniu 3 - 4). Żeby rozstrzygnąć, z którym operatorem mamy akurat do czynienia, sprawdzamy wartość następnego znaku w buforze. Jeśli chodzi o rozstrzygnięcie, czy dany znak reprezentuje cyfrę dziesiętną ('0', '1', '2',... lub '9'), użycie makra isdigit jest lepszym pomysłem na stwierdzenie niż kod typu
if ( c >= '0' && c <= '9' ) |
Makro isdigit posługuje się algorytmem tablicowym i działa nieco szybciej, niz powyższy kod. W pliku nagłówkowym cctype znajdują sie także definicje innych użytecznych makr, np. isspace (czy znak jest tzw. białym znakiem), islower (czy znak jest małą literą) i isupper (czy znak jest dużą literą).
Jeżeli mamy do czynienia z żetonem liczbowym (tokNumber), kalkulator chciałby poznać wartość tej liczby. Informację tę może on otrzymać z obiektu klasy Input poprzez jego metodę Number, która zamienia przechowywany w buforze napis na liczbę typu int. W tym celu metoda Number posługuje się standardową funkcją atoi, zadeklarowaną w pliku cstdlib.
int Input::Number () const
{
assert (_token == tokNumber);
return atoi (_buf); // zamiana napisu na liczbę całkowitą (int)
}
|
Plik makefile
Część Czytelników być może nie chce lub nie może posługiwać się zintegrowanym środowiskiem programistycznym. W sytuacji, gdy projekt rozrasta się na tyle, że chcemy lub musimy podzielić go na kilka plików, prawdopodobnie nadszedł czas, by zacząć posługiwać się programem narzędziowym make. Poniżej przedstawiam bardzo uproszczony plik makefile, w którym zdefiniowano zależności pomiędzy różnymi plikami, wchodzącymi w skład projektu. W pliku tym określono także, w jaki sposób należy utworzyć kod wykonywalny:
calc.exe : calc.obj stack.obj input.obj
cl calc.obj stack.obj input.obj
calc.obj : calc.cpp calc.h input.h stack.h
cl -c calc.cpp
stack.obj : stack.cpp stack.h
cl -c stack.cpp
input.obj : input.cpp input.h
cl -c input.cpp
|
Jeżeli powyższe instrukcje umieścimy w pliku o nazwie calc.mak, to proces kompilacji programu inicjujemy komendą make calc.mak (lub nmake calc.mak). Spowoduje ona przeprowadzenie wszystkich niezbędnych etapów kompilacji i konsolidację uzyskanych w ten sposób kodów pośrednich (*.obj) do pliku wykonywalnego calc.exe. Szczegółowe omówienie programu make (lub nmake) znajdzie Czytelnik w systemie pomocy online lub instrukcji obsługi kompilatora. Program make jest podstawową metodą kompilacji dużych projektów w środowisku systemu operacyjnego Unix (przyp. tłum.).