• Literały znakowym jest przeważnie pojedynczy znak ujęty w apostrofy, np. 'A', 'a'.
  Najczęściej wartością takiego literału jest kod ASCII danego znaku.
• Literały znakowe obejmują także znaki specjalne poprzedzone ukośnikiem: '\n' (znak nowej lini), '\t' znak tabulacji,
• Możemy też wprowadzić kod ósemkowy znaku poprzedzony ukośnikiem np. '\012' lub kod szesnastkowy znaku poprzedzony \x np. '\xA0.
• Aby pokazać, że dany literał jest typu wchar_t poprzedzamy go przedrostkiem L np. L'Ω'

Literały tekstowe są ciągiem znaków ujętych w cudzysłowy np. "To jest przykładowy tekst\n".

W programie napisanym w C/C++ mogą pojawić się zmienne o takich samych identyfikatorach. Jedynym ograniczeniem jest to, że dwie zmienne o takiej samej nazwie nie mogą być zadeklarowane w tym samym bloku.

Jeśli w bloku zadeklarowano zmienną o identyfikatorze, który był użyty dla innej zmiennej o ważności obejmującej ten blok, to mamy do czynienia z zasłanianiem nazwy zmiennej.

int j=10;
 
int main()
{
  ....
  int i;
  for(i=0;i<10;i++)
  {
    int j = 5; // zasłaniamy zmienną globalną j
 
    ....
 
    ::j = 13; // można użyć zasłoniętej zmiennej globalnej
              // przy pomocy operatora zakresu
  }
}

• W bloku pętli for zmienna lokalna j zasłania zmienną globalną o takim samym identyfikatorze
• Zmienna globalna jest mimo wszystko dostępna, przy pomocy tak zwanego operatora zakresu. Jest to znak podwójnego dwukropka.

Przykład - zasłanianie zmiennych globalnych

int main()
{
  ....
  int i, k=10;
  int* wsk = &k; 
  for(i=0;i<10;i++)
  {
    .... 
    int k = 5; // zasłaniamy zmienną lokalną k
 
    ....
 
    *wsk = 13; // zasłonięty obiekt jest dostępny 
               // przy pomocy wskaźnika lub referencji
  }
}

• W bloku pętli for zmienna lokalna k zasłania inną zmienną lokalną o takim samym identyfikatorze
• Zmienna lokalna nie jest dostępna przy pomocy swojego identyfikatora
• Obiekt zasłoniętej zmiennej lokalnej jest mimo wszystko dostępny, ale przy pomocy innych identyfikatorów. Mogą to być wskaźniki lub referencje.

Przykład - zasłanianie zmiennych lokalnych

• Modyfikator register informuje kompilator, że zależy nam na zapewnieniu możliwie szybkiego dostępu do zmiennej.
• Modyfikator ten można stosować tylko do zmiennych lokalnych i argumentów funkcji.
• W takim przypadku kompilator najczęściej stara się ulokować zmienną w rejestrze procesora.
• Nie ma gwarancji, że tak się stanie, jest to tylko nasze życzenie skierowane do kompilatora. W praktyce kompilator sam lepiej radzi sobie z optymalizacją kodu.

• Modyfikator volatile informuje kompilator, że zmienna może ulegać zmianom w sposób nieoczekiwany i niezależny od aktualnego procesu.
• Jest to możliwe w przypadkach obsługi przerwań, wieloprocesowości bądź wielowątkowości.
• Użycie volatile jest informacją dla kompilatora, że należy zachować ostrożność w przypadku optymalizacji kodu dotyczącego tej zmiennej.

W języku C/C++ słowo kluczowe void oznacza brak typu. Nie można deklarować zmiennych typu void.

Można natomiast deklarować wskaźniki typu void. O użyteczności wskaźników typu void przekonamy się w przyszłości, teraz podsumujemy ich własności.

• Każdy wskaźnik może być przypisany do wskaźnika void, na przykład

  int p;
  void* wsk = &p;
  int* q = &p;
  wsk = q;

• Nie jest dozwolona arytmetyka wskaźników void. Jest to uzasadnione, gdyż nie wiadomo jaki właściwie typ kryje się pod wskaźnikiem. Stąd nie wiadomo, czym miałoby być przesunięcie wskaźnika na następny obiekt.

Słowo kluczowe void jest również używane do deklaracji funkcji, które nie zwracają żadnej wartości. O tym powiemy już za chwilę.

Funkcja to podstawowy moduł programu w C/C++. Program główny to również funkcja o nazwie main. Funkcje mogą implementować algorytmy, realizować często powtarzające się zadania.

Nazwa funkcji musi być poprawnym identyfikatorem. Deklarując funkcję musimy podać, jakie są jej argumenty formalne, jaką ma nazwę oraz określić typ zwracanej wartości.

TypZwracany nazwaFunkcji(TypArgumentu1, ... ,TypArgumentuN);
 
//przykłady
void wypiszElementyTablicy(string t[], int ilosc);
double poleProstokata(double bokX, double bokY);

Powyżej zadeklarowaliśmy funkcję o nazwie poleProstokata. Funkcja ta ma dwa argumenty typu double i zwraca również obiekt typu double.

Deklaracja funkcji jest tylko pouczeniem dla kompilatora, że nazwa funkcji jest poprawna. Nie powoduje to wygenerowania żadnego kodu wynikowego. Deklarację funkcji można powtórzyć dowolną ilość razy i nie spowoduje to błędów kompilacji czy linkowania.

Definicja funkcji zawiera ciało funkcji, czyli jej kod.

TypZwracany nazwaFunkcji(TypArgumentu1, ... ,TypArgumentuN)
{
 // tutaj znajduje się kod funkcji
}
 
//przykład
double poleProstokata(double bokX, double bokY)
{
  return bokX * bokY;
}

Definiując funkcję podajemy jej sygnaturę (czyli typ zwracany, nazwę i argumenty). Kod funkcji podajemy w nawiasach wąsiastych. Lista argumentów może być pusta.

Do zwracania wartości przez funkcję służy słowo kluczowe return.

Przykład - funkcja licząca pole prostokąta.

Deklarując funkcję możemy pominąć nazwy argumentów pozostawiając jedynie typy argumentów.

double poleProstokata(double, double);

Argumenty umieszczone na liście w definicji funkcji to argumenty formalne. Kiedy wywołujemy funkcję w miejsce argumentów formalnych wstawiamy argumenty aktualne funkcji.

Mogą one być literałami (np. stałe wartości wprowadzone do kodu programu) lub zmiennymi, na przykład

double pole = poleProstokata(3,x);

• Argumenty formalne funkcji są traktowane jako zmienne lokalne wewnątrz bloku funkcji.
• W momencie wywoływania funkcji argumenty aktualne są kopiowane do argumentów formalnych.
• Mówimy wtedy o przesyłaniu argumentów do funkcji przez wartość.

Skoro argumenty aktualne są kopiowane, to oznacza, że funkcja pracuje na kopiach obiektów a nie na oryginalnych obiektach. Nie może więc zmodyfikować oryginalnych obiektów.

Przykład - argumenty przesyłane przez wartość.

Na liście argumentów formalnych funkcji mogą wystąpić zmienne wskaźnikowe. Tak jak każde zmienne są one przesyłane przez wartość.

void funkcja(int* argument);

Jeśli na liście argumentów formalnych funkcji znajduje się wskaźnik, to mówimy o przesyłaniu argumentu przez wskaźnik.

Przykład - argumenty przesyłane przez wskaźnik.

Na liście argumentów formalnych funkcji mogą wystąpić zmienne referencyjne. Pamiętajmy, że referencja to ukryty wskaźnik. Tak jak każde zmienne są one przesyłane przez wartość.

void funkcja(int& argument);

Jeśli na liście argumentów formalnych funkcji znajduje się referencja, to mówimy o przesyłaniu argumentu przez referencję.

Przesyłając argumenty przez referencję mamy możliwość modyfikacji oryginalnego obiektu, podobnie jak za pomocą wskaźnika. W przeciwieństwie do przesyłania argumentów przez wskaźnik nie musimy używać operatora wyłuskania.

Przykład - argumenty przesyłane przez referencję.

• Tablica, to stały wskaźnik - ustawiony na pierwszy element tablicy.
• W języku C/C++ nie da się przesłać do funkcji tablicy przez wartość - przesyłany jest zawsze wskaźnik

W poniższej deklaracji

void f(int t[5]);

do funkcji f zostanie przesłany adres początku pewnej tablicy. Sama funkcja nie wie, jakiej wielkości jest ta tablica, a podana wielkość nie ma znaczenia.

Mogłoby się wydawać, że funkcja powinna móc odczytać wielkość tablicy tylko na podstawie przesłanej tablicy. Pamiętajmy jednak o utożsamieniu tablic i wskaźników. Tak naprawdę funkcja może otrzymać jako argument tablicę, która jest fragmentem innej tablicy - jest to sytuacja bardzo typowa (np. przy sortowaniu)! Oczywiście rozmiar większej tablicy nie będzie poprawnym rozmiarem, który chcielibyśmy przesłać do takiej funkcji.

Przekazując tablicę do funkcji podajemy tylko jej nazwę.

void f(int t[]);
void f(int* t); // to samo co wyżej
 
int tablica[10];
f(tablica);

Przykład - przekazywanie tablicy do funkcji.

Argument formalny funkcji może być poprzedzony modyfikatorem const. Oznacza to, że po wywołaniu nie będzie można modyfikować takiego argumentu.

void f(const int& x, const int* y, const int z)
{
  x += 5;  // BŁĄD kompilacji, x jest stałą referencją
  *y += 5; // BŁĄD kompilacji, y jest wskaźnikiem do stałej
  z += 5;  // BŁĄD kompilacji, z jest stałą
  y += 5; // przesunięcie wskaźnika jest poprawne
}

Definiując funkcję należy zdecydować, w jaki sposób argumenty będą do niej przesyłane - przez wartość wskaźnik, czy referencję. Można stosować się do poniższych ogólnych zaleceń, ale są od nich liczne wyjątki

• obiekty typów wbudowanych zwykle przesyłamy przez wartość. Jest to o wiele szybsze niż dostęp za pomocą wskaźnika czy referencji
• obiekty typów wbudowanych przesyłamy przez referencję, jeśli chcemy modyfikować oryginalne obiekty
• tablice przesyłamy z użyciem wskaźnika do stałej (const T* tab), jeśli w funkcji nie modyfikujemy elementów tablicy
• obiekty typów zdefiniowanych przez użytkownika (na przykład obiekty klasy bibliotecznej string) zwykle przesyłamy przez referencję, aby uniknąć ich kopiowania. Jest to najczęstszy sposób używania referencji.
• obiekty typów zdefiniowanych przez użytkownika zwykle przesyłamy przez stałą referencję, jeśli tylko obiekt nie jest modyfikowany wewnątrz funkcji (jest tylko odczytu).

Przykład - modyfikator const w argumentach funkcji

Jeśli funkcja ma zwracaną wartość inną niż void to co najmniej raz w kodzie tej funkcji powinna wystąpić instrukcja return, za pomocą której zwracana jest wartość funkcji.

W takiej sytuacji po instrukcji return podajemy wyrażenie, które najpierw jest obliczane, a następnie staje się wartością zwracaną przez funkcję. Wyrażenie może być tylko stałą lub zmienną.

Instrukcja return powoduje zakończenie wykonywania funkcji i zwrócenie wartości. Może być ona użyta dowolną ilość razy w kodzie funkcji.

W funkcjach, które deklarują brak zwracanej wartości (void) użycie instrukcji return nie jest potrzebne, ale możliwe. Wtedy po instrukcji return następuje tylko średnik. W takich funkcjach używa się return do zakończenia wykonywania funkcji, na przykład wewnątrz bloku instrukcji if, czy z instrukcji pętli.

Przykład - wartość zwracana przez funkcję.

• Obiekty zwracane przez funkcje i operatory, to tak zwane obiekty chwilowe.
• Obiekt chwilowy, to obiekt do którego mamy dostęp tylko w chwili jego utworzenia.
• Praktycznie wszystkie obiekty chwilowe powstają jako obiekty zwracane przez funkcje lub operatory, choć czasami obiekty typów wbudowanych powstają przy użyciu literałów.
• Jedyne co możemy zrobić z obiektem chwilowym, to przekazać go jako argument do innej funkcji.
• Po wywołaniu funkcji obiekt chwilowy jest likwidowany
• Obiekty chwilowe tworzone są automatycznie przez kompilator przy składaniu funkcji i operatorów: obiekt zwrócony przez funkcję zostaje argumentem aktualnym innej funkcji.
• Nie możemy zachować obiektu chwilowego dłużej niż na czas wywołania funkcji do której został przekazany, jednak przekazując obiekt chwilowy do operatora podstawienia możemy zachować jego kopię.

Funkcja może również zwracać wskaźnik lub referencję. Wtedy taki wskaźnik albo referencja jest obiektem chwilowym, a nie sam obiekt, na który taki wskaźnik pokazuje.

 
int* f(){
  int* result;
  ......
  return result;
}
 
const int& h(int& x){
  ...
  return x;
}

Zwykle za pomocą wskaźnika lub referencji zwraca się jeden z otrzymanych argumentów, który może być użyty jako argument dla innej funkcji albo wskaźniki/referencje do obiektów utworzonych na stercie.

int& f()
{
  int k;
  ....
  return k; // BŁĄD! zwracamy referencję do zmiennej lokalnej
}

Przykład - zwracanie wartości przez wskaźnik.

Wewnątrz ciała funkcji może wystąpić instrukcja wywołania tej samej funkcji. Mówimy wtedy o wywołaniu rekurencyjnym funkcji, albo o rekursji.

int funckja(int x, int y)
{
  if(warunekKoncaRekursji)
  {
    return wartoscPoczatkowaRekursji;
  }
 
  // rób coś
  .... 
 
  // wywołaj rekurencyjnie
  funkcja(a,b);
 
  // dowolną ilość razy
  funkcja(c,d);
 
}

Aby nie doszło do zapętlenia programu, funkcja rekurencyjna musi zawierać wyrażenie warunkowe pozwalające na przerwanie rekurencyjnych wywołań.

Przykład - wyliczanie symbolu Newtona za pomocą rekursji.

Kompilator napotykając definicję funkcji zwykle generuje kod maszynowy tej funkcji. W czasie wykonywania programu kod ten jest ładowany do pamięci i umieszczany pod pewnym adresem.

Wywołanie funkcji powoduje skok do miejsca w pamięci, w którym jest umieszczona funkcja (wykonywanych jest jeszcze kilka innych czynności, które tutaj pomijamy).

Po zakończeniu wykonywania funkcji następuje powrót do miejsca, z którego nastąpiło wywołanie funkcji.

Przed nagłówkiem funkcji może pojawić się słowo kluczowe inline. Oznacza ono życzenie, aby kompilator zastąpił każde wywołanie funkcji jej ciałem. Powoduje to zniwelowanie całkiem sporego narzutu związanego z wywołaniem funkcji (skok, przekazywanie argumentów, itp.).

inline double Farenheit2Celsius(double f)
{
  return (f-32)/9*5;
}

• Takie funkcje nazywamy funkcjami inline
• Zadeklarowanie funkcji jako inline jest tylko sugestią dla kompilatora.
• Pożytek z deklarowania funkcji jako inline jest tylko w przypadku bardzo krótkich funkcji
• Funkcje inline są przykładem definicji odroczonych, dlatego najlepiej umieszczać je w plikach nagłówkowych

Jeśli w danym zakresie ważności mamy dwie lub więcej funkcji o takiej samej nazwie, to będziemy mówić o przeładowaniu nazw funkcji. Język C/C++ (i wiele innych języków) pozwala na definiowanie funkcji o takiej samej nazwie. Muszą się one różnić listą argumentów. Dozwolone jest przeładowanie, gdy

• jest inna ilość argumentów
• jest inna kolejność argumentów (nie są istotne nazwy argumentów formalnych, tylko ich typy!)

Nie można przeładować funkcji, jeśli różnią się tylko typem zwracanej wartości.

void sortuj(int t[], int rozmiarTablicy)
{
  ...
  // tutaj algorytm sortowania liczb całkowitych
}
 
void sortuj(string t[], int rozmiarTablicy)
{
  ...
  // tutaj algorytm sortowania napisów
}

Przykład - przeładowanie nazw funkcji

Powiedzieliśmy, że przeładowanie funkcji jest możliwe, jeśli lista argumentów różni się typami lub kolejnością argumentów. Tutaj musimy uściślić, że w czasie przeładowania nie rozróżnia się pewnych typów, które formalnie są inne. Dotyczy to:

• T* i T[]
• T, const T, volatile T

Oznacza to na przykład, że następujące przeładowania spowodują błąd kompilacji

void f(int* t);
void f(int z[]);
 
void g(int x);
void g(const int z);

Argumenty T i T& traktowane są jako tożsame tylko przez niektóre kompilatory. Jednak jeśli nawet uda się zdefiniować dwie funkcje różniące się tylko argumentem T i T&, to najczęściej przy próbie wysłania argumentu typu T do takiej funkcji kompilator sygnalizuje błąd niejednoznaczności.

Natomiast jako różne traktowane są dowolne dwa argumenty spośród następujących dwóch trójek

• T*, const T*, volatile T*
• T&, const T&, volatile T&

Jeśli mamy kilka funkcji przeładowanych, to kompilator może mieć problem z wyborem właściwej wersji. Postępuje one według reguł podanej poniżej i w takiej właśnie kolejności

1. ścisła zgodność typów lub dopasowanie na zasadzie utożsamiania typów (np. int, const int)
2. zgodność przy wykorzystaniu konwersji standardowych w zakresie typów całkowitych rozszerzających pojemność typu (np. int na long) oraz konwersja float na double
3. zgodność z wykorzystaniem pozostałych standardowych konwersji, (np. int na double, int* na void*)
4. zgodność przy wykorzystaniu konwersji zdefiniowanych przez użytkownika

Jeśli okaże się, że dwie lub więcej funkcji jest na tym samym poziomie zgodności, to sygnalizowany jest błąd niejednoznaczności (błąd kompilacji)

Przykład - niejednoznaczność przeładowania.

Deklarując funkcję, możemy przypisać argumentom na końcu listy ich wartości domyślne.

void wypisz(int t[], int dlugosc, char separator=',');
 
void wypisz(int t[], int dlugosc, char separator)
{
  ....
  // ciało funkcji
}

Jeśli definicja i deklaracja są rozdzielone, to wartości argumentów domniemanych mogą się pojawić tylko w deklaracji. W przeciwnym razie zostanie zgłoszony błąd kompilacji.

Jeśli deklaracja jest połączona z definicją, to argumenty domniemane mogą się pojawić również w definicji funkcji.

Efekt użycia argumentów domniemanych jest taki, jak zdefiniowanie przeładowanych funkcji z różną ilością argumentów. W przykładzie powyżej będą to

void wypisz(int t[], int dlugosc, char separator);
void wypisz(int t[], int dlugosc);

Definicje dla tych wersji kompilator uzupełni sam, na podstawie jednej podanej definicji i wartości domyślnych argumentów

Przykład - argumenty domniemane funkcji

Język C/C++ dopuszcza tworzenie funkcji o nieokreślonej liczbie argumentów. Wprawdzie w C++ potrzeba używania takich funkcji jest znacznie ograniczona poprzez możliwość przesyłania do funkcji obiektów strukturalnych, jednak w czystym C było to i jest nadal ważnym mechanizmem tworzenia elastycznych funkcji.

Funkcja o nieokreślonej liczbie argumentów może przyjmować pewną stałą listę argumentów. Te opcjonalne umieszczane są na końcu i oznaczamy wielokropkiem, na przykład

int funkcja(int a, float b, char* typ,...);

Taki zapis oznacza, że funkcja zawsze oczekuje co najmniej trzech argumentów, które są kolejno typów int, float, char*. Później może wystąpić cokolwiek.

Aby skorzystać z mechanizmu przesyłania nieokreślonej ilości argumentów do funkcji należy dołączyć plik nagłówkowy cstdarg lub stdarg.h. Później schemat postępowania jest następujący

• W pliku nagłówkowym cstdarg jest zdefiniowany typ va_list (nazwa pochodzi od variable-arguments list). Należy utworzyć zmienną tego typu. Załóżmy, że zmienna ta nazywa się ap (jest to tradycyjna nazwa takiej zmiennej, od argument pointer).

  va_list ap;

• Wywołujemy funkcję biblioteczną va_start podając jako jej pierwszy argument utworzoną wcześniej zmienną typu va_list, a jako drugi argument zmienną odpowiadającą ostatniemu parametrowi obowiązkowemu definiowanej funkcji. Po deklaracji z ostatniego przykładu wywołanie miałoby zatem postać

  va_start(ap,typ);

• Wartości kolejnych argumentów odczytujemy wywołując funkcję va_arg: pierwszym jej argumentem powinna być zmienna ap, a drugim nazwa typu wartości odpowiedniego tego argumentu funkcji który chcemy odczytać.

  double z = va_arg(ap,double);

  Wynika z tego, że te typy trzeba znać! Trzeba też wiedzieć, kiedy skończyć wczytywanie argumentów. Najczęściej informacja o ich liczbie i typie przekazywana jest w jakiejś formie w pierwszych, obowiązkowych, argumentach funkcji.
• Wywołujemy funkcję va_end ze zmienną ap jako jedynym argumentem. Funkcja ta porządkuje stos, tak, aby powrócił on do stanu sprzed wywołania.

Przykład - zmienna liczba argumentów.

• Standard C++ nie specyfikuje w jakiej kolejności są ewaluowane argumenty aktualne funkcji.
• Poleganie na tej kolejności może prowadzić do ciężkich do usunięcia błędów

 
 int licznik = 0;
 int f(){
   return ++licznik;
 }
 int h(int a, int b){
   cout << a << " " << b;
 }
 ...
 h(f(), f());

Po skompilowaniu funkcja jest umieszczona w pewnym miejscu w pamięci. Jej nazwa jest traktowana jako zmienna, która zawiera adres miejsca w pamięci, gdzie umieszczona jest ta funkcja.

Przykład - adres funkcji.

Utożsamienie funkcji i wskaźnika pozwala na deklarowanie wskaźników do funkcji, co często bywa użyteczne.

int (*f)(int, float);
int (*t[5])(int, float);
void g( int (*)(double) );

W powyższym przykładzie

• f jest wskaźnikiem do funkcji, która ma argumenty typu int, float i zwraca int
• t jest pięcioelementową tablicą wskaźników do funkcji, które mają argumenty typu int, float i zwracają int
• g jest funkcją, której argumentem jest wskaźnik do funkcji o jednym argumencie typu double i zwracającą int

W celu podniesienia czytelności kodu można umieścić nazwy parametrów (są one ignorowane)

int (*f)(int ile, float dlugosc);
int (*t[5])(int kierunek, float szybkosc);
void g( int (*wskf)(double x) );

Przykład - wskaźniki do funkcji

Deklaracje wskaźników do funkcji można jeszcze bardziej skomplikować - np. funkcja, której argumentem jest wskaźnik do funkcji i zwraca wskaźnik do funkcji. Stają się one bardzo nieczytelne. Z pomocą przychodzi nam słowo kluczowe typedef

typedef służy do wprowadzania innej nazwy na istniejący już typ. Nowa nazwa musi być poprawnym identyfikatorem.

typedef unsigned long long ullong;
 
ullong n=10;

W powyższym przykładzie zdefiniowaliśmy nowy typ o nazwie ullong. Od tej pory możemy używać tej nazwy na typ tak samo jak jej dłuższej wersji unsigned long long.

Analogicznie można zdefiniować typ wskaźnika do funkcji o określonej sygnaturze.

typedef bool (*WskaznikDoFuncji)(int,int);
 
void funkcja(WskaznikDoFunkcji f)
{
  ... 
  bool r = f(a,b);
}
 
WskaznikDoFunkcji g(WskaznikDoFunkcji f)
{
  ...
  bool r = f(a,b);
  return f;
}
 

• W powyższym przykładzie zdefiniowaliśmy nowy typ WskaznikDoFunkcji.
• Zdefiniowaliśmy funkcję funkcja, której argumentem jest adres jakiejś funkcji o sygnaturze zgodnej z typem WskaznikDoFunkcji
• Zdefiniowaliśmy funkcję g, której argumentem jest adres jakiejś funkcji o sygnaturze zgodnej z typem WskaznikDoFunkcji. Zwraca ona wskaźnik do funkcji.

Przykład - wskaźniki do funkcji i typedef.

Pisząc

enum DzienTygodnia{nie,pon,wto,sro,czw,pia,sob};

definiujemy własny typ, tak zwany typ wyliczeniowy. Oczywiście można teraz zadeklarować

DzienTygodnia dzienWyplaty=pia;

Kompilator kojarzy z elementami typu wyliczeniowego kolejne liczby całkowite, poczynając od zera, chyba, że explicite przy definicji typu konkretny element skojarzono z inną liczbą, tak jak w przykładzie

enum controlKeys{tab=8,enter=13};

• Z każdym typem wyliczeniowym skojarzony jest możliwie najmniejszy zakres sięgający od zera do potęgi dwójki zmniejszonej o jeden. W praktyce jednak może z tym być róznie np. w gcc typy wyliczeniowe są przeważnie przechowywane jako int-y.
• Jednakże do zmiennej typu wyliczeniowego nie da się podstawić bezpośrednio liczby całkowitej. Trzeba dokonać jawnej konwersji. Tak więc zapis

    dzienWyplaty=4; // brak konwersji

  powoduje błąd.
• Jednak można napisać

  dzienWyplaty=DzienTygodnia(7);

  choć w ten sposób nie przypisujemy żadnego dnia z listy, gdyż sobota to DzienTygodnia(6), a niedziela to DzienTygodnia(0). Dlatego dla bezpieczeństwa lepiej posługiwać się nazwami wartości.

Powróćmy do naszego przykładu z bazą danych pracowników firmy. Do przechowywania informacji o pracownikach użyliśmy trójwymiarowej tablicy

char osoby[30][2][32];

Rozwiązanie takie ma pewne wady

• łatwo się pogubić w indeksach - trzeba pamiętać, co oznaczają poszczególne numery w tablicy
• marnotrawstwo pamięci - na ogół imiona są znacznie krótsze niż nazwiska (mogą być podwójne). Deklaracja tablicy trójwymiarowej narzuca konieczność przydzielenia takiej samej maksymalnej długości napisów dla wszystkich elementów tablicy

Język C dostarcza słowa kluczowego struct. Służy ono do tworzenia nowych, zdefiniowanych przez programistę typów. Najprostsza składnia jest następująca:

struct [OpcjonalnaNazwaStruktury]
{
  // deklaracje zmiennych, z których składa się struktura
} [opcjonalnieListaDeklarowanychZmiennych];

Struktura opisująca pracownika może wyglądać tak:

struct Pracownik
{
  string imie;
  string nazwisko;
  string miejscowosc;
  string adres;
 
  string stanowisko;
  float pensjaPodstawowa;
};

W powyższym przykładzie:

• Zadeklarowaliśmy nową strukturę o nazwie Pracownik.
• Stworzyliśmy nowy typ o nazwie Pracownik. Od tej pory można definiować zmienne i tworzyć obiekty tego typu.
• Nie zadeklarowaliśmy żadnej zmiennej typu Pracownik - lista zmiennych pomiędzy kończącym nawiasem a średnikiem jest pusta. Jest to typowa sytuacja.
• Kompilator nie wygeneruje żadnego kodu tak długo, aż nie użyjemy tej struktury w programie. Jest to tylko pouczenie dla kompilatora, że powstał nowy typ i można go będzie używać.

Struktury tworzymy po to, by deklarować zmienne strukturalne. Deklaracja zmiennej odbywa się tak samo jak każdej innej - podajemy typ i nazwę zmiennej lub zmiennych.

Pracownik p;
Pracownik pracownicyFirmy[30];

• Pierwsza linia, to deklaracja jednej zmiennej typu Pracownik o nazwie p
• Druga linia to deklaracja 30-to elementowej tablicy, której elementami są struktury typu Pracownik
• Ilość pamięci, którą zajmuje cały obiekt opisywany przez strukturę można sprawdzić za pomocą operatora sizeof

cout << sizeof(Pracownik);

Przykład - struktura Pracownik

Deklarując zmienną strukturalną rezerwujemy pewien obszar pamięci o wielkości zależnej od tego, z czego składa się struktura. Pamięć ta jest podzielona na mniejsze fragmenty. Każdy z tych fragmentów ma rozmiar i odpowiadający wielkości pola składowego struktury. Pamięć ta jest interpretowana jako obiekt typu określonego w definicji struktury.

Do składowych struktury możemy się odwoływać za pomocą pól składowych struktury oraz notacji kropkowej.

Pracownik p;
p.pensja = 7654.99;

Przykład - dostęp do pól składowych struktury

Jeśli mamy dostęp do struktury za pomocą referencji, to dostęp do składowych struktury uzyskujemy za pomocą notacji kropkowej.

Pracownik& p = * (new Pracownik);
p.pensja = 6543.21;

W przypadku dostępu do obiektu strukturalnego za pomocą wskaźnika używamy notacji strzałkowej. Notacja ta odzwierciedla to, czym jest wskaźnik - zmienną pokazującą na inne obiekty.

Pracownik* p = new Pracownik;
p->pensja = 6543.21;

Można również najpierw użyć operatora wyłuskania, a później zwykłej notacji kropkowej.

Pracownik* p = new Pracownik;
(*p).pensja = 6543.21;

Przykład - dostęp do pól składowych struktury za pomocą wskaźników i referencji

Obiekty strukturalne są na ogół duże. Podczas przesyłania takich obiektów do funkcji jako argumentów zwykle wykorzystujemy przesyłanie przez referencję lub wskaźnik. Pozwala nam to uniknąć kopiowania dużych obiektów w czasie ich przesyłania do funkcji.

void wprowadz(Pracownik* p)
{
  ....
  cin >> p->imie;
  ....
}
 
void wypisz(const Pracownik & p)
{
  ....
  cout << p.imie;
  ....
}

Przykład - przesyłanie obiektów strukturalnych do funkcji.

Obiekty strukturalne mogą być również zwracane przez funkcje jako wartości. Podlegają one tym samym regułom jak zmienne typów wbudowanych. Tworzony jest obiekt chwilowy, który staje się wartością funkcji. Może on być użyty jako argument innej funkcji lub zapamiętany w zmiennej za pomocą operatora przypisania.

Pracownik funkcja()
{
  Pracownik p;
  .....
  return p;
}

• Obiekty zwracane w ten sposób są kopiowane!
• Należy być bardzo ostrożnym przy kopiowaniu obiektów strukturalnych zawierających składowe, które są wskaźnikami lub referencjami. Jak to należy poprawnie robić dowiedzą się Państwo na dalszych kursach (P1/P2). Na razie przyjmijmy, że funkcje nie zwracają przez wartość obiektów strukturalnych jeśli te zawierają pola wskaźnikowe lub referencyjne.
• Jeśli struktura ma składową, która jest tablicą statyczną (wielkość tablicy jest znana w czasie kompilacji), to jej (wygenerowane przez kompilator) kopiowanie wykona się poprawnie.

Nic nie stoi na przeszkodzie, aby wartością funkcji był wskaźnik lub referencja do obiektu strukturalnego.

Typową sytuacją jest zwracanie przez funkcję wskaźnika lub referencji do obiektu utworzonego na stercie.

Pracownik* utworz(  const char imie[], 
                    const char nazwisko[], 
                    float pensja
                  )
{
  Pracownik* p = new Pracownik;
  ....
  return p;
}

Przykład - wskaźniki do obiektów strukturalnych jako wartość funkcji

Poniżej przedstawiamy zalążek programu realizującego prostą bazę danych o pracownikach firmy

• Proszę zwrócić uwagę, że program nie dostarcza interfejsu użytkownika (czyli menu z pytaniami w stylu: 1. Dodaj osobę, 2. Usuń osobę, itp). Jest to typowy sposób programowania.
• Interfejs użytkownika powinien być niezależnym od danych kawałkiem kodu. Operacje na danych mogą być oprogramowane i przetestowane bez jakiejkolwiek interakcji z użytkownikiem - wystarczą proste testy jednostkowe, tak jak to pokazano w przykładzie.
• W bazie zdecydowaliśmy się przechowywać tablicę wskaźników a nie tablicę obiektów. Ma to ogromne zalety:
• przechowujemy w pamięci tylko tyle obiektów, ile faktycznie istnieje
• w przypadku usuwania elementów z tablicy nie musimy kopiować danych - wystarczy skopiowanie adresu co najwyżej jednego obiektu na wolne miejsce
• w przypadku potrzeby powiększenia tablicy wystarczy skopiować tablicę adresów do nowej powiększonej tablicy, a nie całą tablicę obiektów. Wprawdzie podany program nie oferuje takiej możliwości, ale łatwo można go zmodyfikować, aby taką funkcjonalność dostarczał
• Obiekty strukturalne są przesyłane do funkcji przez wskaźnik - unikamy kopiowania obiektów.

Przykład - mini baza danych - programowanie z użyciem struktur

Zadaniem preprocesora jest dokonanie pewnych wstępnych posunięć przed rozpoczęciem kompilacji oraz sterowanie przebiegiem samej kompilacji.

Dyrektywa preprocesora ma składnię

   #dyrektywa argumenty

• Dyrektywa nie kończy się średnikiem!
• Jeśli dyrektywa nie mieści się w jednej linii, można ją kontynuować w następnej, stawiając na końcu poprzedzającej linii ukośnik

• Rola preprocesora w samym programowaniu była większa w języku C.
• W języku C++ jego rola ogranicza się głównie do sterowania przebiegiem kompilacji

Dyrektywa makrodefinicji ma jedną z dwóch postaci

#define nazwa rozwinięcie
#define nazwa(argumenty_formalne) rozwinięcie

• Nazwa makrodefinicji może być dowolnym dopuszczalnym w C++ identyfikatorem
• Zwyczajowo nazwa makrodefinicji budowana jest z samych dużych liter
• Skutkiem użycia dyrektywy makrodefinicji jest zastąpienie każdego wystąpienia podanej nazwy stosownym rozwinięciem.
• Rozwinięcie może mieć dowolną postać.
• Jeśli użyto argumentów, to każde wystąpienie nazwy wraz z zamkniętą w nawiasy listą argumentów aktualnych zostaje zastąpione treścią rozwinięcia, w którym dodatkowo każde wystąpienie argumentu formalnego zostaje zastąpione odpowiednim argumentem aktualnym.
• Między nazwą a nawiasem ( nie może być spacji!

• Poprzedzenie argumentu makrodefinicji w jej rozwinięciu znakiem # powoduje zastąpienie argumentu literałem znakowym zawierającym argument aktualny.
• Na przykład

  #define WYPISZ(x) cout << #x << "=" << x << "\n";
  int i=7;
  WYPISZ(i)

  spowoduje wypisanie na standardowym wyjściu

  i=7

Przykład - zamiana argumentu na łańcuch

• Przy rozwijaniu makrodefinicji każde wystąpienie ## zamieniane jest na tekst pusty
• Pozwala to utworzyć nowy identyfikator przez dopisanie jakichś znaków alfanumerycznych przed i/lub po argumencie będącym identyfikatorem.
• Technika taka przydaje się do tworzenia skrótów przy wypisywaniu serii spokrewnionych deklaracji
• W przykładzie

  #define TEKST(a) char* a##_wskaznik; int a##_dlugosc;
  TEKST(alfa);
  TEKST(beta);
  TEKST(gamma);

  makrodefinicja TEKST(alfa) deklaruje spokrewnioną parę zmiennych:

  char* alfa_wskaznik;
  int alfa_dlugosc;

Uwaga: preprocesor nie sprawdza sensowności argumentów, więc na przykład TEKST("alfa") wygeneruje linię

char* "alfa"_wskaznik; int "alfa"_dlugosc;

na której wywróci się dopiero sam kompilator.

Przykład - sklejanie identyfikatorów

W języku C makrodefinicje miały duże zastosowanie ze względu na brak technik programowania za pomocą szablonów. Obecnie makrodefinicje stosuje się głownie do

• definiowania pustych nazw wykorzystywanych do sterowania pracą kompilatora

#define INTEL

• definiowania stałych (w C++ niewskazane)

  #define pi 3.14

• unikania konieczności przepisywania jednakowo działających funkcji różniących się jedynie typem argumentów (w C++ niewskazane)

  #define max(a,b) ( a>b ? a : b)
  ....
  i=max(i,2);
  x=max(x,3.14);

Dyrektywa kompilacji warunkowej ma postać

#if warunek
   // linie kompilowane warunkowo
#endif

• Warunek musi mieć postać, która gwarantuje, że jego rozstrzygnięcie jest możliwe już na etapie kompilacji.
• Jeśli warunek jest spełniony, linie zawarte między dyrektywami #if i #endif są kompilowane, a w przeciwnym razie są pomijane

Dyrektywa ta może wystąpić również w wersji

#if warunek
   // linie kompilowane gdy warunek zachodzi
#else
   // linie kompilowane gdy warunek nie zachodzi
#endif

Typowym zastosowaniem jest kompilacja zależna od procesora, systemu operacyjnego lub interfejsu użytkownika.

#if GUI == 1
   #include <windows.h>
   ....
#else
   ....
#endif

Przykład - kompilacja warunkowa

W warunku dyrektywy #if można wykorzystać systemową makrodefinicję

defined(nazwa)

sprawdzającą czy podana nazwa została zdefiniowana

Czasami zdarza się, że pewna nazwa zdefiniowana w jakiejś bibliotece koliduje z naszym planem użycia tej nazwy. Wtedy może przydać się dyrektywa

#undef nazwa

która powoduje wymazanie z pamięci kompilatora wcześniej wyuczonej nazwy.

Dyrektywa włączenia pliku pozwala na włączenie do kompilowanego pliku dokładnie w miejscu wystąpienia tej dyrektywy zawartości innego pliku.

Dyrektywa włączenia pliku ma jedną z dwóch postaci

#include <nazwa_pliku>
#include "nazwa_pliku"

• Pierwsza postać stosowana jest do włączania plików bibliotecznych dostarczanych wraz z kompilatorem
• Druga postać stosowana jest do włączania pozostałych plików

Formalna różnica pomiędzy tymi formami sprowadza się do ustalenia kolejności w jakiej są przeszukiwane katalogi i zależy od kompilatora.

• Przy skomplikowanym układzie zależności pomiędzy włączanymi plikami może dojść do sytuacji, że jeden plik jest włączany więcej niż jeden raz w trakcie jednej kompilacji.
• Niepotrzebnie obciąża to kompilator, a czasami może prowadzić do błędów.
• By tego uniknąć powszechnie stosuje się następujące rozwiązanie, w którym treść pliku zostaje obłożona dyrektywą warunkowej kompilacji

#ifndef JEDNOZNACZNY_OPIS_PLIKU
#define JEDNOZNACZNY_OPIS_PLIKU
   // zawartość pliku
#endif

W trakcie pracy preprocesora dostępne są następujące nazwy, których rozwinięcie definiuje sam preprocesor.

• __LINE__ - określa numer linii, nad którą preprocesor w danym momencie pracuje
• __FILE__ - nazwa aktualnie kompilowanego pliku
• __DATE__ - data kompilacji
• __TIME__ - czas kompilacji

Przykład - użycie nazw predefiniowanych

Jako przykład funkcji o nieokreślonej licznie argumentów przedstawimy funkcje biblioteczne printf, scanf. Funkcje te realizują niskopoziomowe (a więc szybkie) operacje wejścia-wyjścia. Są ona dostępne po włączeniu pliku nagłówkowego cstdio.

Pierwszym argumentem printf jest napis, który może zawierać znaki sterujące, określające sposób interpretowania argumentów z listy argumentów o zmiennej długości. Najprościej zilustrować to na przykładzie

char towar[] = "chleb";
int ilosc=30;
float cena=2.99;
printf("Towar %s, ilosc %d, cena %f",towar,ilosc, cena);

Funkcja printf wypisuje na standardowe wyjście podany napis jednocześnie analizując jego zawartość. Znaki rozpoczynającej się od % to znaki specjalne. Każde wystąpienie takiego znaku będzie zastąpione kolejnym argumentem z listy podanym w czasie wywołania. Sposób interpretacji określają kody (litery): %s dla napisu, %d dla liczby całkowitej, %f dla liczby zmiennoprzecinkowej.

Szczegółowa dokumentacja funkcji jest bardzo długa - można ją znaleźć na przykład tutaj.

Funkcja scanf to funkcja realizująca niskopoziomowe czytanie. Jej format odpowiada funkcji printf - pierwszym argumentem jest napis, w którym kodujemy co chcemy przeczytać, kolejne argumenty to adresy obiektu, w których zostaną umieszczone przeczytane dane.

int i;
float liczba;
char bufor[100];
scanf("%d%f%s",&i,&liczba,bufor);

Przykład - funkcje wejścia-wyjścia

Pierwszym argumentem funkcji printf i scanf jest tekst, który decyduje o sposobie w jaki będą wypisywane kolejne argumenty. Może on zawierać znaczniki formatujące postaci

%[flagi][szerokosc][.precyzja][modyfikator]typ

Flagi

• Jeżeli szerokosc została podana to dany argument zostanie wypisany przynajmiej na tylu znakach (dodatkowe znaki będą spacjami lub zerami). Wyjście nie zostanie jednak obcięte.
• precyzja dla liczb zmiennoprzecinkowych określa liczbę cyfr po przecinku, które zostaną wypisane, dla liczb całkowitych określa minimalną liczbę cyfr, dla łańcuchów znakowych jest to maksymalna liczba znaków które zostaną wypisane.
• Jeżeli zamiast liczby w miejsce szerokosci lub precyzji wpiszemy * to odpowiednia wartość powinna zostać podana na liście argumentów przed formatowanym argumentem,
• modyfikator zmienia znaczenie znacznika typ. Modyfikator h zmiejsza zakres typu, modyfikatory l,L zwiększają zakres typu. np. %hd oznacza short int, %ld - long int, %lf double, %Lf long double

Przykład - Formatowanie wyjścia

Funkcje do operacji na plikach znajdziemy w pliku nagłówkowym cstdio.

Typowy sposób pracy z plikiem, to:

• Otwarcie pliku
• Zapis/Odczyt danych
• Zamknięcie pliku

Do otwierania i zamykania plików służą funkcje

FILE * fopen ( const char * filename, const char * mode );
int fclose ( FILE * stream );

Jak widać funkcja otwierająca plik ma dwa argumenty

• filename - to nazwa otwieranego pliku
• mode - to parametry określające tryb otwarcia pliku. Jest to napis zawierający ciąg liter, które mają następujące znaczenie
• r - otwórz plik tylko do czytania
• w - otwórz plik tylko do zapisywania
• a - otwarcie pliku w trybie dopisywania na koniec zawartości
• r+ - otwarcie istniejącego pliku w trybie odczytu i zapisu
• w+ - otwarcie pliku w trybie odczytu i zapisu do nadpisywania. Jeśli plik wcześniej istniał, to jego zawartość zostanie usunięta.
• a+ - otwarcie do dopisywania i czytania. Otwarcie (lub stworzenie jeśli nie istnieje) do poprawiania na końcu pliku.
Dodatkowo do trybu można dopisać na koniec jedną z liter
• t - plik zostanie otwarty w trybie tekstowym
• b - plik zostanie otwarty w trybie binarnym
Jeśli ani t ani b nie zostało podane plik otwierany jest w zależności od wartości zmiennej _fmode - default'owo ustawiona jest ona na O_TEXT, ale można ją ustawić na O_BINARY.

Funkcja fopen zwraca wskaźnik do struktury FILE opisującej plik lub wskaźnik NULL, jeśli nie udało się utworzyć pliku. Typowe otwarcie pliku może wyglądać tak:

FILE* file=fopen("plikTekstowy.txt","w+t");
if(file==NULL)
{
  printf("Nie moge otworzyc pliku!");
} else {
 .... // operacje na pliku
  fclose(file);
}

Uchwyt (wskaźnik) pliku jest argumentem funkcji fclose, którą należy wywołać po zakończeniu operacji na pliku.

Plik tekstowy, to plik który zawiera dane przetłumaczone na format czytelny dla człowieka. Tekst może być formatowany w linie i akapity (tak jak w edytorze tekstowym), liczby są zamieniane na napisy (pamiętajmy, że w pamięci komputera liczby są przechowywane w postaci binarnej) i drukowane do pliku. Odczyt takiej liczby wymaga analizy napisu zawartego w pliku i zamiany go na liczbę. Operacje na plikach tekstowych są wolne, ale ich zawartość jest "czytelna".

Zapis do pliku można realizować przy pomocy funkcji

int fprintf ( FILE * stream, const char * str, ... );

Jej składnia jest prawie taka sama jak omówionej wcześniej funkcji printf. Różnią się tym, że funkcja fprintf ma dodatkowy argument - uchwyt pliku, do którego chcemy zapisywać. Poza tym sposób zapisu do liku jest taki jak na ekran.

Odpowiednikiem funkcji scanf dla plików jest fscanf

int fscanf ( FILE * stream, const char * str, ... );

Przykład - zapis i odczyt pliku w trybie tekstowym

Wyjście nieformatowane jest dużo szybsze gdyż podany łańcuch tekstowy nie jest interpretowany. Odpowiedni łańcuch tekstowy powinien przygotować programista samodzielnie np. dokonując odpowiednich konwersji.

Zapis do pliku odpowiednio znaku lub łańcucha tekstowego realizujemy przez

int fputc (char c, FILE * stream);
int fputs (const char * str, FILE * stream);

Odpowiedni aby przeczytać jeden znak lub łańcuch tekstowy możemy użyć funkcji

int fgetc (char c, FILE * stream);
int fgets (const char * str, int num, FILE * stream);

Druga z funkcji czyta num-1 znaków z strumienia stream chyba, że wcześniej napotka znak końca lini lub końca pliku.

Pliki binarne zawierają dane w takiej postaci, w jakiej są przechowywane w pamięci komputera. Jest to po prostu zrzut fragmentu pamięci komputera. Zawartość pliku na ogół jest nieczytelna dla człowieka - widzimy zwykłe "krzaki".

Operacje na plikach binarnych są szybkie gdyż nie musimy konwertować danych z tekstu na ich właściwy format. Jeśli tylko człowiek nie musi czytać i rozumieć zawartości pliku, to preferowane jest zapisywanie w formacie binarnym. Dane w pliku binarnym traktowane są jak ciąg bajtów.

Biblioteka C/C++ dostarcza funkcji odczytywania i zapisywania zbioru bajtów. Są to

size_t fread ( void * ptr, 
                size_t size, 
                size_t count, 
                FILE * stream 
              );
 
size_t fwrite ( const void * ptr, 
                size_t size, 
                size_t count, 
                FILE * stream 
              );

Argumenty w tych funkcjach oznaczają:

Przykład - zapis i odczyt w trybie binarnym

Istnieje cały szereg innych funkcji do operacji na plikach binarnych, w tym funkcji wyszukujących, przesuwających wskaźnik pliku, itd. Listę tych funkcji i ich opisy można znaleźć w sieci, na przykład tutaj.

Czytając lub zapisując do pliku automatycznie przesuwamy wskaźnik aktualnej pozycji w pliku. Ale możemy ten wskaźnik także przesuwać "ręcznie".

Aktualną pozycję w pliku możemy odczytać korzystając z funkcji

long int ftell ( FILE * stream );
int fgetpos ( FILE * stream, fpos_t * position );

Aby sprawdzić czy osiągnięty został koniec pliku możemy użyć funkcji

int feof(FILE * stream);

Jeżeli osiągnieto koniec pliku to kolejne operacje na pliku nie będą miały efektu chyba, że użyjemy jedna z funkcji

void rewind( FILE * stream );
int fseek ( FILE * stream, long int offset, int origin );
int fsetpos ( FILE * stream, const fpos_t * pos );

• Funkcja rewind przesuwa wskaźnik pliku na jego początek.
• Funkcja fseek przesuwa wskaźnik na pozycję daną przez offset licząc od
  • początku pliku jeżeli origin==SEEK_SET
  • końca pliku jeżeli origin==SEEK_END
  • bieżącej pozycji jeżeli origin==SEEK_CUR

Do tej pory używaliśmy pliku nagłówkowego iostream i strumieni cin, cout do realizacji czytania z klawiatury i wypisywania na ekran. Podamy teraz nieco więcej szczegółów dotyczących realizacji tych operacji.

W C++ operacje wejścia-wyjścia są realizowane za pomocą strumieni. Strumień możemy sobie wyobrażać jako strumień danych (bajtów) płynący od źródła do ujścia. Źródłem może być klawiatura, plik, pamięć, modem, potok nazwany, gniazda, skaner, .... Ujściem może być ekran, drukarka, plik, pamięć, ....

W bibliotece są zdefiniowane dwa podstawowe rodzaje strumieni

• input stream - strumienie odpowiadające za czytanie danych, używane gdy nasz program chce mieć dostęp do ujścia strumienia danych
• output stream - strumienie odpowiadające za wysyłanie danych, używane gdy nasz program chce być źródłem dla strumienia danych

Wśród tych dwóch kategorii biblioteka standardowa dostarcza klas realizujących szczególne rodzaje operacji wejścia-wyjścia

• istream - ogólna nazwa na wszystkie strumienie wejściowe (dla zaawansowanych - jest to klasa bazowa dziedziczona w pozostałych strumieniach). Szczególnym rodzajem są
  • istringstream - strumień wejściowy, gdzie źródłem danych jest pamięć. Dostępny po włączeniu pliku nagłówkowego sstream
  • ifstream - strumień wejściowy, gdzie źródłem danych jest plik. Dostępny po włączeniu pliku nagłówkowego fstream
• ostream - ogólna nazwa na wszystkie strumienie wyjściowe. Szczególnym rodzajem są
  • ostringstream - strumień wyjściowy, gdzie ujściem danych jest pamięć. Dostępny po włączeniu pliku nagłówkowego sstream
  • ofstream - strumień wyjściowy, gdzie źródłem danych jest plik. Dostępny po włączeniu pliku nagłówkowego fstream

Po dołączeniu któregoś z plików nagłówkowych iostream, sstream, fstream mamy do dyspozycji predefiniowane cztery strumienie

• cin - strumień typu istream, powiązany ze standardowym wejściem (stdin), zwykle jest to klawiatura
• cout - strumień typu ostream, powiązany ze standardowym wyjściem, zwykle jest to ekran. Strumień ten jest buforowany, co oznacza, że dane pojawiają się na ekranie z pewnym opóźnieniem.
• cerr - strumień typu ostream, powiązany ze standardowym strumieniem komunikacji o błędach (stderr), zwykle jest to ekran. Strumień ten nie jest buforowany.
• clog - strumień typu ostream, powiązany ze standardowym strumieniem komunikatów, raczej rzadko używany. Jest buforowany.

cout << "Napis";

operator<< (cout, "Napis");

Pozwala to na rozszerzenie funkcjonalności także na nasze własne typy. Wystarczy dla naszego typu np. Towar przeładować funkcję

std::ostream & operator<< (std::ostream & strumien, const Towar & t);

Potem możemy wypisywać nasz typ dokładnie tak samo jak typy wbudowane

Towar kielbasa;
cout << kielbasa << endl;

Przykład - wypisywanie własnych typów

Dla każdego ze strumieni możemy ustawić flagi, które będą decydują o sposobie działania strumienia np. w jaki sposób dane są formatowane przy wypisywaniu na ekran.

Flagi zdefiniowane w klasie bazowej std::ios

-7
     -7
-     7

Stan flag strumienia możemy zmienić używając metod setf oraz unsetf

cout.setf(ios::showpoint);
cin.unsetf(ios::skipws);

Dla flag występujących w grupie możemy użyć metody setf(flaga, grupa), która nie tylko ustawi daną flagę ale także wyzeruje pozostałe flagi w danej grupie.

cout.setf(ios::hex, ios::basefield);

Aby określić minimalną szerokość na jakiej należy wypisać daną liczbę czy tekst możemy użyć metody width. Przydaje się ona np. do tworzenia tabelek. Ustawiona przez nią szerokość odnosi się tylko do pierwszej następującej po niej operacji wypisywania.

cout.width(20);
cout << 7.12 << endl;

char nazwa[20];
cin.setw(20);
cin >> nazwa;

Metoda precision określa precyzję wypisywania liczb zmiennopozycyjnych. Precyzja ta jest obowiązujaca dla danego strumienia aż do ponownego wywołania metody precision

float x = 0.123456789,  y = 2;
cout << x << "  " << y << endl;       // 0.123456 2 
 
cout.precision(8);
cout << x << "  " << y << endl;       // 0.12345678 2 
 
cout.setf(ios::showpoint);
cout << x << "  " << y << endl;       // 0.12345678 2.00000000 

Dużo wygodniejszym sposobem zmiany formatowania jest wykorzystanie tzw. manipulatorów. Większość z nich jest zdefiniowanych w pliku nagłówkowym iomanip.
Zamiast pisać

cout.setf(ios::showpoint|ios:fixed);
cout.precision(10);
cout.width(20);
cout << 124.43225425 << endl; 

możemy napisać

cout << showpoint << fixed << setprecision(10) << setw(20); 
cout << 124.43225425 << endl; 

-7
     -7
-     7

Biblioteka języka C++ dostarcza operacji strumieniowych na plikach (tak tekstowych jak i binarnych) za pomocą strumieni. Aby skorzystać z tych klas należy dołączyć plik nagłówkowy fstream.

ifstream plikDoOdczytu;
plikDoOdczytu.open("nazwaPliku.txt");
plik >> zmienna;
plikDoOdczytu.close();

Jak widać w powyższym przykładzie operacje na plikach tekstowych traktowanych jako strumienie wygląda tak samo jak korzystanie ze strumieni cin, cout. Przy otwieraniu pliku możemy posłużyć się manipulatorami do ustalenia trybu otwarcia pliku. Tryby te można ze sobą łączyć za pomocą alternatywy bitowej. Na przykład

ofstream myFile;
myFile.open("f.bin",ios::app | ios::binary);
myFile.write(dane,rozmiar);
myFile.close();

W powyższym przykładzie manipulator ios::app oznacza, że plik jest otwarty do dopisywania (append), ios::binary oznacza otwarcie pliku w trybie binarnym.

Przykład - odczyt plików za pomocą strumieni