Opracowanie na Szeląga

1 struktura programu w języku c++

-- #include <iostream> dyrektywy preprocesora

--- funkcje zdefiniowane przez użytkownika

---

int main() // główna funkcja programu

{
  return 0;
}

2 Instrukcje Warunkowe

warunkowa if: if (wyrażenie instrukcja_1;

else instrukcja_2;

instrukcja może być blokiem (w nawiasach klamrowych {})

zagnieżdżona: if (warunek_1) instr_1;

else if (warunek_2) instr_2;

else if …;

3. Instrukcja While do While For Switch

Instrukcja while:

while (wyrażenie) instrukcja;

Instrukcja do while:

do instrukcja while (wyrażenie);

najpierw wykonana jest instrukcja, a później sprawdzone jest wyrażenie.

Instrukcja for:

for (ini; wyraz_warunkowe; krok) treść_pętli;

ini - jest to instrukcja inicjalizująca wykonywanie pętli for;

wyraz_warunkowe - jest to wyrażenie obliczane przed każdym obiegiem pętli. Jeśli jest ono różne od zera, to wykonywane zostaną instrukcje będące treścią pętli;

krok - jest to instrukcja wykonywana na zakończenie każdego obiegu pętli. Jest to ostatnia instrukcja wykonywana bezpośredni przed obliczeniem wartośći wyraz_warunkowe.

Instrukcja switch:

switch (wyrażenie)

{

case wart_1: {instr_1; break;}

case wart_1: {instr_2; break;}

case wart_1: {instr_3; break;}

…

case wart_n: {instr_n; break;}

default: {instr_(n+1); break;}

}

Instrukcja break:

może być używana również w instrukcjach pętli for, while, do … while;

instrukcja break powoduje natychmiastowe przerwanie wykonywania tych pętli;

Przykłady zastosowania instrukcji break:

4 Co pojawi się na ekranie

5 Wyjaśnij pojęcie Typedef Ennum i podaj przykład

Typ wyliczeniowy enum

Wyliczenie deklaruje się słowem kluczowym enum, po którym podaje się identyfikator oraz wykaz stałych oddzielonych przecinkiem i zamkniętych w nawiasy klamrowe.

Wymienionym stałym są przypisywane wartości domyślne: pierwszej z nich - wartość 0, a każdej następnej - wartość o 1 większą od poprzedzającej.

Stałym typu wyliczeniowego można również przypisywać wartości jawnie, przy czym wartości te mogą się powtarzać:

enum identyfikator {pn=1, wt=2, sr=3, …, nd=0};

Typ wyliczeniowy jest podobny do typów char oraz int. Nie można jednakże na jego wartościach wykonywać żadnych operacji arytmetycznych.

Gdy wartość typu wyliczeniowego pojawia się w wyrażeniach arytmetycznych, to ma miejsce niejawnie przekształcana do typu int przed wykonaniem operacji.

Typedef
Instrukcja typedef pozwala na nadanie dodatkowej nazwy już itniejącemu typowi

Typedef int cena;

Cena x; /// co odpowiada int x;

Cena a,b,c ///co odpowiada int a,b,c

Wniosek

Instrukcja typedef nie wprowadza nowego typu. Umożliwia tworzenie jedynie synonimu do typu już istniejącego

6. Operatory arytmetyczne, relacji , bierne

Operatory arytmetyczne:

+ dodawanie

- odejmowanie

* mnożenie

/ dzielenie

% reszta z dzielenia (modulo)

25 / 7 -> 3

25 / 7. -> 3.571428

35. / 5 -> 7.0

1 / 4 -> 0

19%6 -> 1

0 % 5 -> 0

18 % 6 -> 0

Operatory relacji:

< mniejszy

<= mniejszy lub równy

> większy

>= większy lub równy

== równy

!= nierówny

Wszystkie operatory relacji mają wartość dwuargumentową: jeśli są prawdą, mają wartość 1, przeciwnie wartość 0.

Operatory logiczne:

! negacja

&& koniunkcja (iloczyn logiczny)

|| alternatywa (suma logiczna)

Operatory bitowe:

& bitowa koniunkcja

| bitowa alternatywa

^ bitowa różnica symetryczna

<< przesunięcie w lewo

>> przesunięcie w prawo

~ bitowa negacja

Inkrementacja: zwiększanie o 1;

Dekrementacja: zmniejszanie o 1.

operatory inkrementacji i dekremantacji mogą występować w dwóch odmianach: przedrostkowej ++i; --i; i przyrostkowej; i++; i--.

operator przedrostkowy ++i; --i wykonuje operację przed przypisaniem wartości, odwrotnie jest z operatorem przyrostkowym

7. Sposoby przesyłania argumentów do funkcji ( przykłady) funkcja jako argument funkcji.

Przesyłanie argumentów do funkcji:

• przez wartość,

• przez referencję,

• przez wskaźnik (omówimy później).

Przesyłanie argumentów przez wartość:

W definicji funkcji występują parametry formalne. Przy wywołaniu funkcji posługujemy się parametrami aktualnymi. Do funkcji (przy wywołaniu) przesyłane są tylko wartości parametrów aktualnych. Służą one do inicjalizacji parametrów formalnych (operacje wykonywane są na parametrach formalnych). Parametry formalne (i inne zadeklarowane w funkcji) są tworzone na stosie (tj. wydzielonym obszarze pamięci po wyjściu z funkcji zwartość tych zmiennych jest niszczona, a przy kolejnym wejściu jest ona przypadkowa). Są one kopiami parametrów aktualnych. Pokazuje to przykład:

…

Przesyłanie argumentów przez referencje (przezwisko):

Przy przekazywaniu argumentów do funkcji przez referencje trzeba inaczej zadeklarować funkcję np.:

void Zamiana (int, int &);

lub void Zamiana (int x, int &y);

wywołanie: Zamiana (a,b);

Znak & powoduje, że zmienna globalna b i lokalna y zajmują to samo miejsce w pamięci operacyjnej. Inaczej - słowo b w pamięci ma referencje (przezwisko) y w funkcji. Modyfikując y w funkcji lokalnej, zmieniamy b w funkcji nadrzędnej.

Ten sposób przekazywania argumentów jest stosowany przy przekazywaniu do funkcji dużych struktur danych np.: tablic. Oszczędza się wówczas pamięć - nie tworzy się kopii dużych struktur danych.

Uwagi:

Obiekt zdefiniowany na zewnątrz wszystkich funkcji ma zasięg globalny. Zmienne globalne umieszczone są w wydzielonym obszarze pamięci, którzy przed uruchomieniem programu jest zerowany.

Zmienne lokalne są zmiennymi automatycznymi. W momencie, gdy kończymy działanie bloku, w którym zmienne lokalne zostały powołane do życia, automatycznie przestają istnieć. Obiekty automatycznie komputer przechowuje na stosie. Należy pamiętać, że zmienne automatyczne nie są zerowane w chwili definicji. Jeśli nie zainicjowaliśmy ich jakąś wartością, to przechowują wartości przypadkowe.

Funkcje inline

Wywołanie funkcji wymaga czasu (kilka instrukcji na poziomie języka maszynowego by przejść w inne miejsce programu). Jest to istotne jeśli funkcje wykonuje się wiele razy. Jeśli funkcja jest krótka (w linii), to w celu przyspieszenia obliczeń używamy funkcji inline.
Deklarujemy i definiujemy ją na początku programu (albo w pliku nagłówkowym). Przy jej wywołaniu kompilator umieści jej treść w miejscu wywołania.

Funkcje w programie składającym się z kilku plików

Jeśli program jest duży i nie mieści się w jednym pliku, to plik dzieli się na pliki mniejsze. Plik można dzielić na mniejsze w miejscu między definicjami funkcji.

By korzystać w pliku B ze zmiennych zadeklarowanych w pliku A, to trzeba w pliku B umieścić deklarację:

extern int a;

extern float b;

extern char c;

Jeśli chcemy korzystać w pliku B z funkcji znajdujących się w pliku A, to także musimy umieścić je w deklaracjach pliku B (nie trzeba dodawać słowa extern - jest ono domniemane).

Wygodnie jest umieścić wszystkie deklaracje funkcji (i deklaracje globalne) w specjalnym pliku - pliku nagłówkowym (nazwa.h). Plik ten jest bezpośrednio przed kompilacją włączany do pliku B.

To automatyczne wstawianie realizuje dyrektywa preprocesora: #include <nazwa.h>

Funkcje biblioteczne nie są częścią języka C++. Ktoś je napisał, a ponieważ były dobre, to zrobiono z nich standardowe biblioteki.

8 Definicja oraz definicja i inicjalizacja dowolnej tablicy, tablicy dynamicznej

Tablica to zbiór elementów tego samego typu, które zajmują ciągły obszar w pamięci. Tablice są typem pochodnym, tzn. buduje się je z elementów jakiegoś typu nazywanego typem składowym.

Rozmiar tablicy musi być stałą, znaną już w trakcie kompilacji; Kompilator musi wiedzieć ile miejsca ma zarezerwować na daną tablicę. Rozmiar ten nie może być ustalany dopiero w trakcie pracy programu. (TABLICE STATYCZNE).

Typ składowy tablic:

• fundamentalny

• wyliczeniowy

• inna tablica

• wskaźniki

• obiekty typu zdefiniowanego

Numeracja elementów zaczyna się od zera. Element A[5] nie istnieje w tablicy int A[4]; Próba wpisania jakiejś wartości do A[5] nie będzie sygnalizowana jako błąd, jednak wartość ta zostanie przypisana do kolejnej zmiennej znajdującej się w pamięci zaraz po tablicy.

Jeżeli w momencie inicjalizacji na liście jest więcej elementów, to kompilator wyświetli błąd, natomiast można zainicjalizować mniej elementów niż wielkość tablicy

9 Operator & , referencja

Do nadania wskaźnikowi wartości początkowej służy jednoargumentowy operator & (ampersand). Oblicza on adres obiektu, który stoi po prawej stronie operatora przypisania.

10

Do czego slużą i jaką informację zawierają wskaźniki przykłady

Wskaźnik przechowuje adres obiektu wskazanego typu oraz wiedzę o typie danego obiektu. Wskaźnik służący do pokazywania obiektów jednego typu nie nadaje się zatem do pokazywania obiektów innego typu.

Podst. zastosowania wskaźników:

• wskaźniki do tablic umożliwiające ulepszenie pracy tablicami;

• w funkcjach do zmieniania wartości przesyłanych do nich (odbieranych) argumentów;

• dostęp do specjalnych obszarów pamięci;

• rezerwacja obszarów pamięci.

11 co deklaruje (definiuje) się w poniższym fragmencie programu ?

12. Podaj przykład definicji struktury, klasy, klasy abstrakcyjnej, szablonu funkcji (sensowne)

KLASA

To inaczej mówiąc typ. Definja klasy ma nastepujaca postać

Class identyfikator_typu

{

Cialo klsy

};

Gdzie cialo klasy zawiera deklaracje składników klasy

Przyklad

Class Okrag

{

Public:

Int x,y,r;

…

};

Struktury

Struci nazwa
(

// lista składników

)

Dostęp do składowych struktury:

Nazwa_Zmienniej_strukturalnej. Nazwa_skladnika\

Przykład:

Struci Osoba //definicja typu strukturalnego Osoba

(

Char*Nazwisko;

Char*imie;

Int wiek;

)

Osoba Student.//dekl. Obiektu student typu osoba

KLASY ABSTRAKCYJNE

Klasa abstrakcyjna to klasa, która nie reprezentuje żadnego konkretnego obiektu. Np. klasa ssak nie ma obiektów i istnieje tylko po to by mieć klasy pochodne (człowiek, psy, koty, konie, świnia, baran).

Ssak jest zatem pojęciem abstrakcyjnym - klasą abstrakcyjną.

Rozważmy sytuację - mamy dwie kalsy: klasę trójkąt i klasę kwadrat. Nie pochodzą one od siebie, nie można zatem powiązać ich dziedziczeniem (jedna nie jest szczególnym przypadkiem drugiej). Z drugiej strony mają one zbiór wspólnych cech (pozycja na erkanie, kloro linii, pole powierzchni).

Mają też zbiór wspólnych zachowań (można je rysować, przesunąć, obrócić). Jeśli potrafimy wyodrębnić wspólne cechy i zachowania, to mamy przesłankę, by zdefiniować klasę nadrzędną - abstrakcyjną.

Class figura { //klasa abstrakcyjna

protected:

int pozycja_x, pozycja_y, kolor;

public:

void przesun (int dx, int dy)

{ pozycja_x+=dx;

pozycja_y+=dy;

}

};

Klasa abstrakcyjna pozwala zaoszczędzić pracy przy programowaniu: wspólne cechy i zachowanie (np. przesuń, rysuj) kilku klas definiujemy jednokrotnie.

Wygodnie jest zadeklarować jedynie szkielet funkcji klasy abstrakcyjnej, natomiast w klasach pochodnych definiować te funkcje w zależności od potrzeb danej klasy.

Jeśli deklarujemy funkcję jako wirtualną, to musimy podać jej definicję w nast. sposób:

void virtual FF()=0; // czysto wirtualna

void virtual FF()=0; {ciało funkcji} //czysto wirtualna z definicją

SZABLONY FUNKCJI

Wyobraźmy sobie sytuację, że w programie potrzebujemy funkcji, która z 2 liczby typu int wybierze większą i ją zwróci. Jak wygląda definicja takiej funkcji?

int wieksza (intx, inty)

{

return (x>y) ? x : y;

}

Wywołanie funkcji np.: cout << wieksza (3,99);

Dla innych typów danych wejściowych trzeba by napisać osobne funkcje. Jak temu zaradzić?

Jakis_typ_wieksza (jakiś_typ x, jakiś_typ y)

{

return (x>y) ? x : y;

}

Jak definiuje szablon funkcji w C++?

template < class --> jakiś_typ[Author:M] >

jakiś_typ wieksza ( --> jakiś_typ x[Author:M] , --> jakiś_typ y[Author:M] )

{

return (x>y) ? x : y;

}

Parametr szablonu musi wystąpić jako typ argumentu funkcji

Gdy kompilator napotka w programie wywołanie funkcji, to korzystając z szabloinu generuje ją.

W zależności od typu arg1, arg2 w wywołaniu, generowana jest funkcja działająca na tym typie (w szablonie j_typ jest zamieniane na bieżący typ). Mamy zatem tyle funkcji, co różnych typów przy wywołaniu.

Gdyby powtórzył się typ argumentów, to funkcja generowana jest tylko 1 raz (później istnieje już w pamięci). Oszczędzamy na kodzie programu - jest on bardzo przejrzysty i generuje się automatycznie.

Sygnałem dla kompilatora jest generowana…

Przy wyborze wariantu generowanej funkcji szablonowej kompilator bierze pod uwagę tlyko typ argumetnów. Nie jest brany pod uwagę typ wartośći zwracanej. Wyróżniamy podobnie jak przy zwykłych funkcjach deklaracji i definicję szablonu funkcji.

Jeśli w liście argumentów jest kilka zmiennych tego samego typu, to w liście parametrów podaje się ten typ tylko raz.

Odwoływanie się

13. Dostęp do skladowych struktury, klasy

Tryb dostępu stanowi o tym, czy do składowych jest dostęp spoza klasy za pomocą operatora kropki:

class Klasa1 {

public: // dostęp publiczny do poniższej składowej

double x;

};

Klasa1 Obiekt1;

Obiekt1.x=3.25; // mamy dostęp spoza klasy do składowych publicznych

class Klasa2 {

double x; // składowa domyślnie prywatna

};

Klasa2 Obiekt2;

Obiekt2.x=3.25; // w tym miejscu kompilator zgłosi błąd!

// Nie mamy dostępu spoza klasy do składowych prywatnych

Do składowych prywatnych mają dostęp zatem tylko i wyłącznie metody należące do tej samej klasy oraz tzw. funkcje zaprzyjaźnione - ale o nich potem

Istnieje jeszcze trzeci tryb dostępu do składowych, a nazywa się protected, czyli chroniony. Działa on dokładnie tak samo jak prywatny, z jednym tylko wyjątkiem. Wyjątek ten objawia się podczas dziedziczenia.

Jeśli uczynimy naszą klasę ze składowymi chronionymi klasą bazową dla nowo tworzonej klasy, to wszystkie klasy pochodne mogą mieć dostęp do składowych chronionych, natomiast żadna z klas pochodnych nie ma dostępu do składowych prywatnych klasy bazowej.

Zatem deklarujmy składowe jako prywatne tylko wtedy, kiedy jesteśmy pewni że żadna z klas pochodnych naszej klasy nie powinna mieć do tych składowych dostępu.

Właściwie definicja klasy nie różni się od definicji struktury. Jedyną różnicą jest domyślny tryb dostępu do pól (składowych): w strukturze jest to tryb tzw. public, natomiast w klasie - private. Świadomie użyłem swierdzenia "jedyną różnicą". Poza nią bowiem można ze struktur korzystać dokładnie tak samo jak z klas, z dziedziczeniem włącznie. Pewną niewygodą tego rozwiązania byłaby niewygodna składnia przy definiowaniu struktur, jak przedstawiłem to powyżej.

• konstruktor i destruktor

Konstruktor

Definicję obiektu i nadanie mu wartości można załatwić w jednej instrukcji. W tym celu należy posłużyć się specjalną funkcją składową zwaną konstruktorem. Charakteryzuje się ona tym, że nazywa się tak samo jak klasa. Oto przykład klasy wyposażonej w konstruktor:

class Numer

{

int Liczba;

public:

Numer (int L) {

Liczba = L;} //konstruktor

void Schowaj (int L) { Liczba = L;}

int Zwracaj() {return Liczba;}

};

Należy zwrócić uwagę, że konstruktor to taka specjalna funkcja o nazwie klasy. Nie ma ona żadnego określenia typu wartości zwracanej. Nie może tam być nawet typu void.

Oczywiście z faktu tego wynika, że nie może tam wystąpić instrukcja return zwracająca jakąkolwiek wartość.

Oto jak w programie posługujemy się konstruktorem Numer wcześniej zdefiniowanej klasy Numer:

Numer a = Numer(15); //definicja obiektu a i nadanie jego składnikowi Liczba wartości 15

(a.Liczba=15)

lub prościej:

Numer b (15);

Nazwa „konstruktor” może być nieco myląca. Konstruktor nie konstruuje obiektu, tylko nadaje mu wartość początkową. Konstruktor nie jest obowiązkowy.

#include <iostream.h> //p.54 klasy - konstruktor

#include <conio.h>

#include <string.h>

//--------------- definicja klasy Numer ------------------------

class Numer

{

int Liczba;

char Nazwa[40];

public: //----- funkcje składowe ------

Numer (int L, char *Opis); // deklaracja konstruktora

void Schowaj(int L)

{

Liczba = L;

Melduj();

}

int Zwracaj() { return Liczba; }

void Melduj()

{

cout << Nazwa << Liczba << endl;

}

};

//-------------- koniec definicji klasy Numer -----------------

Numer::Numer(int L, char *Opis)

{

Liczba = L;

strcpy(Nazwa, Opis);

}

//*************************************************************

void main ()

{

Numer Samolot (1200, "Biezaca wysokosc: ");

Numer Atmosfera(920, "Cisnienie atmosferyczne: "),

Kurs(63, "Kierunek lotu: ");

//---- wstępny raport -------------------

clrscr();

Samolot.Melduj();

Kurs.Melduj();

Atmosfera.Melduj();

cout << "\nKorekta lotu:\n";

//---- wzrost wysokoœci o 1 m ------------

Samolot.Schowaj(1201);

//---- zmiana kursu o 3 stopnie ----------

Kurs.Schowaj(Kurs.Zwracaj()+3);

//---- zmniejszenie ciœnienia o 2 hPa ---

Atmosfera.Schowaj(Atmosfera.Zwracaj()-2);

while (!kbhit())

{ }

}

Destruktor

Przeciwieństwem konstruktora jest destruktor - funkcja składowa wywoływana jest wtedy, gdy obiekt danej klasy ma być zlikwidowany.

Destruktor to funkcja składowa klasy. Destruktor nazywa się tak samo jak klasa, z tym że przed nazwą ma znak ~(tylda).

Podobnie jak konstruktor - nie ma on żadnego typu zwracanego.

#include <iostream.h> //p. 55, klasy – konstruktor, destruktor

#include <conio.h>

#include <string.h>

//------- definicja klasy Gadula -------------------------------

class Gadula

{

int Licz;

char Tekst[40];

public:

// konstruktor:

Gadula(int k, char *Opis);

// destruktor:

~Gadula(void);

// inne funkcje składowe:

int Zwracaj() { return Licz; }

void Schowaj(int x) { Licz = x; }

void CoTo() { cout << Tekst << " ma wartosc: " << Licz << endl; }

};

//------- koniec definicji klasy Gadula -----------------------

Gadula::Gadula(int k, char *Opis) // konstruktor

{ strcpy(Tekst, Opis);

Licz = k;

cout << "Konstruuje " << Tekst << endl;

}

Gadula::~Gadula() // destruktor

{ cout << "Pracuje destruktor (sprzata) " << Tekst << endl;

}

//************************************************************

Gadula a(1, "obiekt a (GLOBALNY)" ); //globalna def. obiektow a,b

//połšczona z wyw. konstrukta

Gadula b(2, "obiekt b (GLOBALNY)" );

//************************************************************

void main()

{ clrscr();

a.CoTo(); //obiekty a,b istniejš; wywołanie f. składowej na rzecz ob. a, b

b.CoTo();

{ cout << "Poczatek lokalnego zakresu:\n";//klamry – poczštek zasięgu lokalnego

Gadula c(30, "obiekt c (lokalny)" ); // dekl. ob. c,a + konstruktor

Gadula a(40, "obiekt a (lokalny)" ); // zasłania globalny

cout << "\nCo teraz mamy: \n";

a.CoTo();

b.CoTo();

c.CoTo();

cout << "Do zaslonietego obiektu globalnego mozna sie jednak dostac\n";

::a.CoTo();

cout << "Konczy się lokalny zakres\n";

} // klamry – koniec zasięgu lokalnego; automatycznie wyw. jest destruktor ob. c,a

cout << "Juz jestem poza blokiem\n";

a.CoTo();

b.CoTo();

cout << "Uruchamiam destruktor obiektu a\n";

a.Gadula::~Gadula(); // jawne wywołanie destruktora

cout << "K o n i e c p r o g r a m u\n";

while (!kbhit())

{ }

} // automatyczne wywołanie destruktora do obiektow a,b

• czym różni się konstruktor i destruktor od funkcji składowych ????

Definiowanie destruktora i konstruktora w obrębie szablonu klasy przebiega w identyczny sposób jak definicja zwykłej funkcji składowej. Również definiowanie konstruktora i destruktora poza ciałem szablonu klasy jest zbliżone do definicji zwykłej funkcji składowej - jedyna różnica polega na tym, że nie podajemy typu jaki zwraca dany konstruktor - destruktor!!! Oto przykład:

template < class typ>
class schowek
{
 public:
   typ a;
   schowek(); //deklaracja konstruktora
   ~schowek();//deklaracja destruktora
}

//definiujemy konsruktor:
template < class typ>
schowek< typ>::schowek()
{
  a=(typ)'A';
}

//definiujemy destruktor:
template < class typ>
schowek< typ>::~schowek()
{
  cout<< "Dziala destruktor :-) "<< endl;
}

• Wyjaśnij pojęcia

Wskaźnik this

Deklaracja każdej klasy zawiera ukryte pole wskaźnikowe o nazwie this

Po utworzeniu obiektu, wskaźnik this zawiera adres obiektu w pamięci ( a wiec takich wsklażników mamy tyle co obiektów);

Oto klasa osoba widziana oczami komputera

wirtualnych (virtual).

• Deklarować w klasie bazowej jako wirtualne wszystkie funkcje, które mogązostać przesłonięte:

void virtual wstaw (int m) {a=m;}

• Jeśli klasa pochodna ma zostać klasa bazową, to również te wszystkie dodatkowe funkcje, które mogą być przesłonięte powinny być zadeklarowane jako virtual (również wirtualne powinny być destruktory).

Funkcje inline

Wywołanie funkcji wymaga czasu (kilka instrukcji na poziomie języka maszynowego by przejść w inne miejsce programu). Jest to istotne jeśli funkcje wykonuje się wiele razy. Jeśli funkcja jest krótka (w linii), to w celu przyspieszenia obliczeń używamy funkcji inline.
Deklarujemy i definiujemy ją na początku programu (albo w pliku nagłówkowym). Przy jej wywołaniu kompilator umieści jej treść w miejscu wywołania.

New

Cechy obiektów stworzonych operatorem new:

• istnieją od momentu, gdy je utworzymy operatorem, do momentu gdy jest usuniemy (delete)

• obiekt tak utworzony nie ma nazwy. Można nim operować tylko za pomocą wskaźników.

• obiektów tych nie obowiązują zwykłe zasady o zakresie ważności. Jeśli tylko w danej chwili jest dostępny choćby jeden wskaźnik, który na taki obiekt wskazuje, to mamy dostęp do tego obiektu.

• Tylko statyczne obiekty są inicjalizowane wstępnie zerami. Natomiast obiekty

17. Klasy i szablony przykład /// przykłady takie jak w pytaniu 12

KLASY

Class figura { //klasa abstrakcyjna

protected:

int pozycja_x, pozycja_y, kolor;

public:

void przesun (int dx, int dy)

{ pozycja_x+=dx;

pozycja_y+=dy;

}

};

Szablony

int wieksza (intx, inty)

{

return (x>y) ? x : y;

}

Wywołanie funkcji np.: cout << wieksza (3,99);

Dla innych typów danych wejściowych trzeba by napisać osobne funkcje. Jak temu zaradzić?

Jakis_typ_wieksza (jakiś_typ x, jakiś_typ y)

{

return (x>y) ? x : y;

}

Jak definiuje szablon funkcji w C++?

template < class --> jakiś_typ[Author:M] >

jakiś_typ wieksza ( --> jakiś_typ x[Author:M] , --> jakiś_typ y[Author:M] )

{

return (x>y) ? x : y;

}

parametr szablonu

argument 1

argument 2

parametr szablonu

argument 1

argument 2

---