prof. Jan Bielecki
Visual C++ 6.0
Podstawy programowania
1. Pierwsze kroki
2. Środowisko Visual C++
3. Wskaz
niki i odnośniki
4. Przetwarzanie łańcuchów
5. Posługiwanie się funkcjami
6. Zarządzanie pamięcią
7. Widoczność deklaracji
8. Studia programowe
Dodatki
Priorytety operatorów
Opracowywanie wyrażeń
Konwersje standardowe
Operatory bitowe i warunkowe
Operacje wejścia-wyjścia
Pierwsze kroki
Program jest zbiorem modułów z
ródłowych. Każdy moduł składa się z deklaracji typów, zmiennych i funkcji.
Napis od znaków // do końca wiersza jest komentarzem. Jako taki nie ma wpływu na przebieg wykonania
programu.
Dokładnie jeden moduł, nazywany głównym, zawiera deklarację funkcji main. Wykonanie programu polega na
opracowaniu wszystkich jego globalnych deklaracji, a następnie przystąpieniu do wykonywania instrukcji
zawartych w funkcji main. Zakończenie wykonywania programu następuje po wykonaniu w funkcji głównej
instrukcji return, albo tuż po powrocie z funkcji exit. Może to nastąpić jeszcze przed podjęciem wykonywania
funkcji głównej.
int main(void) // deklaracja funkcji głównej
{
return 0; // instrukcja return
}
void exit(int); // deklaracja funkcji exit
struct Empty { // deklaracja typu Empty
Empty(void)
{
exit(0); // wywołanie funkcji exit
}
};
Empty obj; // deklaracja zmiennej
Program napisano w taki sposób, aby jego wykonanie zakończyło się przed podjęciem wykonywania funkcji
głównej.
Komunikacja z otoczeniem
W najprostszym przypadku, program pobiera dane z klawiatury i wyprowadza je na monitor. Operacje
wprowadzania danych odbywają się za pomocą operatora >>, a operacje wyprowadzania danych za pomocą
operatora <<. Klawiatura jest reprezentowana przez zmienną cin, a monitor przez zmienną cout. Posłużenie się
nimi wymaga użycia dyrektywy #include wyszczególniającej nazwę iostream.h.
Daną wprowadzoną z klawiatury kończy odstęp, uzyskany przez naciśnięcie klawisza Space, Tab albo Enter.
Analiza danych wejściowych następuje wierszami, to jest dopiero po naciśnięciu klawisza Enter. W
szczególności, jeśli program oczekuje 3 danych, to każdą można podać w osobnym wierszu, albo wszystkie
podać w jednym wierszu. Przed wprowadzeniem kolejnej danej pomija się poprzedzające ją odstępy.
Uwaga: Wygodnym sposobem wyprowadzenia odstępu Enter jest użycie symbolu endl, a wygodnym sposobem
wyprowadzenia znaku o kodzie 0 jest użycie symbolu ends.
Ponieważ operacja wejścia-wyjścia dostarcza w miejscu jej użycia jej lewy argument, więc zapis pary instrukcji
cin >> one;
cin >> two;
można uprościć do
1
cin >> one >> two;
Właściwość tę, nazywaną łączeniem operacji, można zastosować także do wyprowadzania danych.
#include
int main(void)
{
int one, two;
cout << "Enter 2 numbers:" << endl;
cin >> one >> two;
cout << "Sum = " << one + two << endl;
return 0;
}
Program wyprowadza zachętę do wprowadzenia 2 liczb, a następnie wyznacza i wyprowadza ich sumę.
Wykonywanie operacji
Wykonanie programu sprowadza się do wykonania operacji na danych. W Dodatku A zamieszczono kompletny
wykaz operacji, a w Dodatku B omówiono zasady opracowywania wyrażeń. Podane tam opisy stanowią istotny
element niniejszego opracowania.
Operacje przypisania
Prosta operacja przypisania ma postać
a = b
w której a i b są wyrażeniami, ale ponadto a jest l-nazwą zmiennej (por. Dodatek B).
Wykonanie operacji polega na przypisaniu zmiennej a wartości wyrażenia b.
Złożona operacja przypisania ma postać
a @= b
w której @= jest jednym z operatorów wymienionych w Dodatku A (np. +=, -=, *= , /=).
Operację a @= b (np. a += b) wykonuje tak, jak operację
a = a + b
ale wymaga się, aby opracowanie a i b było jednokrotne.
Operacja połączenia
Operacja połączenia ma postać
a , b
Jej wykonanie składa się z opracowania wyrażenia a (wyłącznie dla jego skutków ubocznych) oraz z niejawnego
zastąpienia całej operacji nazwą zmiennej reprezentowanej przez wyrażenie b.
2
Uwaga: Nie jest operatorem połączenia przecinek oddzielający parametry i argumenty funkcji.
W szczególności wykonanie instrukcji
return a = 10, cout << a, b = 20;
jest równoważne wykonaniu instrukcji
a = 10;
cout << a;
b = 20;
return b;
Operacje arytmetyczne
Operacje arytmetyczne wykonuje się za pomocą operatorów wymienionych w tabeli Operacje arytmetyczne.
Tabela Operacje arytmetyczne
###
+ (dodawanie) - (odejmowanie)
* (mnożenie) / (dzielenie) % (reszta)
++ (zwiększenie o 1) -- (zmniejszenie o 1)
+= (dodanie) -= (odjęcie)
*= (pomnożenie) /= (podzielenie)
###
Sposób wykonania podstawowych działań arytmetycznych nie wymaga opisu. Należy jedynie zauważyć, że
rezultat dzielenia całkowitego jest całkowity, a argumenty wyznaczania reszty muszą być całkowite (np. 11 / 4
ma wartość 2, a 11 % 4 ma wartość 3).
Operacje przedrostkowe
Wykonanie operacji ++num powoduje zwiększenie wartości zmiennej num o 1. W miejsce wykonania operacji
jest dostarczana nowa wartość num.
Wykonanie operacji --num powoduje zmniejszenie wartości zmiennej num o 1. W miejsce wykonania operacji
jest dostarczana nowa wartość num.
int fix = 10;
cout << ++fix; // 11
cout << fix; // 11
Operacje przyrostkowe
Wykonanie operacji num++ powoduje zwiększenie wartości zmiennej num o 1. W miejsce wykonania operacji
jest dostarczana pierwotna wartość num.
Wykonanie operacji num-- powoduje zmniejszenie wartości zmiennej num o 1 W miejsce wykonania operacji
jest dostarczana pierwotną wartość num.
int fix = 10;
cout << fix--; // 10
cout << fix; // 9
3
Operacje porównania
Operacje porównania wykonuje się za pomocą operatorów wymienionych w tabeli Operacje porównania.
Tabela Operacje porównania
###
== (równe) != (nie równe),
< (mniejsze) > (większe),
<= (mniejsze lub równe) >= (większe lub równe)
###
Jeśli porównanie wyraża orzeczenie prawdziwe, to jego rezultat ma wartość true (prawda). W przeciwnym razie
ma wartość false (fałsz).
Uwaga: Porównanie na równość wykonuje się za pomocą operacji ==, a nie za pomocą operacji =. Zaniedbanie
tego faktu jest z
ródłem trudnych do wykrycia błędów semantycznych.
#include
int main(void)
{
int num = 0;
while(num == 0)
cin >> num;
cout << num << endl;
return 0;
}
Program wyprowadza liczbę 0 albo pierwszą niezerową liczbę wprowadzoną z klawiatury. Gdyby operator
porównania zastąpiono operatorem przypisania, to zawsze wyprowadzałby liczbę 0.
Operacje orzecznikowe
Operacje orzecznikowe wykonuje się za pomocą operatorów wymienionych w tabeli Operacje orzecznikowe.
Tabela Operacje orzecznikowe
###
! (zaprzeczenie) && (koniunkcja) || (dysjunkcja)
###
Argumenty i rezultaty operacji orzecznikowych są typu bool i mają wartości true albo false.
Rezultat zaprzeczenia ma wartość true tylko wówczas, gdy argument ma wartość false.
Rezultat koniunkcji ma wartość true tylko wówczas, gdy oba argumenty mają wartość true.
Rezultat dysjunkcji ma wartość false tylko wówczas, gdy oba argumenty mają wartość false.
Uwaga: Operacja koniunkcji i dysjunkcji jest wykonywana w taki sposób, że jeśli po opracowaniu pierwszego
argumentu jest znana wartość rezultatu całej operacji (bo dla koniunkcji ma wartość false, a dla dysjunkcji ma
wartość true), to rezygnuje się z opracowania drugiego argumentu.
#include
int vec[] = { 10, 20, 30, 40, 50 };
int main(void)
{
4
 int pos;
cin >> pos;
pos >= 0 && pos < 5 && (cout << vec[pos]);
return 0;
}
Program wyprowadza wartość tego elementu tablicy, którego indeks wprowadzono z klawiatury.
Jeśli wprowadzi się indeks, który nie ma wartości z przedziału [0 ; 4], to program nie wyprowadzi nic.
Dzięki użyciu operatora &&, nigdy nie dojdzie do opracowania wyrażenia vec[pos] z niedozwolonym indeksem.
Operacje konwersji
Wykonanie konwersji ma na celu przekształcenie zmiennej pewnego typu w zmienną typu docelowego.
Operacja konwersji wyrażenia e do typu Type ma postać
(Type)e
Jeśli nazwę typu docelowego Type można wyrazić za pomocą identyfikatora (np. int), to operację konwersji
można zapisać jako
Type(e)
W szczególności, jeśli w programie występuje instrukcja
int num = 4.8;
w której zmienna num jest typu int, a wyrażenie 4.8 jest typu double, to ponieważ danej typu double (zazwyczaj
8-bajtowej) nie można pomieścić w zmiennej typu int (zazwyczaj 4-bajtowej), więc najprościej byłoby taką
instrukcje uznać za błędną.
Ponieważ w C++ przekształcenie zmiennej typu double w zmienną typu int zdefiniowano jako konwersję
standardową (polega ona na odrzuceniu części ułamkowej), więc rozpatrywana instrukcja zostanie niejawnie
zmieniona w poprawną instrukcję
int num = int(4.8);
równoważną
int num = 4;
w której wyrażenie inicjujące jest już typu int.
Uwaga: Ważne informacje na temat konwersji zamieszczono w Dodatku C.
Operacje warunkowe
Operacje warunkowe wykonuje się za pomocą trójargumentowego operatora ?: (pytajnik, dwukropek).
Rezultatem operacji
e ? eT : eL
5
jest zmienna o wartości eT jeśli orzeczenie wyrażone przez e jest prawdziwe, albo zmienna o wartości eF w
przeciwnym razie..
Uwaga: Po opracowaniu wyrażenia e, opracowuje się tylko jedno z wyrażeń eT i eF.
num = fix > 0 ? fix1 : fix2;
num < 0 ? fix1 : fix2 = 30;
Operatory :: i Name::
Jeśli id jest identyfikatorem, to ::id jest nazwą globalną, a Name::id jest nazwą składnika typu strukturowego
Name.
int num = 0;
struct Fix {
int num;
void set(int num =::num)
{
Fix::num = num;
}
};
Napis ::num jest nazwą zmiennej globalnej, a napis Fix::num jest nazwą składnika num.
Prawy argument przypisania Fix::num = num jest nazwą parametru.
Wykonywanie instrukcji
Do napisania dowolnego programu wystarczy zaledwie kilka instrukcji. Najważniejszymi z nich są: instrukcja
pusta, grupująca, warunkowa (if), iteracyjna (while) i powrotu (return). Opis pozostałych ograniczono do
przykładów.
Instrukcja pusta
Instrukcja pusta składa się ze średnika.
;
Jej wykonanie nie ma żadnych skutków.
Instrukcja grupująca
Instrukcja grupująca składa się z nawiasów klamrowych zawierających dowolną sekwencję instrukcji.
Jeśli w miejscu, w którym składnia wymaga użycia dokładnie jednej instrukcji, chce się umieścić ich więcej, to
wystarczy ująć je w nawiasy klamrowe i powstanie jedna instrukcja.
{ int a; cin >> a; a++; cout << a; }
Instrukcja warunkowa
Instrukcja warunkowa ma postać
6
 if(c)
s
albo
if(c)
s1
else
s2
w której c jest wyrażeniem orzecznikowym o wartości true albo false, a s1 oraz s2 jest pojedynczą instrukcją
(np. instrukcją grupującą).
Wykonanie instrukcji warunkowej zaczyna się od opracowania wyrażenia c (np. a > 2). Jeśli wyrażone przez nie
orzeczenie jest prawdziwe, to w pierwszym przypadku jest wykonywana instrukcja s, a w drugim instrukcja s1.
W przeciwnym razie, w pierwszym przypadku nie robi się nic, a w drugim wykonuje instrukcję s2.
if(a > 2)
{ a++; cout << a; }
else
{ cout << a; a-- }
albo równoważnie
if(a > 2) {
a++;
cout << a;
} else {
cout << a;
a--;
}
Jeśli podczas opracowywania instrukcji warunkowej napotka się słowo kluczowe else, to przyjmuje się, że
dotyczy ono najbliższego z lewej słowa if, nie połączonego jeszcze z else.
W szczególności instrukcja
if(fix1 > fix2) if(fix1) fix1++; else fix2++;
jest wykonywana jak instrukcja
if(fix1 > fix2) {
if(fix1)
fix1++;
else fix2++;
}
a nie jak instrukcja
if(fix1 > fix2) {
if(fix1)
fix1++;
} else
fix2++;
Instrukcje iteracyjne
Instrukcja iteracyjna while ma postać
while(c)
s
7
w której c jest wyrażeniem orzecznikowym, a s jest pojedynczą instrukcją.
Wykonanie instrukcji iteracyjnej while polega na cyklicznym badaniu orzeczenia wyrażonego przez wyrażenie c
i wykonywaniu instrukcji s.
Iteracja kończy się w chwili stwierdzenia, że orzeczenie jest nieprawdziwe. Jeśli okaże się to już na wstępie, to
instrukcja s nie będzie wykonana wcale.
int i = 3;
while(i > 0) {
int t = i * i;
cout << t << endl; // 9 4 1
i--;
}
Często używa się instrukcji iteracyjnej for
for(d c ; e) {
s s ... s
}
w której d jest instrukcją deklaracyjną, a c i e są wyrażeniami.
Tak zapisana instrukcja for jest równoważna instrukcji
d
while(c) {
s s ... s
e;
}
Instrukcja for dobrze opisuje czynności o znanej liczbie powtórzeń.
int tab[5] = { 10, 20, 30, 40, 50 }, sum = 0;
for(int i = 0; i < 5 ; i++)
sum += tab[i];
cout << "Sum = " << sum << endl;
Instrukcja zaniechania
Instrukcja zaniechania ma postać
break;
Wykonanie instrukcji zaniechania powoduje zakończenie wykonywania najwęższej obejmującej ją instrukcji
iteracyjnej albo decyzyjnej.
int sum = 0;
while(true) {
int tmp = 0;
cin >> tmp; // wprowadz
daną
if(tmp == 0) // zbadaj czy 0
break; // zakończ iterację
sum += tmp; // dosumuj
}
cout << "Sum = " << sum << endl;
albo
int tmp = 0, sum = 0;
while(cin >> tmp, tmp) // wprowadz
i zbadaj
sum += tmp; // dosumuj
cout << "Sum = " << sum << endl;
8
lub
for(int tmp = 0, sum = 0; cin >> tmp, tmp ; sum += tmp);
cout << "Sum = " << sum << endl;
Instrukcja powrotu
Instrukcja powrotu ma postać
return e;
w której e jest wyrażeniem.
Wykonanie instrukcji powrotu powoduje zakończenie wykonywania funkcji i dostarczenie rezultatu o wartości
określonej przez e.
int sum(int one, int two)
{
return one + two;
}
Jeśli typem funkcji jest void, to użyta w niej instrukcja powrotu nie może zawierać wyrażenia. Użycie takiej
instrukcji jest zazwyczaj zbyteczne, ponieważ domniemywa się ją tuż przed klamrą zamykajacą ciało funkcji.
void sum(int one, int two)
{
cout << one + two << endl;
return; // zbędne
}
Instrukcja decyzyjna
Instrukcja decyzyjna uogólnia instrukcję warunkową i jest przydatna wówczas, gdy w programie występują
więcej niż dwie gałęzie decyzyjne. W szczególności instrukcję warunkową
if(a == 2)
b = 3;
else if(a == 1)
b = 5;
else if(a == 4)
b = -1;
else
b = 0;
można zapisać w postaci
switch(a) {
case 2: // jeśli a == 2
b = 3;
break;
case 1: // jeśli a == 1
b = 5;
break;
case 4: // jeśli a == 4
b = -1;
break;
default: // w pozostałych przypadkach
b = 0;
}
9
Deklarowanie zmiennych i typów
Każdy moduł programu jest kompilowany niezależnie od pozostałych. Analiza składniowa modułu odbywa się
od-góry-do-dołu i od-lewej-do-prawej i polega na rozpoznawaniu jednostek leksykalnych: identyfikatorów
(np. exit), literałów (np. 0), operatorów (np. +) i ograniczników (np. ;).
Identyfikatory
Identyfikatorem jest spójna sekwencja liter i cyfr, zaczynająca się od litery. Identyfikator nie może mieć postaci
słowa kluczowego (np. return). Za jego literę uznaje się również znak podkreślenia (_).
Litery małe uznaje się za różne od dużych. Zaleca się, aby w wielosłowowych nazwach zmiennych i funkcji,
wszystkie słowa, z wyjątkiem pierwszego, były zapisane za pomocą dużych liter.
np.
forSale speedLimit veryLongName
Literały
Literałami są liczby (np. 12, 0xff i 2.e-3), znaki (np. 'a') i łańcuchy (np. "Hello"). Każdy literał jest nazwą
zmiennej ustalonej. Jej typ wynika z zapisu literału.
Uwaga: Jeśli łańcuch ma zawierać znak \ (ukośnik), to należy go zapisać jako \\ (np. "C:\\Data.txt).
np.
'a' '\n' '\0' // nazwy zmiennych typu char
12 -12 0 // nazwy zmiennych typu int
-2.4 2.e4 .2 // nazwy zmiennych typu double
"a" "N" "\n" // nazwy zmiennych typu char [2]
Deklaracje
Każde użycie identyfikatora musi być poprzedzone jego deklaracją. Deklaracja kompletnie opisująca zmienną
(określająca jej wartość początkową), typ (wyszczególniająca strukturę jego obiektów) i funkcję (podająca jej
ciało) jest nazywana definicją.
W skład deklaracji wchodzą specyfikatory, deklaratory i inicjatory.
np.
const int tab[3] = { -1, 0, +1 };
Specyfikatorami są const i int, deklaratorem jest tab[3], a inicjatorem jest = { -1, 0, +1 }.
Nagłówki
Deklaracje typów i funkcji są ujmowane w nagłówki. Każdy nagłówek jest zapisany w odrębnym pliku.
Włączenie nagłówka odbywa się w miejscu wystąpienia wyszczególniającej go dyrektywy #include.
Do najczęściej używanych nagłówków należą: iostream.h i iomanip.h, math.h, string.h i stdlib.h. Dwa
pierwsze włączają do modułu deklaracje zmiennych i operatorów wejścia-wyjścia (cin, cout, >>, <<), dwa
następne włączają deklaracje funkcji matematycznych (sqrt, sin, cos) i łańcuchowych (strlen, strcpy, strcat,
strcmp), a ostatni włącza m.in. deklarację funkcji exit.
10
#include
#include
int main(void)
{
double number; // deklaracja zmiennej
cin >> number; // wprowadzenie liczby
cout << sqrt(number); // wyprowadzenie pierwiastka
return 0; // zakończenie wykonywania
}
Zmienne
Zmienną jest obszar pamięci do przechowywania danych określonego typu: skalarnych, tablicowych i
strukturowych. Każde odwołanie do zmiennej musi być poprzedzone deklaracją jej typu.
int fix; // zmienna całkowita
char chr; // zmienna znakowa
double num; // zmienna rzeczywista
Zmienna fix jest typu int, zmienna chr jest typu char, zmienna num jest typu double.
Rozmiar zmiennej
Rozmiar zmiennej w bajtach określa się za pomocą operatora sizeof. Argumentem operatora sizeof może być
nazwa zmiennej albo nazwa typu.
Uwaga: Rozmiar zmiennej zależy od implementacji. W Visual C++ zmienne typu char są 1-bajtowe, zmienne
typu int są 2-bajtowe, a zmienne typu double są 8-bajtowe.
int age = 24;
cout << sizeof(age); // 4
cout << sizeof(int); // 4
int tab[3];
cout << sizeof(tab); // 12
Zmienne ustalone
Zmienna zadeklarowana ze specyfikatorem const jest zmienną ustaloną. Zmienna ustalona musi być
zainicjowana, ale nadana jej wartość nie może ulec zmianie.
Uwaga: Zmiennymi ustalonymi są także zmienne reprezentowane przez literały. W szczególności liczba 12e2
jest nazwą zmiennej ustalonej o wartości 1200.
const int size = 100;
const double width = -2e-7, height = 2e2;
const int tab[2] = { 10, 20 };
Zmienne skalarne
Deklaracja zmiennej skalarnej określa jej identyfikator oraz wyszczególnia typ danych jakie można przypisywać
zmiennej (np. int, double, char).
int number;
double speedLimit;
char separator;
11
Wartość początkową zmiennej określa się za pomocą inicjatora. Jeśli deklaracja zmiennej zawiera jawny albo
domniemany inicjator, to jest jej definicją.
int minValue = 10, maxValue = 90;
double width = 2.4, height = 4.5e+2, area;
char lastChar = '.';
Składnia inicjatora
Inicjatory dzielą się na wyrażeniowe, klamrowe i nawiasowe. Inicjator zmiennej ustalonej musi mieć postać
wyrażenia stałego. W jego skład wchodzą odwołania do literałów i zmiennych ustalonych, ale nie mogą
wchodzić odwołania do zmiennych nie-ustalonych.
int base = 100; // inicjator wyrażeniowy
int min = { base + 20 }; // inicjator klamrowy
int max(base + 40); // inicjator nawiasowy
const int size = max - min; // błąd
Punkt zadeklarowania
Identyfikator zmiennej uważa się za zadeklarowany w punkcie tuż przed inicjatorem wyrażeniowym i
klamrowym, ale tuż po inicjatorze nawiasowym. Ta subtelna różnica ma niekiedy wpływ na poprawność i skutek
wykonania programu.
#include
const int val = 10; // definicja zmiennej globalnej
int main(void)
{
int val(val); // definicja zmiennej lokalnej
cout << val; // 10
return 0;
}
Punkt zadeklarowania zmiennej lokalnej występuje tuż po inicjatorze (val). Gdyby inicjator nawiasowy
zastąpiono jednym z pozostałych inicjatorów, to program stałby się błędny, ponieważ zmienna lokalna byłaby
wówczas inicjowana nie wartością zmiennej globalnej, ale nieokreśloną jeszcze wartością zmiennej lokalnej.
Operacje wejścia-wyjścia
Zmienne typu int, double i char są zmiennymi arytmetycznymi, przystosowanymi odpowiednio do
przechowywania liczb całkowitych, zmiennopozycyjnych i kodów znaków.
Podczas wykonywania operacji wejścia, do zmiennych typu int i double wprowadza się dane liczbowe, a do
zmiennych typu char wprowadza się kody znaków. A zatem, jeśli z klawiatury wprowadzi się na przykład napis
20e3, to liczba pobranych znaków i otrzymana wartość będzie zależeć od typu zmiennej, zgodnie z tabelą
Wprowadzanie danych.
Tabela Wprowadzanie danych
Typ zmiennej Pobrano znaków Wprowadzono wartość
int 2 20
double 4 20000
char 1 49
12
Podczas wykonywania operacji wyjścia, wyprowadza się liczby o wartości zmiennych typu int i double oraz
znaki o kodach określonych przez wartości zmiennych typu char.
#include
int main(void)
{
int mant, exp;
char sep;
cin >> mant >> sep >> exp;
int value = mant;
while(exp > 0) {
value = value * 10;
exp--;
}
cout << mant << sep << exp <<
" == " << value << endl;
return 0;
}
Jeśli wprowadzi się napis 2e3, to program wyprowadzi ten napis oraz liczbę 2000.
Zmienne tablicowe
Zmienną tablicową, w skrócie tablicą, jest zestaw sąsiadujących ze sobą elementów tablicy. Każdy element jest
zmienną takiego samego typu: skalarną, tablicową, strukturową.
int tab[20];
Zmienna tab jest tablicą o 20-elementach typu int.
Z każdym elementem tablicy jest związany indeks, określający położenie elementu w obrębie tablicy. Elementy
tablicy są indeksowane od 0. W deklaracji tablicy podaje się liczbę jej elementów, a nie indeks jej ostatniego
elementu. Jeśli deklarator nie podaje liczby elementów, ale deklaracja zawiera inicjator, to za liczbę elementów
uznaje się liczbę fraz inicjujących.
Uwaga: Liczba fraz inicjujących nie może przekraczać liczby elementów tablicy. Jesli jest od niej mniejsza, to
jest niejawnie dopełniana frazami 0.
int tab[100] = { 4, 4 };
Zerowy i pierwszy element tablicy tab ma wartość 4. Wszystkie pozostałe mają wartość 0.
Liczba elementów tablicy musi być wyrażona za pomocą wyrażenia stałego. Wyrażenie stałe może zawierać
literały i identyfikatory zmiennych ustalonych, ale nie może zawierać operatora połączenia.
const int Count = 3;
double sizes[Count] = { 2.4, 3.8, 5.2 };
int values[] = { 10, 20, 30, 40, 50 };
int Size = 4;
double reals[Size]; // błąd
Tablica sizes składa się z 3 zmiennych, z których każda jest typu double.
Tablica values składa się z 5 zmiennych, z których każda jest typu int.
Identyfikowanie elementów tablicy
13
Jeśli nazwą tablicy jest vec, to nazwą jej elementu o indeksie ind jest vec[ind]. Jest to prawdziwe tylko wówczas,
gdy wyrażenie ind ma wartość większą-lub-równą 0 i jednocześnie mniejszą od liczby elementów tablicy.
Uwaga: Jeśli tablica vec ma n elementów, to zezwala się, aby wyrażenie ind miało wartość -1 oraz n, ale tylko
wówczas, gdy opracowanie wyrażenia vec[ind] nie ma na celu dokonania zmiany albo dostarczenia wartości
elementu.
#include
int values[5] = { 10, 20, 30, 40, 50 };
int main(void)
{
int index;
cin >> index;
if(index >= 0 && index < 5)
cout << values[index] << endl;
else
cout << "Wrong index" << endl;
return 0;
}
Program wyprowadza wartość elementu o podanym indeksie. Jeśli indeks nie mieści się w domkniętym
przedziale [0 ; 4], to program wyprowadza napis Wrong index.
Tablice znakowe
Tablicą znakową jest tablica o elementach typu char. Przechowuje się w niej zazwyczaj małe liczby oraz kody
znaków.
Ponieważ Visual C++ używa kodu ASCII, w którym kodem cyfry 0 jest 48, więc zainicjowanie 4-elementowej
tablicy znakowej kodami cyfr 0, 1 i 2 oraz kodem znaku '\0' można wykonać na wiele sposobów, w tym m.in.
char digits[] = { '0', '1', '2', '\0' };
char digits[] = { 48, 49, 50, 0 };
char digits[4] = { '0', '0'+1, '3'-1 };
char digits[4] = "012";
Z klawiatury można wprowadzać tylko spójne ciągi znaków. Za ostatnim wprowadzonym znakiem umieszcza się
wówczas specjalny znak o kodzie 0.
Jeśli chce się wyprowadzić ciąg znaków utworzony w tablicy programowo, to należy zakończyć go znakiem o
kodzie 0 (jego rozpoznanie spowoduje zakończenie wyprowadzania znaków).
#include
char name[100];
int main(void)
{
cin >> name;
name[1] = 0;
cout << "Your initial is: " << name << endl;
return 0;
}
Program wprowadza imię, a następnie wyprowadza jego inicjał.
Literały łańcuchowe
14
Literał łańcuchowy, na przykład "Hello", ma postać ciągu znaków ujętego w cudzysłowy. Znaki specjalne są w
tym ciągu reprezentowane przez nastepujące symbole
\\ (ukośnik) \n (nowy wiersz) \t (tabulator),
\' (apostrof) \" (cudzysłów) \0 (znak o kodzie 0).
Każdy literał łańcuchowy, jest nazwą tablicy o elementach typu char, zainicjowanych kodami kolejnych znaków
literału oraz kodem znaku \0. W szczególności (w kodzie ASCII) literał "No" jest nazwą 3-elementowej tablicy
zainicjowanej liczbami 78, 111 i 0.
#include
int main(void)
{
int i = 0;
while("Hello"[i] != 0) {
cout << "Hello"[i] << ' ';
i++;
}
cout << endl;
return 0;
}
Program wyprowadza kolejne znaki napisu Hello, po każdym znaku dodając spację. Zakończenie wykonywania
następuje po rozpoznaniu elementu zainicjowanego liczbą 0.
Literały łańcuchowe mogą być użyte do inicjowania tablic znakowych. Tak zainicjowana tablica musi mieć co
najmniej tyle elementów ile ma tablica reprezentowana przez literał. Jeśli jest dłuższa, to jej nadmiarowe
elementy są inicjowane liczbami 0.
char name1[10] = { 'I', 's', 'a', 0 };
char name2[10] = "Isa";
char name3[] = "Isa";
char name4[3] = "Isa"; // błąd
Operacje wejścia-wyjścia
Tablice znakowe mogą być wykorzystane do wprowadzania z klawiatury spójnych ciągów znaków. W takim
przypadku argumentem operacji jest zazwyczaj nazwa tablicy, a wykonanie operacji powoduje umieszczenie w
tablicy kodów znaków łańcucha oraz kodu o wartości 0.
Ponieważ może wówczas dojść do przepełnienia tablicy, zaleca się użycie manipulatora setw, zadeklarowanego
w nagłówku iomanip.h, ograniczającego liczbę wprowadzonych znaków.
Uwaga: Manipulator setw może być użyty także podczas wyprowadzania danych. W takim wypadku określa on
szerokość pola zewnętrznego, w którym umieszcza się dane wyjściowe.
#include
#include
char name[20];
int main(void)
{
cin >> setw(20) >> name;
name[1] = 0;
cout << "Your initial is: " << name << endl;
return 0;
}
15
Program wprowadza imię, a następnie wyprowadza jego inicjał. Aby zabezpieczyć się przed wpisaniem do
tablicy name więcej niż 20 znaków, użyto manipulatora setw(20) zadeklarowanego w nagłówku iomanip.h.
Zmienne strukturowe
Zmienną strukturową, w skrócie strukturą, jest zestaw sąsiadujących ze sobą elementów struktury. Każdy
element struktury może być zmienną innego typu: skalarną, tablicową, strukturową.
Przed zadeklarowaniem zmiennej strukturowej należy zdefiniować jej typ. Deklaracja typu strukturowego składa
się z deklaracji pól struktury. Deklaracja pola struktury ma postać deklaracji zmiennej.
struct Child {
char name[20];
int age;
};
Child isa = { "Isabel", 15 };
Struktura isa składa się z 2 zmiennych, opisanych przez pola name i age. Wartości początkowe elementów
struktury określono za pomocą inicjatora klamrowego. Użycie innych inicjatorów jest zabronione.
Identyfikowanie elementów
Jeśli nazwą struktury jest str, a w opisie jej typu występuje pole fld, to nazwą zmiennej odpowiadającej temu
polu jest str.fld.
#include
#include
struct Child {
char name[20];
int age;
};
Child child;
int main(void)
{
cin >> setw(20) >> child.name >> child.age;
cout << child.name << " is "
<< child.age << " now" << endl;
return 0;
}
Zmienna child składa się z tablicy o elementach typu char i zmiennej skalarnej typu int. Program wprowadza
imię i wiek dziecka, a następnie wyprowadza je.
Kopiowanie struktur
W odróżnieniu od tablic, które można kopiować tylko element-po-elemencie, kopiowanie struktur może dotyczyć
pełnego zestawu jej elementów i to nawet wówczas, gdy struktura zawiera tablice.
#include
struct Child {
char name[20];
int age;
};
Child girl;
16
int main(void)
{
Child isa = { "Isabel", 15 };
girl = isa;
cout << girl.name << " is " << girl.age << endl;
return 0;
}
Program wyprowadza te same dane, którymi zainicjowano strukturę isa.
Unia elementów
Struktura, której elementy są rozmieszczone w pamięci nie jeden-za-drugim, ale zawsze od tego samego miejsca,
jest nazywana unią. W celu zadeklarowania unii należy zamiast słowa kluczowego struct użyć słowa union.
Definicja unii, w której pominięto nazwę typu, jest definicją unii anonimowej. Pola unii anonimowej są
zadeklarowane w miejscu zdefiniowania unii.
struct Number {
bool isFixed;
union { // unia anonimowa
int fixed;
double real;
};
};
Number num = { true, 12 };
if(num.isFixed)
cout << num.fixed << endl; // 12
else
cout << num.real << endl;
cout << num.real << endl; // błąd
W każdej chwili struktura num składa się ze zmiennych typu bool i int, albo ze zmiennych typu bool i double.
Błąd polega na tym, że w chwili gdy zmienna num składa się ze zmiennych typu bool i int, następuje odwołanie
do zmiennej typu double.
Przetwarzanie plików
Przetwarzanie plików odbywa się za pośrednictwem zmiennych strumieniowych klas ifstream i ofstream,
zadeklarowanych w nagłówku fstream.h. Po utworzeniu zmiennej strumieniowej należy otworzyć skojarzony z
nią plik, a następnie upewnić się, że otwarcie było pomyślne.
Po pomyślnym otwarciu pliku, pochodzący z niego strumień danych można przetwarzać w taki sam sposób, jak
strumień danych związany z klawiaturą albo z monitorem.
Stany strumienia
Początkowo strumień znajduje się w stanie dobrym, ale na skutek błędu operacji wejścia-wyjścia albo próby
wprowadzenia nieistniejącej danej, może znalez
ć się w stanie nie-dobrym (fail).
W stanie nie-dobrym wszystkie operacje na strumieniu są ignorowane. Jeśli dane przygotowano właściwie, a
jakość pamięci zewnętrznej jest zadowalająca, to stan nie-dobry oznacza, że napotkano koniec strumienia.
17
Uwaga: W programach przykładowych nie będzie rozpatrywany przypadek wystąpienia błędu przesyłania
danych.
Szczególnym przypadkiem stanu nie-dobrego jest stan zły (bad). Powstaje on w przypadku rozpoznania danych o
złym formacie. Niestety, na skutek niefortunnych domniemań, wprowadzenie takiej "danej" jak 3e, zamiast 3e0
(w kontekście 3ex) nie zmienia stanu strumienia na zły.
Uwaga: Do sprawdzenia czy stan strumienia jest zły, służy funkcja bad, a do sprawdzenia, czy strumień znajduje
się w pozycji za końcem pliku, służy funkcja eof. Funkcji tych używa się bardzo rzadko.
Zmienna plikowa
Jeśli w miejscu wystąpienia operacji wejścia-wyjścia odbywa się takie badanie zmiennej plikowej, jakby
dotyczyło wyrażenia o wartości orzecznikowej, na przykład
while(cin >> num) ...
albo
if(cin) ...
to w stanie dobrym jest dostarczana wartość true, a w stanie nie-dobrym wartość false.
Wprowadzanie danych
Zmienna strumieniowa użyta do wprowadzania danych z pliku jest typu ifstream. Otwarcie pliku odbywa się za
pomocą funkcji open, której pierwszym argumentem jest nazwa, a drugim tryb otwarcia pliku: ios::in. Jeśli
otwierany plik nie istnieje, to zostanie utworzony jako pusty. Aby tego uniknąć, plik należy otworzyć w trybie
ios::in | ios::nocreate.
Do zbadania, czy otwarcie pliku się powiodło, służy funkcja is_open. Jej rezultat ma wartość nie-zero tylko
wówczas, gdy otwarcie było pomyślne.
#include
#include
#include
int sum = 0;
int main(void)
{
ifstream inp; // zmienna plikowa
inp.open("Data.txt", ios::in | ios::nocreate);
if(!inp.is_open()) {
cout << "File does not exist" << endl;
return -1;
}
int val;
while(inp >> val) // wprowadz
i sprawdz
stan
sum += val; // dosumuj
assert(!inp.bad()); // raczej zbędne
cout << "Sum = " << sum << endl;
return 0;
}
Wykonanie programu powoduje wyprowadzenie sumy liczb całkowitych zawartych w pliku Data.txt.
Wywołanie funkcji assert ma na celu upewnienie się, że strumień nie znajduje się w złym stanie. Gdyby tak było,
to wykonanie programu zostałoby zaniechane.
18
Wyprowadzanie danych
Zmienna strumieniowa użyta do wyprowadzania danych do pliku jest typu ofstream. Otwarcie pliku odbywa się
za pomocą funkcji open, której pierwszym argumentem jest nazwa, a drugim tryb otwarcia pliku: ios::out.
Jeśli otwierany plik nie istnieje, to zostanie utworzony i otworzony jako pusty. Jeśli już istnieje, to zostanie
otworzony jako pusty.
Do zbadania, czy otwarcie pliku się powiodło, służy funkcja is_open. Jej rezultat ma wartość nie-zero tylko
wówczas, gdy otwarcie było pomyślne.
#include
#include
int main(void)
{
ifstream inp;
inp.open("Data.txt", ios::in | ios::nocreate);
if(!inp.is_open()) {
cout << "Source does not exist" << endl;
return -1;
}
ofstream out;
out.open("Data2.txt", ios::out);
if(!out.is_open()) {
cout << "Target not opened" << endl;
return -1;
}
int val;
while(inp >> val)
out << val << endl;
cout << "Done!" << endl;
return 0;
}
Program kopiuje liczby całkowite z pliku Data.txt do pliku Data2.txt. Każdą kopiowaną liczbę umieszcza w
nowym wierszu.
Użycie klawiatury
Jeśli dane wprowadza się z klawiatury, to koniec strumienia określa się za pomocą znaku końca: Ctrl-Z (na
polskiej klawiaturze Ctrl-Y). W Visual C++ nastąpi wówczas pominięcie pierwszego znaku wyprowadzonego na
konsolę.
Uwaga: Zaleca się, aby znak końca został wprowadzony na początku nowego wiersza (po Enter).
#include
int main(void)
{
int count = 0;
double tmp;
while(cin >> tmp)
count++;
cout << endl; // na pożarcie
cout << "Count = " << count << endl;
return 0;
}
19
Program zlicza dane liczbowe wprowadzone z klawiatury.
20
Środowisko Visual C++
Program z
ródłowy składa się z modułów z
ródłowych. Każdy moduł jest umieszczony w odrębnym pliku z
rozszerzeniem .cpp. Dodatkowo, w skład programu mogą wchodzić moduły skompilowane (*.obj) i biblioteczne
(*.lib).
W celu przekształcenia zestawu modułów w program wykonalny, należy utworzyć projekt, umieścić go w
przestrzeni roboczej, włączyć do projektu nazwy plików z rozszerzeniami .cpp, .obj i .lib, a następnie zbudować
program. Zostanie on umieszczony w pliku z rozszerzeniem .exe.
Katalog
Zaleca się, aby pliki programu znajdowały się we własnym katalogu. Jeśli dysponuje się wolnym miejscem na
przykład w katalogu głównym dysku D:, to należy wywołać Eksplorator Windows, kliknąć na nazwie katalogu
głównego i wydać polecenie Plik / Nowy obiekt / Folder, a następnie określić nazwę swojego katalogu, na
przykład jbVisual.
Przestrzeń
W celu utworzenia przestrzeni roboczej należy wydać polecenie File / New, a następnie (w zakładce
Workspaces) podać nazwę przestrzeni, np. Workspace: jbSpace oraz określić jej położenie, np. Location:
D:\jbVisual\jbSpace, po czym nacisnąć przycisk OK.
Jeśli przestrzeń już istnieje, to aby ją otworzyć, należy wydać polecenie File / Open Workspace, wejść do
katalogu przestrzeni (np. jbSpace), a następnie dwu-kliknąć na nazwie jbSpace.dsw.
Projekt
W celu utworzenia projektu należy wydać polecenie File / New, a w zakładce Projects podać typ projektu: Win
32 Console Application i jego nazwę, np. Project name: jbTests. Po upewnieniu się, że projekt zostanie
włączony do bieżącej przestrzeni (Add to current workspace) o czym zaświadczy
Location: D:\jbVisual\jbSpace\jbTests, należy nacisnąć przycisk OK.
Pliki
W celu utworzenia plików projektu należy wydać polecenie File / New, a następnie (w zakładce Files), określić
rodzaj pliku
C/C++ Source File dla pliku z rozszerzeniem .cpp
C++ Header File dla pliku z rozszerzeniem .h
Text File dla pliku z rozszerzeniem .txt
nie zapominając o podaniu jego nazwy (bez rozszerzenia), np. File name: Sum.
Po wykonaniu tych czynności, w katalogu D:\jbVisual\jbSpace\jbTests powstanie plik Sum.cpp, a jego
(początkowo pusta) zawartość ujawni się odrębnym oknie edycyjnym.
21
Jeśli program wymaga utworzenia plików z danymi, to zaleca się je umieścić w tym samym katalogu co pliki
z
ródłowe. Dla wygody można je dołączyć do plików projektu.
Budowanie projektu
W celu zbudowania projektu, to jest skompilowania jego wszystkich plików *.cpp, oraz ewentualnie jego plików
*.obj i *.lib, należy kliknąć ikonę Build. Spowoduje to niezależne kompilacje wszystkich modułów z
ródłowych
oraz połączenie ich w program wykonalny.
Przebieg budowania projektu jest diagnozowany w oknie Output. Jeśli okno nie jest widoczne, to można je
wyświetlić wydając polecenie View / Output.
Błędy modułu wyszczególnia się w oknie Output. Po rozpoznaniu każdego z nich podaje się krótki opis
przyczyny błędu i numer wiersza programu. Dwu-kliknięcie w obrębie opisu błędu powoduje przeniesienie
kursora w pobliże miejsca, w którym wykryto błąd.
W rzadkich przypadkach, gdy poprawność diagnozy budzi wątpliwości, zaleca się zastąpienie polecenia Build
poleceniem Build / Rebuild All.
Wykonanie programu
Program wykonalny, pod nazwą jbTests.exe jest umieszczany w podkatalogu jbTests\Debug. Jeśli wykonuje się
bezbłędnie i jest należycie wytestowany, to może zostać zoptymalizowany.
W celu zoptymalizowania programu należy wydać polecenie Build / Set Active Configuration, a następnie
zamiast konfiguracji Win 32 Debug, wybrać konfigurację Win 32 Release. Po ponownym zbudowaniu projektu,
w katalogu jbTests\Release, powstanie program znacznie krótszy, ale już bez informacji uruchomieniowych.
Zarządzanie projektami
Przestrzeń robocza może zawierać więcej niż jeden projekt, a projekt może składać się z więcej niż jednego
pliku.
Jeśli przestrzeń zawiera więcej niż jeden projekt, to tylko jeden z nich może być aktywny, to jest taki, którego
dotyczą polecenia Build. Uaktywnienie projektu odbywa się przez p-kliknięcie jego nazwy i wydanie polecenia
Set Active Project.
W celu umieszczenia w przestrzeni dodatkowego projektu należy p-kliknąć nazwę przestrzeni, wydać polecenie
Add New Project to Workspace, a dalej postępować tak, jak podczas tworzenia pierwszego projektu.
W celu włączenia do projektu dodatkowego pliku należy p-kliknąć nazwę projektu, a następnie wydać polecenie
Add Files to Project i wybrać skopiowany plik.
Jeśli włączany do projektu plik z
ródłowy już istnieje, to należy skopiować go do katalogu projektowego
(posługując się np. Eksploratorem Windows), a następnie postąpić tak, jak podczas dodawania pliku do
projektu.
Dopasowanie oblicza
Oblicze środowiska uruchomieniowego składa się z menu oraz z pasków, które można konfigurować. Odbywa
się to za pomocą polecenia Tools / Customize umożliwiającego zarządzanie wyświetlaniem pasków edycyjnych,
uruchomieniowych i innych.
22
Uruchamianie programu
Systematyczne wyszukiwanie błędów w programie odbywa się za pomocą uruchamiacza. W celu wyświetlenia
paska zawierającego jego narzędzia należy wydać polecenie Tools / Customize / Toolbars, a następnie odhaczyć
nastawę Debug.
Wykonanie programu nadzorowanego przez uruchamiacz zaczyna się w konfiguracji Win32 Debug po wydaniu
polecenia Build / Start Debug / Step into (F10). Program zatrzyma się tuż przed przystąpieniem do wykonania
pierwszej funkcji (zazwyczaj funkcji main).
Począwszy od tego momentu można
Określać argumenty funkcji głównej
Project / Settings // Debug, Program arguments
Zastawiać / usuwać pułapki
ikona Hand (F9)
Usuwać pułapki
Edit / Breakpoints / Remove All (Alt-F9)
Wykonywać program krokowo
ikona Go (po zastawieniu pułapki)
ikona Step over (F10)
ikona Step into (F11)
ikona Step out (Shift-F11)
Obserwować zmienne
ikona Quick Watch (Shift-F9)
Kompilacja warunkowa
Podczas uruchamiania programu przydaje się ignorowanie jego wybranych fragmentów. Odbywa się to za
pomocą dyrektyw kompilacji warunkowej: #if, #else, #endif.
Zinterpretowanie dyrektywy
#if c
kod-z
ródłowy
#else
kod-alternatywny
#endif
zaczyna się od wyznaczenia wartości wyrażenia c (najczęściej liczby 1 albo 0). Jeśli wyrażenie ma wartość różną
od 0, to całą dyrektywę zastępuje się napisem kod-z
ródłowy. W przeciwnym razie zastępuje się ją napisem
kod-alternatywny.
Uwaga: Jeśli napis kod-z
ródłowy jest pusty, to dyrektywę można zapisać bez frazy #else.
#include
int main(void)
{
int one, two;
cin >> one >> two;
#if 1
23
 cout << "Sum = ";
#endif
cout << one + two << endl;
return 0;
}
Program wyprowadza sumę pary danych wejściowych poprzedzając ją napisem Sum =. Jeśli w dyrektywie #if
zmieni się 1, na 0, to powstanie program, który takiego napisu nie wyprowadzi.
24
Wskaz
niki i odnośniki
Wskaz
niki i odnośniki są zmiennymi, które służą do identyfikowania innych zmiennych. Wskaz
nik może
identyfikować wiele zmiennych pokrewnego mu typu, natomiast odnośnik może identyfikować tylko jedną
zmienną.
Wskaz
nikom przypisuje się wskazania, a odnośnikom odniesienia. Mimo iż w typowych implementacjach
zarówno wskazania jak i odniesienia są reprezentowane przez adresy, posługiwanie się pojęciem adres jest
całkowicie zbyteczne i dowodzi myślenia o C++ nie w kategoriach języka wysokiego poziomu, ale w
kategoriach implementacji. Dlatego o adresach nie będzie już mowy.
Zmienne wskaz
nikowe
Wskaz
nikiem jest zmienna, której można przypisywać wskazania. Deklarację wskaz
nika można poznać po tym,
że jej identyfikator jest poprzedzony symbolem * (gwiazdka).
Jeśli w pewnym miejscu programu jest wymagane użycie wskazania zmiennej, to otrzymuje się je poprzedzając
nazwę zmiennej operatorem wskazywania & (ampersand).
Po przypisaniu wskaz
nikowi ptr wskazania zmiennej, napis *ptr staje się chwilową nazwą tej zmiennej. Po
przypisaniu wskaz
nikowi wskazania pustego (reprezentowanego przez liczbę 0), użycie nazwy *ptr albo nazwy
jej równoważnej (np. ptr[0]) jest zabronione.
int fix1 = 10,
fix2 = 20;
int *ptr = &fix1;
cout << *ptr; // 10
*ptr = 11;
cout << *ptr << fix; // 11 11
ptr = &fix2;
cout << *ptr; // 20
*ptr = 22;
cout << *ptr << fix; // 22 22
ptr = 0;
cout << *ptr; // błąd
Wskaz
nik ptr jest przystosowany do wskazywania zmiennych typu int. Przypisano mu kolejno: wskazanie
zmiennej fix1, wskazanie zmiennej fix2 i wskazanie puste.
Po przypisaniu wskaz
nikowi ptr wskazania zmiennej fix1, napis *ptr jest chwilową nazwą zmiennej fix1, a po
przypisaniu mu wskazania zmiennej fix2, jest chwilową nazwą zmiennej fix2.
Po przypisaniu wskaz
nikowi ptr wskazania pustego, aż do chwili przypisania mu wskazania zmiennej, użycie
nazwy *ptr jest zabronione.
Dla dociekliwych
Typ wyrażenia inicjującego wskaz
nik musi być zgodny z typem wskaz
nika. Przyjmuje się z definicji, że zgodne
ze wskaz
nikiem typu Type jest każde wyrażenie typu Type oraz każde wyrażenie, które może być poddane
niejawnej konwersji do typu Type (por. Dodatek C).
25
char *ptr1 = "0\0\0\0" // niejawna konwersja
int *ptr2 = "0\0\0\0"; // błąd
int *ptr = (int *)"0\0\0\0"; // jawna konwersja
cout << *ptr; // 48 (kod cyfry 0)
Skutek użytej tu jawnej konwersji zależy od implementacji. W Visual C++ powoduje to potraktowanie obszaru
pamięci zajętego przez pierwsze 4 bajty literału jako zmiennej całkowitej.
Wskaz
niki i tablice
Związki między wskaz
nikami i tablicami są bardzo bliskie. Każda nazwa tablicy jest niejawnie przekształcana na
wskaz
nik jej zerowego elementu, a każda nazwa wskaz
nika może być indeksowana tak, jak nazwa tablicy.
Jeśli wskaz
nik ptr wskazuje pewien element tablicy, to zarówno *ptr jak i ptr[0] jest nazwą tego elementu.
Elementy położone z lewej strony elementu wskazywanego mają nazwy ptr[-1], ptr[-2], itd., a elementy położone
z prawej mają nazwy ptr[1], ptr[2], itd.
Jeśli i jest wyrażeniem całkowitym, to wyrażenie ptr+i jest wskaz
nikiem elementu odległego o i elementów od
wskazywanego (dla i ujemnego - w lewo, a dla i dodatniego - w prawo).
Jeśli wskaz
niki ptr1 i ptr2 wskazują odpowiednio elementy o indeksach i oraz j tej samej n-elementowej tablicy
(a także gdy wskazują nie istniejące "elementy" o indeksach -1 i n), to wyrażenie ptr1-ptr2 ma wartość i-j.
int vec[3] = { 10, 20, 30 };
int *ptr = vec + 2;
cout << ptr++[-1]; // 20
cout << *(vec + 2); // 30
cout << vec - ptr; // -3
Nazwa vec zostaje niejawnie przekształcona na wskazanie elementu vec[0], to jest na &vec[0].
Wyrażenie vec + 2 wskazuje element o wartości 30.
Wyrażenie ptr++[-1] jest nazwą elementu o wartości 20.
W wyrażeniu vec - ptr pierwszy argument wskazuje element zerowy, a drugi argument wskazuje nie istniejący
element vec[3].
Wskaz
niki i struktury
Jeśli wskaz
nik ptr wskazuje strukturę o polu f, to nazwą zmiennej odpowiadającej temu polu jest (*ptr).f, albo
krócej ptr->f.
#include
struct Child {
char name[20];
int age;
Child *pNext;
};
Child bob = { "Robert", 20 },
tom = { "Thomas", 30, 0 };
Child *pBob = &bob,
*pTom = &tom;
int main(void)
{
cout << pBob->name << endl; // Robert
26
 pBob->pNext = pTom;
cout << pBob->pNext->age << endl; // 30
return 0;
}
Zmienna pBob jest wskaz
nikiem przystosowanym do wskazywania zmiennych typu Child. Przypisano jej
wskazanie struktury bob.
Napis pBob->name jest chwilową nazwą tego elementu struktury bob, który jest opisany przez pole name.
Napis pBob->pNext jest nazwą wskaz
nika opisanego przez pole pNext. Ponieważ wskazuje on strukturę tom,
więc pBob->pNext->age jest nazwą tego elementu struktury tom, który jest opisany przez pole age.
Tablice wskaz
ników
Tablicą wskaz
ników jest tablica, której elementami są wskaz
niki. W deklaracji tablicy wskaz
ników jej
identyfikator jest poprzedzony znakiem * (gwiazdka).
W deklaracji wskaz
nika, który służy do wskazywania-wskaz
ników, jego identyfikator jest poprzedzony dwiema
znakami * (gwiazdka).
#include
const int Count = 3;
struct Child {
char name[20];
int age;
};
Child john = { "John Smith", 30 },
tom = { "Thomas Mill", 10 },
bill = { "Robert Dole", 20 };
Child *pBoys[Count] = { &john, &tom, &bill };
int main(void)
{
for(int i = 0; i < Count-1 ; i++) {
int minAge = pBoys[i]->age;
for(int j = i+1; j < Count ; j++) {
if(pBoys[j]->age < minAge) {
minAge = pBoys[j]->age;
Child *ptr = pBoys[i];
pBoys[i] = pBoys[j];
pBoys[j] = ptr;
}
}
}
Child **ptr = pBoys;
for(i = 0; i < Count ; i++)
cout << (*ptr++)->name << endl;
return 0;
}
Program wyprowadza nazwiska chłopców, w kolejności ich rosnącego wieku. Sortowanie dotyczy tylko
elementów tablicy wskaz
ników i nie powoduje kopiowania struktur typu Child.
Wskaz
niki a ustalenia
27
Podobnie jak zwykła zmienna, tak i wskaz
nik może być ustalony albo nie-ustalony. Ponadto wskaz
nik może być
przystosowany do wskazywania zmiennych ustalonych albo nie-ustalonych. Daje to cztery możliwości.
Uwaga: Zabrania się, aby wskaz
nikowi przystosowanemu do wskazywania zmiennych nie-ustalonych przypisano
wskazanie zmiennej ustalonej.
#include
int main(void)
{
int mod = 10;
const int fix = 20;
int *ptr1 = &mod;
int *const ptr2 = &mod;
const int *ptr3 = &mod;
const int *const ptr4 = &fix;
cout << *ptr1 << endl; // 10
cout << *ptr2 << endl; // 10
cout << *ptr3 << endl; // 10
cout << *ptr4 << endl; // 20
ptr1 = &fix; // błąd
++ptr2; // błąd
++*ptr3; // błąd
ptr1 = &(int &)fix; // dozwolone
cout << *ptr1 << endl; // 20
return 0;
}
Wskaz
nik ptr1 służy do wskazywania zmiennych nie-ustalonych. Wskaz
nik ptr2 jest wskaz
nikiem ustalonym, który
służy do wskazywania zmiennych nie-ustalonych. Wskaz
nik ptr3 jest wskaz
nikiem nie-ustalonym, który służy do
wskazywania zmiennych ustalonych. Wskaz
nik ptr4 jest wskaz
nikiem ustalonym, który służy do wskazywania
zmiennych ustalonych.
Zmienne odnośnikowe
Odnośnikiem jest zmienna, którą można zainicjować odniesieniem. Deklarację odnośnika można poznać po tym,
że jej identyfikator jest poprzedzony symbolem & (ampersand). Istnieją odnośniki do zmiennych, ale nie istnieją
tablice odnośników. Każdy odnośnik musi być zainicjowany.
Uwaga: Jeśli w pewnym miejscu programu występuje nazwa zmiennej, a program byłby poprawny tylko
wówczas, gdyby występowała tam nazwa odnośnika do zmiennej, to nazwę zmiennej niejawnie przekształca się
w odnośnik.
int fix = 10;
int &ref = fix; // int &ref = (int &)fix;
Ponieważ odnośnik ref jest typu int &, więc nie może być zainicjowany wartością zmiennej fix, która jest typu
int. Dlatego, za pomocą niejawnej konwersji (int &)fix, nazwę zmiennej fix niejawnie przekształca się w
odnośnik.
Po zainicjowaniu odnośnika ref odniesieniem do zmiennej, napis ref staje się trwałą nazwą tej zmiennej. A więc
odnośnik można zainicjować, ale nie można mu przypisać odniesienia.
#include
28
int main(void)
{
int fix = 10;
int &ref = fix;
ref = 10;
cout << fix << ref << endl; // 10 10
return 0;
}
Po zainicjowaniu odnośnika, napis ref staje się trwałą nazwą zmiennej fix. Dlatego przypisanie ref = 10 zmienia
wartość zmiennej fix, ale nie zmienia wartości odnośnika ref.
Dla dociekliwych
Typ wyrażenia inicjującego odnośnik musi być zgodny z typem odnośnika. Przyjmuje się z definicji, że typ
"odnośnik do zmiennej typu Type" (np. int &) jest zgodny z typem Type (np. int). Jeśli wyrażenie inicjujące jest
innego typu, to może być poddane niejawnej konwersji do typu zgodnego, ale tylko wówczas, gdy typ odnośnika
jest ustalony (const). W takim wypadku odnośnik zostanie zainicjowany odniesieniem do zmiennej pomocniczej
typu z nim zgodnego, zainicjowanej wartością wyrażenia po konwersji.
int &ref1 = 2.4; // błąd
const int &ref = 2.4;
Identyfikator ref2 jest trwałą nazwą zmiennej pomocniczej o wartości (int)2.4.
Wskaz
niki i odnośniki
Podejmując decyzję o użyciu wskaz
nika, czy odnośnika, należy kierować się wytyczną, że wszędzie tam gdzie
jest to możliwe, należy stosować odnośniki, gdyż zwiększa to czytelność programu.
W rzadkich przypadkach stosuje się odnośniki do wskaz
ników. Jest to niezbędne wówczas, gdy poprzez
odnośnik należy zmodyfikować wskaz
nik.
#include
int main(void)
{
int vec[3] = { 10, 20, 30 };
int *ptr = vec;
int *&ref = ptr;
++ref;
cout << *ptr << endl; // 20
return 0;
}
Po zadeklarowaniu odnośnika, napis ref jest trwałą nazwą wskaz
nika ptr. Dlatego po wykonaniu operacji ++ref
wskaz
nik ptr wskazuje element vec[1] o wartości 20.
Gdyby z deklaracji odnośnika usunięto znak &, to napis ref stałby się nazwą wskaz
nika zainicjowanego
wskazaniem elementu vec[0], a wykonanie operacji ++ref nie miałoby żadnego wpływu na wskaz
nik ptr. W takim
wypadku nastąpiłoby wyprowadzenie liczby 10.
29
Przetwarzanie łańcuchów
A
ańcuchem jest dowolna sekwencja elementów tablicy znakowej, zakończona elementem o wartości 0. Ponieważ
każdy literał łańcuchowy jest nazwą takiej właśnie sekwencji elementów, więc jest nazwą łańcucha.
W szczególności, literał "Hello" jest nazwą 6-elementowej tablicy znakowej, której element "Hello"[0] ma
wartość 'H', a element "Hello"[5] ma wartość 0.
Do typowych operacji wykonywanych na łańcuchach należą: wprowadzenie i wyprowadzenie łańcucha,
wyznaczenie długości łańcucha (strlen), skopiowanie łańcucha (strcpy), połączenie łańcuchów (strcat) i
porównanie łańcuchów (strcmp). Operacje te można wykonać za pomocą funkcji bibliotecznych,
zadeklarowanych w nagłówku string.h.
Uwaga: Jeśli wskaz
nik wskazuje pierwszy element łańcucha, to mówi się w skrócie, że wskazuje łańcuch..
int strlen(char *pStr)
Dostarcza liczbę znaków łańcucha wskazanego przez argument.
np.
cout << strlen("Hello"); // 5
char *strcpy(char *pTrg, const char *pSrc)
Dostarcza pierwszy argument. Ponadto kopiuje, począwszy od miejsca wskazanego przez pierwszy argument,
łańcuch wskazany przez drugi argument.
np.
char buf[100] = "Hello ";
cout << strcpy(buf + 6, "World")- 6; // Hello World
char *strcat(char *pTrg, const char *pSrc)
Dostarcza pierwszy argument. Ponadto kopiuje, poczawszy od miejsca, w którym znajduje się znak końca
łańcucha wskazanego przez pierwszy argument, łańcuch wskazany przez drugi argument.
np.
char buf[100] = "Hello ";
cout << strcat(buf, "World"); // Hello World
int strcmp(const char *pOne, const char *pTwo)
Dostarcza wartość +1 jeśli łańcuch wskazany przez pierwszy argument jest większy niż łańcuch wskazany przez
drugi argument, dostarcza wartość 0 jeśli są równe, albo wartość -1 jeśli pierwszy jest mniejszy.
Uwaga: Porównanie łańcuchów zastępuje się porównaniem pierwszej pary znaków różnych. Jeśli jeden z
łańcuchów jest podłańcuchem drugiego, to za większy uznaje się dłuższy.
np.
cout << strcmp("abc", "abaaaaa"); // -1
cout << strcmp("abcde", "ab"); // 1
cout << strcmp("ab", "ab"); // 0
Wprowadzanie i wyprowadzanie łańcuchów
Operacja wprowadzenia łańcucha ma postać cin >> ptr, w której ptr jest wskaz
nikiem elementu tablicy
znakowej. Jej wykonanie powoduje umieszczenie w tablicy, począwszy od jej elementu *ptr, kodów spójnego
ciągu znaków wejściowych oraz kodu znaku '\0' (o wartości 0).
Przed wprowadzeniem znaków zostaną pominięte odstępy wiodące. W celu zabezpieczenia się przed
przepełnieniem tablicy można użyć manipulatora setw.
30
Operacja wyprowadzenia łańcucha ma postać cout << ptr, w której ptr jest wskaz
nikiem. Zabrania się, aby ptr
było wskaz
nikiem elementu tablicy, który nie jest zerowym elementem łańcucha.
#include
#include
const int Size = 100;
char buffer[Size] = "prof. ";
int main(void)
{
int len1 = strlen(buffer);
cin >> buffer + len1;
int len2 = strlen(buffer);
buffer[len2] = ' ';
buffer[len2+1] = 0;
cin >> buffer + len2 + 1;
cout << buffer << endl;
cout << "dr " << buffer + len1 << endl;
return 0;
}
Jeśli z klawiatury wprowadzi się imię i nazwisko (np. Jan Bielecki), to program wyprowadzi to imię i to nazwisko
poprzedzone napisem prof. (np. prof. Jan Bielecki), a ponadto tylko to imię i to nazwisko.
Wyznaczenie długości
#include
#include
char str[6] = "Hello";
int main(void)
{
cout << strlen("Hello") << endl; // 5
char *ptr = str;
int len = 0;
while(*ptr != 0) {
len++;
ptr++;
}
cout << len << endl; // 5
ptr = str;
len = 0;
while(*ptr++)
len++;
cout << len << endl; // 5
return 0;
}
Pokazano trzy sposoby wyznaczenia długości łańcucha zapisanego w tablicy znakowej.
Wyrażenie *ptr++ jest nazwą zmiennej, wskazywanej przez wskaz
nik ptr, przed wykonaniem na nim operacji
zwiększenia.
Kopiowanie
#include
#include
char src[7] = "Hello ";
31
char trg[100];
int main(void)
{
char *pSrc = src,
*pTrg = trg;
strcpy(pTrg, pSrc);
cout << trg << endl; // Hello
while(*pSrc != 0) {
*pTrg = *pSrc;
pSrc++;
pTrg++;
}
pTrg = 0;
cout << trg << endl; // Hello
pSrc = src;
pTrg = trg;
while(*pTrg++ = *pSrc++)
;
cout << trg << endl; // Hello
return 0;
}
Pokazano trzy sposoby kopiowania łańcucha znaków.
A
ączenie
#include
#include
char *pSrc = "Hello",
buf[100];
int main(void)
{
strcat(strcpy(buf, pSrc), "!");
cout << buf << endl; // Hello!
char *pBuf = buf;
strcpy(pBuf, pSrc);
while(*pBuf++)
;
char *pSrc = "!";
while(pBuf++[-1] = *pSrc++)
;
cout << buf << endl; // Hello!
return 0;
}
Pokazano dwa sposoby łączenia łańcuchów.
Porównanie
#include
#include
char one[100],
two[100];
int main(void)
{
cin >> one >> two;
32
 cout << one;
switch(strcmp(one, two)) {
case +1:
cout << " > ";
break;
case -1:
cout << " < ";
break;
default:
cout << " == ";
}
cout << two << endl;
char *pOne = one,
*pTwo = two;
cout << one;
while(*pOne == *pTwo && *pOne != 0) {
pOne++;
pTwo++;
}
if(*pOne == 0 && *pTwo == 0)
cout << " == ";
else if(*pOne > *pTwo)
cout << " > ";
else
cout << " < ";
cout << two << endl;
pOne = one;
pTwo = two;
cout << one;
while(*pOne || *pTwo) {
if(*pOne++ != *pTwo++) {
if(pOne[-1] > pTwo[-1])
cout << " > ";
else
cout << " < ";
cout << two << endl;
return 0;
}
}
cout << " == ";
cout << two << endl;
return 0;
}
Pokazano trzy sposoby porównywania łańcuchów wprowadzonych z klawiatury.
33
Posługiwanie się funkcjami
Funkcja jest sparametryzowanym opisem czynności. W miejscu wywołania funkcji musi być znana jej
deklaracja albo definicja. W szczególności oznacza to, że wywołanie
sum(10, 20)
funkcji sumującej argumenty, musi być poprzedzone
albo jej definicją
int sum(int one, int two)
{
return one + two;
}
albo jej deklaracją
int sum(int one, int two);
albo włączeniem nagłówka zawierającego deklarację.
Uwaga: W deklaracji funkcji można pominąć dowolny zestaw identyfikatorów parametrów. Jeśli uczyni się to w
definicji, to uniemożliwi to odwoływanie się do argumentów.
Parametry i argumenty
Wywołanie funkcji zaczyna się od skojarzenia jej parametrów z argumentami. Skojarzenie parametru z
argumentem odbywa się przez-wartość, co oznacza, że parametr jest traktowany tak, jak lokalna zmienna funkcji,
zadeklarowana tuż przed jej pierwszą instrukcją i zainicjowana wartością argumentu.
A zatem, jeśli definicją funkcji jest
int sum(int one, int two)
{
return one + two;
}
to dla wywołania
sum(10, 20)
funkcja jest traktowana tak, jakby miała postać
int sum()
{
int one = 10;
int two = 20;
return one + two;
}
34
Parametry zwykłe
Parametr funkcji jest "zwykły", jeśli nie jest wskaz
nikiem ani odnośnikiem. Z parametrem zwykłym można
skojarzyć argument, który jest takiego samego typu jak parametr, albo który można poddać niejawnej konwersji
do typu parametru.
Zainicjowanie parametru polega na skopiowaniu argumentu. Jeśli argument jest strukturą, to kopiuje się
wszystkie jej elementy (co w przypadku dużych struktur ma oczywiste wady!).
Po dokonaniu skojarzenia, wszelkie operacje wykonywane na parametrze dotyczą lokalnej zmiennej
zainicjowanej argumentem i nie powodują zmiany wartości skojarzonego z nim argumentu.
#include
int main(void)
{
void inc(int par);
int fix = 10;
cout << fix << endl; // 10
inc(fix);
cout << fix << endl; // 10
return 0;
}
void inc(int par)
{
++par;
}
Program potwierdza, że wykonanie operacji na parametrze "zwykłym" nie powoduje zmiany wartości
skojarzonego z nim argumentu.
Parametry wskaz
nikowe
Z parametrem wskaz
nikowym można skojarzyć argument, który jest takiego samego typu jak parametr, albo
który można poddać niejawnej konwersji do typu parametru.
Zainicjowanie parametru polega na skopiowania wskaz
nika. Nie pociąga to za sobą kopiowania zmiennej
identyfikowanej przez argument (co można wykorzystać w przypadku dużych struktur!).
Po dokonaniu skojarzenia, wszelkie operacje wykonywane na parametrze dotyczą lokalnej zmiennej
zainicjowanej argumentem, ale operacje wykonywane za pośrednictwem parametru (np. *par, par[i] albo par->f)
dotyczą zmiennej wskazywanej przez argument. Może to mieć wpływ na wartość argumentu.
#include
int main(void)
{
void inc(int *ptr);
int fix = 10;
cout << fix << endl; // 10
inc(&fix);
cout << fix << endl; // 11
return 0;
}
void inc(int *ptr)
{
++*ptr;
}
35
Program potwierdza, że wykonanie operacji za pośrednictwem parametru wskaz
nikowego może powodować
zmianę wartości zmiennej wskazywanej przez skojarzony z nim argument.
Parametry tablicowe
Każdy parametr tablicowy jest niejawnie zastępowany parametrem wskaz
nikowym, który powstaje po
zastąpieniu deklaratora vec[i] deklaratorem (* const vec).
W szczególności funkcja
int sum(int tab[20])
{
int sum = 0;
for(int i = 0; i < 3 ; i++)
sum += tab[i];
return sum;
}
jest niejawnie przekształcana w funkcję
int sum(int *const tab)
{
int sum = 0;
for(int i = 0; i < 3 ; i++)
sum += tab[i];
return sum;
}
Powoduje to, że jeśli chce się zdefiniować funkcję do sumowania tablic, nie odwołującą się do zmiennych
globalnych, to jeden z jej argumentów musi określać liczbę elementów tablicy.
#include
int sum(int tab[], int count)
{
int sum = 0;
for(int i = 0; i < count ; i++)
sum += tab[i];
return sum;
}
int main(void)
{
int small[] = { 10 },
large[] = { 10, 20, 30 };
cout << sum(small, 1) << endl;
cout << sum(large, 3) << endl;
return 0;
}
Parametry odnośnikowe
Z parametrem odnośnikowym można skojarzyć argument, który jest takiego samego typu jak parametr, albo
który można poddać niejawnej konwersji do typu parametru.
Zainicjowanie parametru polega na skopiowania odnośnika. Podobnie jak dla parametru wskaz
nikowego, nie
pociąga to za sobą kopiowania zmiennej identyfikowanej przez argument.
Po dokonaniu skojarzenia, wszelkie operacje wykonywane na parametrze dotyczą zmiennej identyfikowanej
przez argument. Może to powodować zmianę wartości skojarzonego z nim argumentu.
36
#include
int main(void)
{
void inc(int &ref);
int fix = 10;
cout << fix << endl; // 10
inc(fix);
cout << fix << endl; // 11
return 0;
}
void inc(int &ref)
{
++ref;
}
Program potwierdza, że wykonanie operacji za pośrednictwem parametru odnośnikowego może powodować
zmianę wartości skojarzonego z nim argumentu.
Parametry funkcji main
Funkcja główna może być zadeklarowana jako bezparametrowa albo dwu-parametrowa. Jeśli jest
dwuparametrowa, to jej pierwszy parametr jest typu int i ma wartość równą liczbie argumentów programu
zwiększonej o 1, a drugi jest typu char *[] i jest tablicą odnośników do łańcuchów zainicjowanych nazwą
programu oraz nazwami jego argumentów.
#include
int main(int argc, char *argv[])
{
cout << "My name is: " << argv[0] << endl;
cout << "My arguments are: " << endl;
for(int i = 1; i < argc ; i++)
cout << argv[i] << endl;
return 0;
}
Program wyprowadza swoją nazwę i argumenty; każde w osobnym wierszu.
Skojarzenia powrotne
W chwili zakończenia wykonywania funkcji rezultatowej (o typie różnym od void) następuje skojarzenie jej
rezultatu z wyrażeniem występującym w instrukcji powrotu. Odbywa się to według tych samych zasad co
skojarzenie parametru z argumentem i polega na zainicjowaniu rezultatu funkcji wyrażeniem występującym w
instrukcji powrotu.
Uwaga: Rezultat funkcji jest zmienną. Typ rezultatu jest identyczny z typem funkcji. Nazwą rezultatu jest
wywołanie funkcji. Z punktu widzenia łączenia operacji (np. ++*fun(1,2)+3), nazwa funkcji jest zastępowana
nazwą rezultatu.
#include
#include
double sqr(double val)
{
return val * val;
}
37
int main(void)
{
double a, b;
cin >> a >> b;
cout << sqrt(sqr(a) + sqr(b)) << endl;
return 0;
}
Wywołanie sqr(a) jest nazwą rezultatu o wartości "kwadrat a", wywołanie sqr(b) jest nazwą rezultatu o wartości
"kwadrat b", a wyrażenie sqrt(sqr(a) + sqr(b)) jest nazwą rezultatu o wartości "pierwiastek z sumy kwadratów
a i b".
Typ nie-odnośnikowy
Jeśli typ funkcji jest nie-odnośnikowy, to zainicjowanie rezultatu polega na skopiowaniu zmiennej, której nazwą
jest wyrażenie występujące w instrukcji powrotu.
Jeśli typ wyrażenia nie jest identyczny z typem funkcji, to wyrażenie jest poddawane konwersji do typu rezultatu.
Zezwala się na niejawne wykonanie co najwyżej jednej konwersji standardowej i jednej definiowanej.
#include
double getSqr(int par);
int main(void)
{
cout << getSqr(3) << endl; // 9
return 0;
}
double getSqr(int par)
{
return par * par; // return double(par * par);
}
Wyrażenie par * par jest nazwą zmiennej typu int zainicjowanej daną o wartości 9.
Ponieważ typ rezultatu jest różny od typu tej zmiennej, więc zostanie zastosowana niejawna konwersja
standardowa z typu int do double.
Po zainicjowaniu rezultatu zmienną double(par * par), wywołanie getSqr(3) można traktować nazwę rezultatu.
dla dociekliwych
#include
struct Child {
char name[20];
int age;
};
Child isa = { "Isabel", 15 };
Child getOlder(Child child, int val);
void show(Child &child);
int main(void)
{
show(isa); // Isabel is 15
show(getOlder(isa, 2)); // Isabel is 17
show(isa); // Isabel is 15
38
 return 0;
}
Child getOlder(Child child, int val)
{
child.age += val;
return child;
}
void show(Child &child)
{
cout << child.name << " is " <<
child.age << endl;
}
Wywołanie funkcji getOlder(isa, 2) powoduje skopiowanie struktury isa do lokalnej zmiennej funkcji getOlder.
Operacja child.age += val jest wykonywana na tej zmiennej lokalnej.
Wywołanie getOlder(isa, 2) jest nazwą zmiennej, do której skopiowano tę zmienną lokalną.
Typ odnośnikowy
Jeśli typ funkcji jest odnośnikowy, to zainicjowanie rezultatu polega na skopiowaniu odnośnika do tej zmiennej,
której nazwą jest wyrażenie występujące w instrukcji powrotu. A zatem wywołanie funkcji jest nazwą tej
zmiennej.
#include
int &refVal(void)
{
static int val = -1;
return ++val;
}
int main(void)
{
cout << refVal() << endl; // 0
cout << refVal() << endl; // 1
refVal() = 5;
cout << refVal() << endl; // 6
++refVal();
cout << refVal() << endl; // 9
return 0;
}
Wywołanie refVal() jest nazwą statycznej zmiennej val. A zatem każda operacja wykonana na refVal() dotyczy
tej właśnie zmiennej.
dla dociekliwych
Jeśli typ wyrażenia w instrukcji powrotu nie jest zgodny z typem funkcji, to typ funkcji musi być ustalony
(const), a ponadto musi istnieć niejawna konwersja z typu wyrażenia do typu zgodnego z typem funkcji.
#include
const int &refVal(double par)
{
return par * par; // return double(par * par);
}
39
int main(void)
{
cout << refVal(3) << endl;
return 0;
}
Uwaga: Wyrażenie zawarte w instrukcji powrotu może tylko wówczas identyfikować zmienną lokalną funkcji,
gdy typ funkcji jest ustalony.
#include
int &getInc(int par);
int main(void)
{
cout << getInc(3) << endl; // błąd
return 0;
}
int &getInc(int par)
{
return ++par;
}
Wywołanie getInc(3) jest nazwą lokalnej zmiennej par. Ponieważ po powrocie z funkcji getInc zmienna par już
nie istnieje, więc odwołanie się do niej jest zabronione. W Visual C++ program wyprowadza liczbę 4.
Program można poprawić, nadając mu postać
#include
const int &getInc(int par);
int main(void)
{
cout << getInc(3) << endl; // 4
return 0;
}
const int &getInc(int par)
{
return ++par;
}
Deklarowanie funkcji
Deklaracja funkcji podaje jej identyfikator oraz określa typ funkcji oraz typy jej parametrów. Jeśli ponadto
podaje ciało funkcji, to jest jej definicją.
Funkcje bezrezultatowe
Funkcja, której typem jest void, jest funkcją bezrezultatową. Jej wywołanie kończy się w chwili wykonania
instrukcji powrotu nie zawierającej wyrażenia, albo w chwili zakończenia wykonywania jej ciała.
void outDiv(int a, int b)
{
if(b == 0)
return;
cout << a / b;
}
40
Funkcje otwarte i zamknięte
Funkcja zadeklarowana ze specyfikatorem inline jest realizowana jako otwarta. W odróżnieniu od funkcji
zamkniętej, ciało funkcji otwartej wstawia się w każdym miejscu jej wywołania. Powoduje to przyspieszenie
wykonania programu, ale niekiedy wydłuża jego kod wynikowy.
Uwaga: Wystąpienie specyfikatora inline nie ma wpływu na skutek wykonania programu. Jeśli funkcja otwarta
zostanie uznana za zbyt skomplikowaną, to może być zrealizowana jako zamknięta.
inline in sum(int a int b)
{
return a + b;
}
Funkcje przeciążone
Jeśli w pewnym zakresie są widoczne deklaracje dwóch lub większej liczby funkcji o takiej samej nazwie, ale
różniących się typami parametrów, to ogół takich funkcji stanowi wieloaspektową funkcję przeciążoną.
W miejscu wywołania funkcji przeciążonej wywołuje się ten z jej aspektów, do którego parametrów najlepiej
pasują podane argumenty. Ma to miejsce wówczas, gdy istnieje taki aspekt, że do każdego z jego parametrów
podany argument pasuje nie gorzej niż do pozostałych, ale istnieje taki parametr, do którego jeden z argumentów
pasuje lepiej niż do pozostałych.
Uwaga: Jeśli argument nie pasuje do parametru dokładnie, to może być poddany konwersji dopasowującej, ale
im konwersja ta jest bardziej złożona, tym dopasowanie pierwotnego argumentu uznaje się za gorsze.
#include
void out(char par);
void out(int par);
int main(void)
{
out('a');
out(2);
out(2.0); // błąd (niejednoznaczność)
return 0;
}
void out(char par)
{
cout << par << endl;
}
void out(int par)
{
cout << par << endl;
}
Argument 'a' typu char najlepiej pasuje do parametru typu char, a argument 2 typu int najlepiej pasuje do
parametru typu int.
Argument 2.0 typu double pasuje równie dobrze do parametru typu char jak i do parametru typu int. Ponieważ
do żadnego z nich nie pasuje najlepiej, więc wywołanie out(2.0) jest błędne.
Gdyby z programu usunięto dowolną z funkcji out, to wszystkie odwołania do out byłyby poprawne.
41
Argumenty domniemane
W deklaracji parametru funkcji może wystąpić inicjator wyrażeniowy określający domniemaną wartość
argumentu kojarzonego z tym parametrem.
int sum(int a, int b =0, int c =0);
Jeśli pewien parametr wyposażono w argument domniemany, to każdy z następnych parametrów także musi być
wyposażony w argument domniemany.
int sum(int a, int b =0, int c); // błąd
Z każdym parametrem nie wyposażonym w argument domniemany musi być skojarzony jawny argument.
Końcowy zestaw argumentów, dla których podano domniemania, można pominąć. W ich miejscu zostaną użyte
argumenty domniemane.
#include
int sum(int a, int b, int c =0, int d =0);
int main(void)
{
cout << sum(1, 2, 3) << endl; // 6
cout << sum(1, 2) << endl; // 3
cout << sum(1) << endl; // błąd
return 0;
}
int sum(int a, int b, int c, int d)
{
return a + b + c + d;
}
dla dociekliwych
Wyrażenie określające wartość argumentu domniemanego nie musi być wyrażeniem stałym. W takim wypadku
jest opracowywane w kontekście jego deklaracji, a nie w kontekście jego użycia.
#include
int p = 20;
int sub(int a =p*p)
{
return a;
}
int main(void)
{
int p = 10;
cout << sub() << endl; // 400
::p = 10;
cout << sub() << endl; // 100
return 0;
}
Wywołania rekurencyjne
42
Wywołanie funkcji jest rekurencyjne, jeśli nastąpi przed powrotem z jej poprzedniego wywołania. Użycie
rekurencji może uczynić program czytelniejszym, ale w wielu wypadkach powoduje zwiększenie rozmiaru
pamięci operacyjnej niezbędnej do jego wykonania.
#include
#include
#include
int sqrt(int par, int min =0, int max =INT_MAX)
{
int mid = (min + max) / 2;
if(mid == min)
return mid;
if(par < double(mid) * mid)
return sqrt(par, min, mid);
else
return sqrt(par, mid, max);
}
int main(void)
{
int val;
cin >> val;
val = abs(val);
cout << "sqrt(" << val << ") = " <<
sqrt(val) << endl;
return 0;
}
Funkcja sqrt dostarcza pierwiastek z jej nieujemnego argumentu. Nieobowiązkowe argumenty dodatkowe
określają przedział, w którym znajduje się pierwiastek.
Definiowanie funkcji
Zdefiniowanie funkcji polega na podaniu jej ciała. Dobry styl programowania poznaje się po użyciu wielu
krótkich, a nie małej liczby długich funkcji.
Tak dalece jak jest to możliwe, należy posługiwać się funkcjami bibliotecznymi. Ilustruje to następujący
program, który napisano w dwóch wersjach: z użyciem i bez użycia funkcji bibliotecznych.
#include
#include
#include
const int Size = 100;
int main(void)
{
char srcOne[Size],
srcTwo[Size];
cin >> setw(Size) >> srcOne >>
setw(Size) >> srcTwo;
char trg[2*Size-1];
strcat(strcpy(trg, srcOne), " ");
int len = strlen(strcat(trg, srcTwo));
cout << trg << endl << len << endl;
return 0;
}
43
Program wprowadza dwa łańcuchy, łączy je oddzielając spacją, a następnie wyprowadza: łańuch docelowy,
długość łańcucha docelowego i wynik porównania łańcuchów z
ródłowych.
#include
const int Size = 100;
int strLen(char *ptr);
char *strCpy(char *pTrg, char *pSrc);
char *strCat(char *pTrg, char *pSrc);
int strCmp(char *pOne, char *pTwo);
int main(void)
{
char srcOne[Size],
srcTwo[Size];
cin >> setw(Size) >> srcOne >>
setw(Size) >> srcTwo;
char trg[2*Size-1];
strCat(strCpy(trg, srcOne), " ");
int len = strLen(strCat(trg, srcTwo));
cout << trg << endl << len << endl;
cout << srcOne << ' ';
char chr = '=';
switch(strCmp(srcOne, srcTwo)) {
case +1:
chr = '>';
break;
case -1:
chr = '<';
break;
}
cout << chr << ' ' << srcTwo << endl;
return 0;
}
int strLen(char *ptr)
{
int len = 0;
while(*ptr++)
len++;
return len;
}
char *strCpy(char *pTrg, char *pSrc)
{
char *pTrg2 = pTrg;
while(*pTrg++ = *pSrc++);
return pTrg2;
}
char *strCat(char *pTrg, char *pSrc)
{
char *pTrg2 = pTrg;
strCpy(pTrg += strLen(pTrg), pSrc);
return pTrg2;
}
int strCmp(char *pOne, char *pTwo)
{
while(*pOne || *pTwo)
if(*pOne++ != *pTwo++)
if(pOne[-1] > pTwo[-1])
return +1;
else
return -1;
44
 return 0;
}
45
Zarządzanie pamięcią
Wykonanie programu polega na przepływie sterowania przez jego deklaracje, definicje i instrukcje.
W pierwszej kolejności sterowanie przepływa przez wszystkie deklaracje globalne (takie, które nie wchodzą w
skład innych deklaracji). Następnie jest wyszukiwana funkcja główna i sterowanie przepływa przez zawarte w
niej instrukcje. Przepływ sterowania kończy się po powrocie z wywołania funkcji exit albo po wykonaniu
instrukcji powrotu z funkcji głównej.
#include
#include
int main(void)
{
int num;
cin >> num;
if(num != 0) {
cout << num << endl;
exit(num);
}
return 0;
}
W zależności od tego, jaką wartość ma wprowadzona liczba, program kończy się po napotkaniu instrukcji
powrotu albo po wywołaniu funkcji exit.
Zmienne statyczne
Jeśli sterowanie przepłynie przez definicję zmiennej globalnej, albo przez definicję zmiennej lokalnej
zadeklarowanej ze specyfikatorem static, to zostanie utworzona zmienna statyczna. Tuż przed zakończeniem
wykonywania programu wszystkie zmienne statyczne zostaną zniszczone. Odbędzie się to w kolejności
odwrotnej do ich tworzenia.
Uwaga: Zmienna statyczna jest tworzona w obszarze statycznym. Inicjator zmiennej statycznej jest brany pod
uwagę tylko podczas pierwszego opracowania jej deklaracji.
#include
int main(void)
{
void fun(int par);
fun(10);
static int one = 1;
fun(20);
return 0;
}
int two = 2;
void fun(int par)
{
static int loc = par;
cout << loc << ' ' << par << endl;
loc++;
46
}
Zmienne statyczne one, two, loc zostaną utworzone w kolejności: two, loc, one, a zostaną zniszczone w
Komentarz [PPL1]:
kolejności: one, loc, two.
Program wyprowadzi dwie pary liczb: 10 10 i 11 20.
Zmienne automatyczne
Jeśli sterowanie przepłynie przez definicję zmiennej lokalnej, nie zadeklarowanej ze specyfikatorem static albo
extern, to zostanie utworzona zmienna automatyczna. Jawny albo niejawny inicjator zmiennej automatycznej
będzie brany pod uwagę podczas każdego opracowania tej definicji.
Uwaga: Zmienne automatyczne tworzy się na stosie. Stos jest obszarem pamięci, w którym można tworzyć
zmienne, ale takim, że można je niszczyć tylko w kolejności odwrotnej do ich tworzenia.
void sub(void)
{
int num; // int num = int();
cout << num; // błąd
// ...
}
Zmienną automatyczną num wyposażono w niejawny inicjator = int() dostarczający wartość nieokreśloną.
Zmienna automatyczna zostanie zniszczona tuż przed zakończeniem wykonywania bloku (wnętrza instrukcji
grupującej), w którym ją zadeklarowano. Jeśli w bloku zadeklarowano więcej niż jedną zmienną automatyczną,
to ich niszczenie odbędzie się w kolejności odwrotnej do ich tworzenia, ale przed przystąpieniem do niszczenia
zmiennych statycznych.
#include
int main(void)
{
int cnt = 2;
while(cnt > 0) {
int val = cnt--;
cout << val << endl;
}
return 0;
}
int one = 10;
Najpierw zostanie utworzona zmienna statyczna one, a po niej zmienna automatyczna cnt. Następnie zostanie
utworzona i zniszczona zmienna automatyczna val zainicjowana wartością 2, a po tym zostanie utworzona i
zniszczona zmienna automatyczna val zainicjowana wartością 1. Tuż przed wykonaniem instrukcji powrotu
zostanie zniszczona zmienna cnt, a po niej zmienna one.
Zmienne kontrolowane
Zmienna kontrolowana powstaje na skutek wykonania operacji new, a jest niszczona po jawnym wykonaniu
operacji delete. Zmienne kontrolowane są tworzone na stercie. Sterta jest obszarem pamięci, do którego można
dokładać zmienne, a następnie usuwać je w dowolnej kolejności.
47
Jeśli wykonanie operacji new jest niemożliwe, ponieważ wyczerpano obszar sterty, to rezultatem operacji
przydzielenia pamięci jest wskaz
nik pusty (o wartości reprezentowanej przez 0).
Uwaga: Programiści rzadko badają rezultat operacji new, bo są z natury optymistami.
int *ptr = new char [10000000];
if(ptr == 0) {
cout << "No memory" << endl;
exit(-1);
}
Zmienne skalarne
Wykonanie operacji
new Type
w której Type jest opisem typu skalarnego (tj. nie-tablicowego!), powoduje utworzenie na stercie zmiennej typu
Type. Rezultatem operacji jest wskaz
nik zainicjowany wskazaniem utworzonej zmiennej.
Wykonanie operacji
delete ptr
w której ptr wskazuje zmienną utworzoną na stercie, powoduje zniszczenie tej zmiennej.
#include
int main(void)
{
int *pOne = new int;
double &two = *new double;
two = 2.8;
*pOne = (int)two;
cout << *pOne << endl; // 2
delete pOne;
delete &two;
return 0;
}
Najpierw zostanie utworzona zmienna typu int, a następnie zmienna typu double. Najpierw zostanie zniszczona
zmienna typu int, a następnie zmienna typu double.
Zmienne tablicowe
Wykonanie operacji
new Type
w której Type jest opisem typu tablicowego (np. int [12]), powoduje utworzenie na stercie zmiennej typu Type.
Rezultatem operacji jest wskaz
nik zainicjowany wskazaniem zerowego elementu utworzonej tablicy.
Jeśli elementami tablicy są obiekty, to do ich zainicjowania jest niejawnie stosowany konstruktor domyślny.
Uwaga: Wyrażenie określające liczbę elementów tablicy nie musi być wyrażeniem stałym.
Wykonanie operacji
delete [] ptr
48
w której ptr wskazuje zerowy element tablicy utworzonej na stercie, powoduje zniszczenie tej tablicy.
#include
#include
int main(void)
{
char *ptr = new char [100];
cin >> ptr;
char &vec = *new char [strlen(ptr) + 1];
cout << strcpy(&vec, ptr) << endl;
delete [] ptr;
delete [] &vec;
return 0;
}
Program tworzy na stercie 100-elementową tablicę znakową i wprowadza do niej ciąg znaków. Następnie tworzy
na stercie najmniejszą tablicę, w której można pomieścić wprowadzony ciąg znaków oraz tworzy na stosie
odnośnik vec identyfikujący zerowy element tej tablicy.
Przed zakończeniem wykonywania program niszczy obie tablice, w kolejności ich utworzenia.
Ostrzeżenie
W żadnym wypadku nie wolno zmiennej utworzonej za pomocą operacji new dla zmiennych skalarnych niszczyć
za pomocą operacji delete dla zmiennych tablicowych, a zmiennej utworzonej za pomocą operacji new dla
zmiennych tablicowych niszczyć za pomocą operacji delete dla zmiennych skalarnych.
Nie wolno także używać operacji delete ze wskaz
nikiem ptr identyfikującym co innego niż zmienna skalarna
albo zerowy element tablicy utworzonej za pomocą operacji new, ani przyjmować, że po wykonaniu operacji
delete wskaz
nik ptr ma wartość określoną.
Uwaga: W celu uniknięcia trudnych do wykrycia błędów, zaleca się (o ile to możliwe) zerowanie wskaz
nika ptr
bezpośrednio po użyciu go w operacji delete.
#include
int main(void)
{
int *ptr = new int [5];
delete [] (ptr + 2); // błąd
int &vec = *new int [5];
delete &vec; // błąd
int &ref = (*new int) = 3;
delete &ref;
cout << ref << endl; // błąd
return 0;
}
Mimo iż program jest poprawny składniowo, zawiera 3 poważne błędy logiczne. Wykonany w środowisku
Visual C++, program ten załamuje system zarządzania stertą.
49
Widoczność deklaracji
Identyfikatorem zmiennej, funkcji i typu można posługiwać się tylko w miejscu, w którym jest widoczna jego
deklaracja.
Zaleca się, aby w tym samym zakresie, identyfikator użyty do zadeklarowania zmiennej, funkcji albo typu nie
został użyty do zadeklarowania innej zmiennej, funkcji albo typu.
Uwaga: Podano zalecenie, a nie zakaz, ponieważ w tym samym zakresie mogą wystąpić, nie kolidujące za sobą,
deklaracje funkcji i typu.
void id(int id)
{
struct id {
};
extern void id(id id);
int id = 10; // błąd
}
Z każdą deklaracja jest związany jej zakres i zasięg. Jeśli w pewnym module zdefiniowano identyfikator o
zasięgu globalnym, a w innym zadeklarowano go ze specyfikatorem extern, to oba dotyczą tej samej zmiennej,
funkcji albo typu.
plik Main.cpp
#include
int fix = 10; // definicja
int main(void)
{
extern void fun(void); // deklaracja
fun();
return 0;
}
plik One.cpp
#include
void fun() // definicja
{
extern int fix; // deklaracja
cout << fix << endl; // 10
}
Gdyby pominięto wszystkie specyfikatory extern, to program stałby się statycznie poprawny, ale dynamicznie
błędny. Błąd polegałby na użyciu wartości zmiennej, której nie zainicjowano.
Deklaracje lokalne
Zakresem deklaracji identyfikatora zadeklarowanego w bloku jest obszar programu od punktu zadeklarowania
do końca bloku. Zasięgiem deklaracji jest ta część zakresu, która nie jest zakresem innej deklaracji takiego
samego identyfikatora.
50
#include
int main(void)
{
int num = 10;
cout << num << endl; // 10
{
cout << num << endl; // 10
int num = 20;
cout << num << endl; // 20
}
cout << num << endl; // 10
return 0;
}
Zakresem deklaracji pierwszej zmiennej num jest obszar zaczynający się od = 10 i kończący na klamrze
zamykającej funkcję main.
Zakresem deklaracji drugiej zmiennej num jest obszar zaczynający się od = 20 i kończący na klamrze
zamykającej blok wewnętrzny.
Zasięgiem deklaracji pierwszej zmiennej num jest zakres deklaracji pierwszej zmiennej num, pomniejszony o
zakres deklaracji drugiej zmiennej num.
Deklaracje globalne
Zakresem deklaracji identyfikatora zadeklarowanego w module (tj. poza blokiem), jest obszar programu od
punktu zadeklarowania do końca modułu. Zasięgiem deklaracji jest ta część zakresu, która nie jest zakresem
innej deklaracji takiego samego identyfikatora.
Uwaga: Modułem jest zawartość pliku *.cpp projektu, po zastosowaniu użytych w nim dyrektyw (#include, #if,
#endif, itp.).
#include
int num = 10;
int main(void)
{
cout << num << endl; // 10
{
cout << num << endl; // 10
int num = 20;
cout << num << endl; // 20
}
cout << num << endl; // 10
return 0;
}
int num2 = num;
Zasięg deklaracji pierwszego identyfikatora num obejmuje m.in. deklarację występującą po funkcji main.
Deklaracje i definicje
51
Jeśli deklaracja globalna zawiera specyfikator static, to jest widoczna tylko w jej module. Jeśli deklaracja
globalna jest definicją, ale nie zawiera specyfikatora static, to jest widoczna w tych obszarach pozostałych
modułów programu, w których jest widoczna zgodna z nią deklaracja ze specyfikatorem extern bez inicjatora,
nie dotycząca deklaracji globalnej ze specyfikatorem static.
Uwaga: Globalne zmienne ustalone są domyślnie wyposażone w specyfikator static. Specyfikator extern
występujący w deklaracji funkcji można pominąć.
plik Main.cpp
#include
int main(void)
{
int fun(void); // pominięto extern
cout << fun() << endl; // 10
extern int num;
cout << num << endl; // 20
return 0;
}
plik One.cpp
static int num = 10;
int fun(void)
{
extern int num; // zbędne
return num;
}
plik Two.cpp
int num = 20;
Deklaracje typów
Globalna deklaracja typu, na przykład
struct Child;
nie wystarczy do tego, aby można było nawiązać do definicji tego typu podanej w innym module.
W odróżnieniu od definicji zmiennej i funkcji, która w zbiorze modułów programu może wystąpić tylko jeden
raz, definicja struktury musi być powtórzona w każdym z odwołujących się do niej modułów.
plik Main.cpp
#include
struct Child {
char name[20];
int age;
};
int main(void)
{
Child getIsa(void);
Child isa = getIsa();
52
 cout << isa.name << " is " <<
isa.age << endl;
return 0;
}
plik Isa.cpp
struct Child {
char name[20];
int age;
};
Child isa = { "Isabel", 15 };
Child getIsa(void)
{
return isa;
}
albo lepiej i bezpieczniej
plik child.h
struct Child {
char name[20];
int age;
};
plik Main.cpp
#include
#include "child.h"
int main(void)
{
Child getIsa(void);
Child isa = getIsa();
cout << isa.name << " is " <<
isa.age << endl;
return 0;
}
plik Isa.cpp
#include "child.h"
Child isa = { "Isabel", 15 };
Child getIsa(void)
{
return isa;
}
53
Studia programowe
Przedstawiono dwa rozwiązania następującego problemu
Napisać program, który wprowadza z pliku sekwencję danych arytmetycznych, a następnie wyprowadza
ich średnie odchylenie standardowe: pierwiastek z sumy kwadratów różnic dana-średnia, podzielony
liczbę danych.
W szczególności, jeśli w pliku Data.txt umieści się liczby 6 9 12, a jako argument programu poda Data.txt
(polecenie Project / Settings // Debug), to nastąpi wyprowadzenie liczby 1.41421.
Struktura tablicowa
#include
#include
#include
int readData(char *fileName, double *&pData);
double getAverage(double *pData, int count);
double getResult(double *pData, int count, double average);
void freeMemory(double *pData);
int main(int noOfArgs, char *pArg[])
{
if(noOfArgs != 2) {
cout << "Usage is: " << pArg[0] <<
" fileName" << endl;
return -1;
}
double *pData;
char *fileName = pArg[1];
int count = readData(fileName, pData);
if(count) {
double average = getAverage(pData, count);
double result = getResult(pData, count, average);
cout << "Result = " << result << endl;
} else
cout << "Error!" << endl;
return 0;
}
int readData(char *fileName, double *&pData)
{
const int start = 200;
ifstream inp;
inp.open(fileName, ios::in | ios::nocreate);
int count = 0;
if(inp.is_open()) {
pData = new double [start];
int len = start;
double tmp;
while(tmp = 0, inp >> tmp, tmp) {
if(count == len) {
double *ptr = new double [len *= 2];
for(int j = 0; j < len /2 ; j++)
ptr[j] = pData[j];
delete [] pData;
pData = ptr;
}
pData[count++] = tmp;
}
}
return count;
}
54
double getAverage(double *pData, int count)
{
double sum = 0;
for(int i = 0; i < count ; i++)
sum += pData[i];
return sum / count;
}
double getResult(double *pData, int count, double average)
{
double sumSqr = 0;
for(int i = 0; i < count ; i++) {
double dif = pData[i] - average;
sumSqr += dif * dif;
}
return sqrt(sumSqr) / count;
}
void freeMemory(double *pData)
{
delete [] pData;
}
Struktura listowa
#include
#include
#include
struct Item {
Item *pNext;
double value;
};
struct List {
Item *pFirst;
int count;
};
List list = { 0 };
int readData(char *fileName, List &list);
double getAverage(List &list);
double getResult(List &list, double average);
void freeMemory(List &list);
int main(int noOfArgs, char *pArg[])
{
if(noOfArgs != 2) {
cout << "Usage is: " << pArg[0] <<
" fileName" << endl;
return -1;
}
char *fileName = pArg[1];
int count = readData(fileName, list);
if(count) {
double average = getAverage(list);
double result = getResult(list, average);
cout << "Result = " << result << endl;
} else
cout << "Error!" << endl;
freeMemory(list);
return 0;
}
int readData(char *fileName, List &list)
{
ifstream inp;
inp.open(fileName, ios::in | ios::nocreate);
55
 int count = 0;
if(inp.is_open()) {
double tmp;
while(tmp = 0, inp >> tmp, tmp) {
Item *pItem = new Item;
pItem->pNext = list.pFirst;
pItem->value = tmp;
list.pFirst = pItem;
count++;
}
}
return list.count = count;
}
double getAverage(List &list)
{
double sum = 0;
Item *pItem = list.pFirst;
while(pItem) {
sum += pItem->value;
pItem = pItem->pNext;
}
return sum / list.count;
}
double getResult(List &list, double average)
{
double sumSqr = 0;
Item *pItem = list.pFirst;
while(pItem) {
double dif = pItem->value - average;
sumSqr += dif * dif;
pItem = pItem->pNext;
}
return sqrt(sumSqr) / list.count;
}
void freeMemory(List &list)
{
Item *pItem = list.pFirst, *pTmp;
while(pItem) {
pTmp = pItem->pNext;
delete pItem;
pItem = pTmp;
}
}
56
Dodatek A
Priorytety operatorów
Operatory wyszczególniono w kolejnoS
ci malejącego priorytetu.
Wiązanie Operator
prawe ::
lewe Type::
lewe [] . -> () Type()
lewe ++ -- (następnikowe)
prawe ++ -- (poprzednikowe)
prawe sizeof + - ~ ! & * new delete (Type) throw
lewe .* ->*
lewe * / %
lewe + -
lewe << >>
lewe < <= > >=
lewe == !=
lewe &
lewe ^
lewe |
lewe &&
lewe ||
prawe ?:
prawe = *= /= %= += -= <<= >>= &= ^= |=
lewe ,
l-nazwą zmiennej (por. Dodatek B) jest tylko: operacja przypisania (np. a+=b), przedrostkowego zwiększenia
(np. ++a), przedrostkowego zmniejszenia (np. --a), indeksowania (np. ptr[i]), wyłuskania (np. *ptr), wyboru
(np. str.f i ptr->f), warunku którego dwa ostatnie argumenty są l-nazwami (np. a>0?a:b), konwersji do typu
odnośnikowego (np. (int &)a) oraz globalności (np. ::) i zakresu (np. Child::name).
57
Dodatek B
Opracowywanie wyrażeń
Wyrażenia są zapisami operacji. O kolejności wykonywania operacji decyduje sposób użycia nawiasów oraz
uwzględnienie priorytetów i wiązań operatorów (por. Dodatek A).
Jeśli kilka operatorów zapisano spójnie (tj. bez odstępów), wówczas za pierwszy uznaje się najdłuższy. A
zatem: ponieważ w C++ istnieją operatory + i ++, ale nie istnieje operator +++, więc wyrażenie
a +++ b
jest traktowane jak
(a++) + b // a nie jak: a + (++b)
Priorytety
Ponieważ w C++ priorytet mnożenia jest wyższy niż priorytet dodawania, więc wyrażenie
a + b * c
jest traktowane jak
a + (b * c) // a nie jak: (a + b) * c
Podobnie, ponieważ w C++ priorytet następnikowej operacji zwiększenia (++) jest wyższy niż priorytet operacji
wyłuskania (*), więc wyrażenie
*ptr++
jest traktowane jak
*(ptr++) // a nie jak: (*ptr)++
Wiązania
Ponieważ w C++ priorytet odejmowania (-) jest równy priorytetowi dodawania (+), więc jeśli pewnego
podwyrażenia dotyczą oba takie operatory, to odwołanie się do priorytetów nie wystarcza i trzeba odwołać się do
wiązań.
Ponieważ w C++ wiązanie operacji odejmowania i dodawania jest lewe, więc wyrażenia
a - b + c
cout << a << b
są traktowane jak
(a - b) + c // a nie jak a - (b + c)
58
 (cout << a) << b // a nie jak: cout << (a << b)
(środkowe podwyrażenia dowiązano do lewej).
Dla porównania, ponieważ wiązanie operacji przypisania jest prawe, więc wyrażenie
a = b = c
jest traktowane jak
a = ( b = c) // a nie jak: (a = b) = c
Kolejność
Kolejność opracowywania argumentów operacji jest nieokreślona. Dotyczy to zarówno argumentów wywołania
funkcji, jak i argumentów operacji dwuargumentowych, takich jak przypisanie.
Dlatego zaleca się, aby w wyrażeniu, w którym następuje zmiana wartości zmiennej, nie odwoływano się
(dodatkowo!) do tej zmiennej.
fun(cout << 100, cout << 200);
int tab[4] = { 10, 20, 30 },
pos = 1;
tab[pos] = ++pos;
Nie wiadomo, czy przed wykonaniem ciała funkcji fun zostanie wyprowadzona liczba 100 czy 200. W Visual
C++ zostanie wyprowadzona liczba 200.
Nie wiadomo, czy przypisanie dotyczy elementu tab[1] czy elementu tab[2]. W Visual C++ dotyczy ono tab[2].
Promocja
Niektóre operacje są wykonywane dopiero po promocji argumentu. Dotyczy to w szczególności zmiennych typu
char (poddawanych promocji do typu int).
char chr = 'a';
char &ref1 = chr;
char &ref2 = +chr; // błąd
char &ref3 = 'a'; // błąd
Typ wspólny
Jeśli argumenty operacji są różnych typów, to wykonuje się ją w ich typie wspólnym. W szczególności typem
wspólnym dla char i int jest int, a typem wspólnym dla double i int jest double.
Uwaga: Jeśli wyrażenie jest pewnego typu, to nie oznacza to, że wszystkie jego operacje wykonuje się w tym
typie.
#include
#include
int main(void)
{
int max = INT_MAX;
cout << max * max << endl; // 1 (sic!)
cout << 0.0 + max * max << endl; // 1 (sic!)
cout << double(max) * max << endl; // ok. 4.6e18
59
 return 0;
}
Mimo iż typem wyrażenia zawierającego liczbę 0.0 jest double, iloczyn max * max jest obliczany w typie int.
Punkty charakterystyczne
Punktem charakterystycznym jest miejsce w programie, w którym realizuje się wszystkie "zaległe" skutki
uboczne, takie jak operacje wejścia-wyjścia i przypisania.
Punkt charakterystyczny występuje m.in. po każdym kompletnym wyrażeniu, przed każdym średnikiem, przed
pierwszą instrukcją funkcji oraz przed operatorami koniunkcji i dysjunkcji.
Programy zależne od położenia punktu charakterystycznego należy konstruować ze szczególną ostrożnością.
int fix = 10;
++fix = fix;
cout << fix;
Ponieważ operacja zwiększenia (++) może być zrealizowana dopiero w punkcie charakterystycznym, więc nie
wiadomo, czy zostanie wyprowadzona liczba 10 czy 11. W Visual C++ zostanie wyprowadzona liczba 11.
Nazwy
Każde wyrażenie i podwyrażenie (w szczególności zapis operacji), można rozpatrywać jako nazwę pomocniczej
zmiennej tymczasowej. Podczas opracowywania wyrażenia, każdą z operacji zastępuje się nazwą jej rezultatu.
Uwaga: Pomocniczą zmienną tymczasową niszczy się bezpośrednio po opracowaniu kompletnego wyrażenia,
którego opracowania wymagało utworzenia tej zmiennej.
W szczególności, jeśli przyjąć, że zmiennymi tymczasowymi są t1, t2 i t3 to instrukcja
cout << 1 + 2 * 3;
jest wykonywana tak, jak
int t1, t2, t3;
t1 = 2 * 3, t2 = 1 + t1, cout << t2
a zmienne tymczasowe zostaną zniszczone w chwili, gdy sterowanie "przepłynie przez średnik".
l-nazwy
Przyjmuje się z definicji, że l-nazwą jest tylko: identyfikator zmiennej nie-ustalonej, rezultat funkcji o typie
odnośnikowym oraz rezultat operacji wymienionych w Dodatku A. Nie jest l-nazwą literał, ani wskaz
nik
powstały z niejawnego przekształcenia nazwy tablicy.
Posługując się taką definicją można podać następujące wymagania
1) Odnośnik do zmiennej nie-ustalonej może być zainicjowany tylko takim wyrażeniem, które jest l-nazwą
zmiennej.
np.
const int fix1 = 10;
int &fix2 = 20; // błąd
2) Argumentem operacji zwiększenia (++), zmniejszenia (--), wskazywania (&) i wyboru (. i ->) może być tylko
takie wyrażenie, które jest l-nazwą zmiennej.
60
np.
int fix = 10;
++(int)fix; // błąd
fix++++; // błąd
int *ptr = &20; // błąd
3) Lewym argumentem przypisania (=, += itp.) może być tylko takie wyrażenie, które jest l-nazwą zmiennej.
np.
int fix = 10;
fix++ = 20; // błąd
int tab[] = { 10 };
tab = 20; // błąd
Uwaga: Niepoprawność operacji fix++++ wynika stąd, że fix++ nie jest l-nazwą, a więc nie może być
argumentem ponownej operacji zwiększenia.
61
Dodatek C
Konwersje standardowe
Konwersją standardową, jest taka predefiniowana konwersja, która może być wstawiona do programu
niejawnie.
Konwersjami standardowymi są m.in.:
0) Przekształcenie promocyjne (np. zmiennej typu char w zmienna typu int).
1) Przekształcenie zmiennej arytmetycznej albo wskaz
nika w orzecznik (np. zmiennej typu int w zmienną typu
bool).
2) Przekształcenie zmiennej arytmetycznej w zmienną arytmetyczną innego typu (np. zmiennej typu double w
zmienną typu int).
3) Przekształcenie nazwy tablicy na wskaz
nik do jej zerowego elementu.
4) Przekształcenie nazwy zmiennej na odnośnik do tej zmiennej.
5) Przekształcenie wskaz
nika do obiektu na wskaz
nik do jego podobiektu.
6) Przekształcenie odnośnika do obiektu na odnośnik do jego podobiektu.
7) Przekształcenie wskaz
nika do zmiennej na wskaz
nik lokalizujący tę zmienną.
Nie są nimi m.in.
1) Przekształcenie wskaz
nika do elementu tablicy na wskaz
nik do tej tablicy.
2) Przekształcenie wskaz
nika do tablicy na wskaz
nik do jej elementu.
3) Przekształcenie wskaz
nika do podobiektu na wskaz
nik do jego obiektu.
4) Przekształcenie odnośnika do podobiektu na odnośnik do jego obiektu.
5) Przekształcenie wskaz
nika lokalizującego zmienną na wskaz
nik do tej zmiennej.
Uwaga: Poza konwersjami standardowymi, niejawne może być zastosowany jedynie konstruktor i konwerter.
62
Dodatek D
Operatory bitowe
Operatorami bitowymi są: ~ (zanegowanie bitów), & (iloczyn bitów), | (suma bitów), ^ (suma modulo 2 bitów),
<< (przesunięcie bitów w lewo), >> (przesunięcie bitów w prawo).
Podczas wykonywania operacji na bitach przydatne okazują się literały szesnastkowe. Literał szesnastkowy ma
postać 0xh, w której h jest spójnym ciągiem cyfr szesnastkowych (0-9 i a-f).
cout << 0x12; // 18
cout << 0xffff; // 65535
Operator ~
Operacja zanegowania bitów ma postać
~exp
w której exp jest wyrażeniem całkowitym.
Rezultatem operacji zanegowania bitów jest zmienna tymczasowa takiego samego typu jak zmienna exp, po
poddaniu jej promocjom, a następnie zanegowaniu każdego jej bitu.
Uwaga: Negacją bitu 1 jest bit 0, a negacją bitu 0 jest bit 1.
int red = 1, green = 2, blue = 4;
int hue = red | green; // ... 011 (kolor żółty)
hue = ~hue; // ... 100 (kolor niebieski)
Trzy najmniej znaczące bity zmiennej hue reprezentują jeden z 8 kolorów. Wykonanie operacji zanegowania
bitów powoduje zmianę koloru na dopełniający.
Operator &
Operacja iloczynu bitów ma postać
expL & expR
w której expL i expR są wyrażeniami całkowitymi.
W celu utworzenia wyniku operacji, zmienne expL i expR poddaje się konwersjom do typu wspólnego, a
następnie każdy bit wyniku tworzy się z odpowiadających sobie bitów argumentów wyznaczając ich iloczyn
logiczny.
Uwaga: Iloczyn logiczny pary bitów ma wartość 1 tylko wówczas gdy oba bity są jedynkowe.
int fix = 6; // 00 ... 110
const int mask = '\x3'; // 00 ... 011
fix &= ~mask;
cout << Fix; // 4 (00 ... 100)
63
Wykonanie operacji na zmiennej fix powoduje wyzerowanie tych wszystkich jej bitów, które w mask są
jedynkowe.
Operator ^
Operacja sumy modulo 2 bitów ma postać
expL ^ expR
w której expL i expR są wyrażeniami całkowitymi.
W celu utworzenia wyniku operacji, zmienne expL i expR poddaje się konwersjom do typu wspólnego, a
następnie każdy bit wyniku tworzy się z odpowiadających sobie bitów argumentów wyznaczając ich sumę
logiczną modulo 2.
Uwaga: Suma logiczna modulo 2 pary bitów ma wartość 1 tylko wówczas gdy bity są różne.
int fix = 6; // 00 ... 110
const int mask = '\x3'; // 00 ... 011
fix ^= mask;
cout << fix; // 5 (00 ... 101)
Wykonanie operacji na zmiennej fix powoduje zanegowanie tych wszystkich jej bitów, które w mask są
jedynkowe.
Operator |
Operacja sumy bitów ma postać
expL | expR
w której expL i expR są wyrażeniami całkowitymi.
W celu utworzenia wyniku operacji, zmienne expL i expR poddaje się konwersjom do typu wspólnego, a
następnie każdy bit wyniku tworzy się z odpowiadających sobie bitów argumentów wyznaczając ich sumę
logiczną.
Uwaga: Suma logiczna pary bitów ma wartość 0 tylko wówczas gdy oba bity są zerowe.
int fix = 5; // 00 ... 101
const int mask = '\x3'; // 00 ... 011
fix |= mask;
cout << Fix; // 7 (00 ... 111)
Wykonanie operacji na zmiennej fix powoduje ustawienie tych wszystkich jej bitów, które w mask są jedynkowe.
Operator <<
Operacja przesunięcia bitów w lewo ma postać
expL << n
w której expL i n są wyrażeniami całkowitymi.
W celu utworzenia wyniku operacji, zmienną expL poddaje się promocji, a następnie każdy bit wyniku tworzy
się z bitów tej nowej zmiennej po przesunięciu ich o n pozycji w lewo.
64
Uwaga: Podczas przesuwania w lewo bity najbardziej znaczące są odrzucane, a na pozycje najmniej znaczące
wchodzą bity 0.
int fix = 7; // 00 ... 0111
fix <<= 2;
cout << fix; // 28 (00 ... 011100)
Bity zmiennej fix przesunięto o 2 pozycje w lewo.
Operator >>
Operacja przesunięcia bitów w prawo ma postać
expL >> n
w której expL i n są wyrażeniami całkowitymi.
W celu utworzenia wyniku operacji, zmienną expL poddaje się promocji, a następnie każdy bit wyniku tworzy
się z bitów tej nowej zmiennej po przesunięciu ich o n pozycji w prawo.
Uwaga: Podczas przesuwania w prawo bity najmniej znaczące są odrzucane.
int fix = 15; // 00 ... 01111
fix >>= 2;
cout << fix; // 3 (00 ... 011)
Bity zmiennej fix przesunięto o 2 pozycje w prawo.
65
Dodatek E
Operacje wejścia-wyjścia
Większość operacji wejścia-wyjścia można wykonać za pomocą operatorów. Do specjalnych celów przydają się
niekiedy funkcje wejścia-wyjścia.
Funkcje get i put
inp.get(chr)
Wprowadza ze strumienia inp najbliższy znak (w tym znak odstępu) i jego kod przypisuje zmiennej chr typu
char. Dostarcza odnośnik do inp.
out.put(chr)
Wyprowadza do strumienia out znak o kodzie chr. Dostarcza odnośnik do out.
#include
#include
#include
int main(void)
{
ifstream inp;
inp.open("Data.txt", ios::in);
if(!inp.is_open())
return -1;
char chr;
while(inp.get(chr))
cout.put(chr);
return 0;
}
Program kopiuje na konsolę zawartość pliku Data.txt. Kopiowanie odbywa się znak-po-znaku.
Funkcje read i write
inp.read(ptr, len)
Wprowadza ze strumienia inp ciąg len najbliższych znaków i ich kody umieszcza w tablicy znakowej o
elemencie wskazywanym przez ptr. Dostarcza odnośnik do inp.
out.write(ptr, len)
Wyprowadza do strumienia out ciąg len znaków z tablicy znakowej, począwszy od elementu wskazywanego
przez ptr. Dostarcza odnośnik do out.
inp.gcount()
66
Dostarcza liczbę znaków wprowadzonych za pomocą ostatnio wywołanej funkcji read albo getline.
#include
#include
const int Size = 10;
int main(void)
{
ifstream inp;
inp.open("Data.txt", ios::in);
if(!inp.is_open())
return -1;
char buf[Size];
while(true) {
inp.read(buf, Size);
int len = inp.gcount();
if(len > 0)
cout.write(buf, len);
if(len < Size)
break;
}
return 0;
}
Program kopiuje na konsolę zawartość pliku Data.txt. Kopiowanie odbywa się porcjami po Size znaków.
Funkcja getline
inp.getline(ptr, len)
Wprowadza ze strumienia inp jeden wiersz, ale nie więcej niż len-1 najbliższych znaków, a ich kody, bez kodu
'\n', ale z dodatkowym kodem 0, umieszcza w tablicy znakowej o elemencie wskazywanym przez ptr. Dostarcza
odnośnik do inp.
#include
#include
const int Size = 100;
int main(void)
{
ifstream inp;
inp.open("Data.txt", ios::in);
if(!inp.is_open())
return -1;
char buf[Size];
while(inp) {
inp.getline(buf, Size);
int len = inp.gcount();
if(len > 0)
cout << buf << endl;
}
return 0;
}
Program kopiuje na konsolę zawartość pliku Data.txt. Kopiowanie odbywa się wierszami.
Funkcje peek i putback
inp.peek()
Dostarcza kod najbliższego znaku strumienia inp, ale znaku ze strumienia nie wprowadza (sic!).
67
inp.putback(chr)
Cofa do strumienia inp znak o kodzie chr. Dostarcza odnośnik do inp.
#include
#include
#include
const int Size = 100;
int main(void)
{
ifstream inp;
inp.open("Data.txt", ios::in);
if(!inp.is_open())
return -1;
while(inp) {
char chr;
inp >> chr;
inp.putback(chr);
if(chr == '-' || chr == '+' || isdigit(chr)) {
double num;
inp >> num;
cout << num << endl;
} else {
char buf[Size];
inp >> buf;
cout << buf << endl;
}
}
return 0;
}
Program wprowadza z pliku Data.txt zawarte w nim liczby i łańcuchy, a następnie wyprowadza je na konsolę,
każdy w osobnym wierszu.
Funkcje tellg i tellp
Funkcje tellg i tellp służą do określania pozycji pliku. Pozycja jest daną typu streampos. W Visual C++ typ
streampos jest identyczny z typem int.
inp.tellg()
Dostarcza bieżącą pozycję pliku otwartego w trybie ios::in.
inp.tellp()
Dostarcza bieżącą pozycję pliku otwartego w trybie ios::out.
#include
#include
int main(void)
{
ifstream inp;
inp.open("C:\\config.sys", ios::in);
if(!inp.is_open())
return -1;
char chr;
while(inp >> chr)
;
streampos pos = inp.tellg();
cout << "Size = " << pos << endl;
return 0;
}
68
Program wyznacza rozmiar pliku config.sys.
Funkcje seekg i seekp
Funkcje seekg i seekp służą do ustawiania pozycji pliku. Nowa pozycja pliku może być podana względem
początku pliku (ios::beg), względem pozycji bieżącej (ios::cur), albo względem pozycji końcowej (ios::end).
inp.seekg(pos) // inp.seekg(pos, ios::beg)
inp.seekg(pos, from)
Ustawia plik otwarty w trybie ios::in w pozycji pos, liczonej względem from (ios::beg, ios::cur, ios::end).
inp.seekp(pos) // inp.seekp(pos, ios::beg)
inp.seekp(pos, from)
Ustawia plik otwarty w trybie ios::out w pozycji pos, liczonej względem from (ios::beg, ios::cur, ios::end).
inp.seek(0);
Instrukcja ustawia strumień w pozycji początkowej.
Funkcja clear
Funkcja clear służy do ustawienia stanu strumienia.
str.clear()
str.clear(ios::badbit)
Wywołanie bezargumentowe ustawia strumień str w stan dobry. Wywołanie z argumentem ios::badbit ustawia
go w stan zły.
#include
#include
int main(void)
{
ifstream inp;
inp.open("C:\\autoexec.bat", ios::in);
if(!inp.is_open())
return -1;
char chr;
for(int i = 0; i < 3 ; i++) {
while(inp.get(chr))
cout << chr;
inp.clear();
inp.seekg(0);
}
return 0;
}
Program ma na celu 3-krotne wyprowadzenie na konsolę zawartości pliku autoexec.bat.
Ponieważ po zakończeniu instrukcji while strumień inp znajduje się w stanie nie-dobrym, więc należy ustawić go
w stan dobry. W przeciwnym razie wszystkie operacje wejścia-wyjścia dotyczące tego strumienia byłyby
pomijane, a zawartość pliku zostałaby wyprowadzona tylko 1 raz.
Operacje w pamięci
69
Operacje wejścia-wyjścia mogą dotyczyć nie tylko plików, ale również pamięci operacyjnej. Do wykonywania
operacji w pamięci służą obiekty klas istrstream i ostrstream, zadeklarowanych w pliku nagłówkowym
strstream.h.
Argumentem konstruktora klasy istrstream jest wskaz
nik łańcucha. Argumentami konstruktora klasy ostrstream
jest wskaz
nik elementu tablicy znakowej i maksymalna liczba jej elementów, które mogą być użyte w operacji
wyjścia.
Uwaga: Operacja wyjścia nie zapisuje znaku końca łańcucha. Należy to wykonać jawnie, na przykład za pomocą
symbolu ends.
#include
#include
int main(void)
{
char data[] = "10 20 30";
istrstream(data) >> a >> b >> c;
char buf[100];
ostrstream(buf, sizeof(buf)) << "Sum = " <<
a + b + c << ends;
cout << buf << endl;
return 0;
}
Przetwarzanie wyrywkowe
Wyrywkowo przetwarza się zazwyczaj pliki binarne. Plik binarny otwiera się w trybie
ios::in | ios::out | ios::binary
Operacje na pliku wykonuje się za pomocą funkcji read i write.
#include
#include
const char *const SrcName = "Data.txt";
const int Size = sizeof(int);
const char *const TrgName = "Random";
int main(void)
{
ifstream inp;
inp.open(SrcName, ios::in | ios::nocreate);
if(!inp.is_open()) {
cout << "Source failure" << endl;
return -1;
}
ofstream out;
out.open(TrgName, ios::out | ios::binary);
if(!out.is_open()) {
cout << "Target failure" << endl;
return -2;
}
// wprowadzanie
cout << endl << "reading ... " << endl;
int count = 0, tmp;
while(inp >> tmp) {
count++;
cout << tmp << endl;
out.write((char *)&tmp, Size);
70
 }
out.close();
inp.close();
if(count == 0) {
cout << "No data" << endl;
return -4;
}
// sprawdzanie
cout << endl << "checking ... " << endl;
inp.open(TrgName, ios::in | ios::binary | ios::nocreate);
if(!inp.is_open()) {
cout << "Check failure" << endl;
return -5;
}
while(inp.read((char *)&tmp, Size))
cout << tmp << endl;
inp.close();
// sortowanie
cout << endl << "sorting ... ";
fstream rio;
rio.open(TrgName, ios::in | ios::out | ios::binary);
if(!rio.is_open()) {
cout << "Sort failure" << endl;
return -6;
}
bool sorted = false;
while(!sorted) {
cout << endl;
sorted = true;
for(int i = 0; i < count-1 ; i++) {
rio.seekp(i * Size, ios::beg);
if(!rio)
goto Exit;
int num1, num2;
rio.read((char *)&num1, Size).
read((char *)&num2, Size);
cout << num1 << " " << num2 << endl;
if(num2 < num1) {
rio.seekp(-2 * Size, ios::cur);
rio.write((char *)&num2, Size).
write((char *)&num1, Size);
sorted = false;
}
}
}
Exit:;
if(!sorted) {
cout << "Seek error" << endl;
return -7;
}
// wyprowadzanie
cout << endl << "showing ... " << endl;
rio.seekp(0, ios::beg);
for(int i = 0; i < count ; i++) {
rio.read((char *)&tmp, Size);
cout << tmp << endl;
}
return 0;
}
Program tworzy plik binarny, do którego zapisuje dane pochodzące pliku Data.txt. Następnie dane sortuje i
wyprowadza.
Ponieważ funkcje read i write oczekują argumentów typu char * i int, wskazana zmiennych całkowitych
(np. &tmp) poddano jawnej konwersji do typu char *.
71