Slajd 1

Typ referencyjny

(odniesienie)

Referencja

jest czymś w rodzaju

synonimu i odsyłacza do innej

zmiennej

(obiektu) dla której staje się

alternatywą

Wszystkie

operacje na utworzonej referencji

będą

również

wykowywane na zmiennej

(obiekcie) którą została zainicjowana ta

referencja

Różnice

Wskaźnik

– jego wartość to

adres wskazywanej

zmiennej

Referencja

– jej wartość to

inna zmienna

Deklarowanie zmiennej

referencyjnej

int

&rx

;

typ zmiennej referencyjnej i zmiennej

nazwa zmiennej

operator i nazwa zmiennej referencyjnej

inicjacja

zmiennej referencyjnej

double pos=56, &r_pos=pos;

zmienna referencyjna r_pos związana ze zmienną pos

int i, n=10, &ri=n;

zmienna referencyjna ri związana ze zmienną i

przyjmuje wartość 10

ri=n;

Deklaracja zmiennej referencyjnej musi być

połączona z jej inicjacją

marka

cena_min

cena_max

FORD

35000

200000

BMW

70000

400000

AUDI

80000

350000

SEAT

30000

120000

marka

FORD

BMW

AUDI

SEAT

cena_min

cena_max

35000

200000

70000

400000

80000

350000

30000

120000

można – tablice równoległe

int lp[4]

char marka[4][20] float[4][2]

konstrukcja agregatora danych w C++,

jakim jest

struktura

, używa następujących pojęć:

-pole rekordu (struktury)

–

field

zmienna typu prostego wchodząca w skład struktury

-wystąpienie rekordu danego typu

–

single record

instance

(rekord może zawierać wiele pól w

ustalonej (predefiniowanej) kolejności.

-ponumerowana tablica

–

arrey of records (DataBase Table)

złożona z rekordów.

-nowy strukturalny typ danych

–

structure type (structural data type)

określony typ

struktur (rekordów)

Definicja nowego typu
struktur

struct pojazd

{

int lp;

char marka[20];

float cena_min;

float cena_max;

};

Słowo
kluczowe

Nazwa-identyfikator
typu struktura
(rekordu)

typ nazwa

pola struktury

typ nazwa

pola struktury

typ nazwa

pola struktury

typ nazwa

pola struktury

#include<iostream.h>

\\tablica złożona ze

struktur

#include<string.h>

#include<conio.c>

struct pojazd

{ int lp;

char marka[20];

float cena_min;

float cena_max;};

main()

{

struct pojazd samochod[10];

int i;

samochod[0].lp=1;

strcpy(samochod[0].marka,"FORD");

samochod[0].cena_min=35000;

samochod[0].cena_max=200000;

samochod[1].lp=2;

strcpy(samochod[1].marka,"BMW");

samochod[1].cena_min=70000;

samochod[1].cena_max=400000;

samochod[2].lp=3;

strcpy(samochod[2].marka,"AUDI");

samochod[2].cena_min=80000;

samochod[2].cena_max=350000;

samochod[3].lp=4;

strcpy(samochod[3].marka,"SEAT");

samochod[3].cena_min=30000;

samochod[3].cena_max=120000;

cout<<"Lp\t"<<"marka "<<"cena_min

"<<"cena_max"<<endl<<endl;

for(i=0;i<4;i++)

{

cout<<samochod[i].lp<<'\t'<<samochod[i].marka;

cout<<'\t'<<samochod[i].cena_min<<'\t'<<samochod[i].cena_max

<<endl;

}

getch();

return 0;

}

Lp marka cena_min

cena_max

1 FORD 35000

200000

2 BMW 70000

400000

3 AUDI 80000

350000

4 SEAT 30000

120000

.lp

.marka

.cena_min

.cena_max

„FORD”

35000

200000

.lp

.marka

.cena_min

.cena_max

„BMW”

70000

400000

.lp

.marka

.cena_min

.cena_max

„AUDI”

80000

350000

.lp

.marka

.cena_min

.cena_max

„SEAT”

30000

120000

[0
]

[1
]

[2
]

[3
]

samocho
d

rekord

pole

FUNKCJE

podprogramy, moduły (części)

programu napisanego w C++

nazywane są funkcjami

Powody stosowania funkcji:

najlepszy jest krótki kod

(

program bardziej

czytelny, zrozumiały, uzyskujemy bezpośrednią korelację między
algorytmem a tekstem programu

łatwiejsze i szybsze wyłapywanie błędów

(pluskiew – bug),

moduł napisany raz może być wielokrotnie

wykorzystany, może powiększać biblioteki

gotowych kodów,

podczas

testowania

uruchomienia

programu

można

oddzielnie

sprawdzać

poszczególne funkcje a następnie uruchomić

cały program,

programowanie

gra

zespołowa,

poszczególne

moduły

tworzą

różni

programiści,

Fundamentalne zasady gry

z funkcjami w C++

Każda funkcja w C++ składa się z:

-prototypu (prototype) -

musi

się

znajdować

przed

głównym

modułem

programu tj. przed funkcją main( ),

-definicji (definition, ciało) -

znajduje

się

zwykle

zakończeniu

głównego modułu programu tj. po return 0.

Może znajdować się również bezpośrednio

pod prototypem funkcji.

Prototyp funkcji w

C++

float funkcja1 (int x, int y,

float z)

;

Typ danych
wyjściowych

Dane wejściowe

funkcji

umieszczone w

nawiasach ( )

Nazwa własna

funkcji,

unikalna,

niepowtarzal

Pamię

taj

średni

Argumenty

formalne

Dyrektywy preprocesora

Prototypy
funkcji

Funkcja główna

Wywołania
funkcji

Definicje
funkcji

float Funkcja_1(int x, float y,float z);

main()

{

suma=Funkcja_1(a,b,c);

Funkcja_2(t,12);

}

float Funkcja_1(int x, float y,float z)

{

}

void Funkcja_2(int X, int DD);

void Funkcja_2(int X, int DD)
{

}

Przykład programu zawierającego

funkcję

#include <iostream.h>

int kukulka(int ile) ;

/*******************************************/
main ( )
{
int m=20 ;

cout<<”zaczynamy”<<endl ;
m=kukulka(5) ;

cout<<”\nNa koniec m= ” <<m ;

}
/*******************************************/
int kukulka (int ile)

{

int i ;

for ( i=0 ; i < ile ; i++ )
{

cout << ”Ku-ku ! ” ;

}
return 77 ;

}

prototyp

(1) kukulka

jest funkcją wywołaną

argumentem typu

int

a zwracającą

jako rezultat wartość typu

int

wywołanie

(2)

Napisanie funkcji łącznie z

nawiasem, w którym znajduje się
argument przesyłany do funkcji.
Funkcja zwróci jakąś wartość –
przypisujemy tej wartosci zmienną

(3)

Na dowód

wypisujemy na

ekran

definicje

(4)

Definiujemy funkcję; ciało

funkcji zawiera wszystkie instrukcje
wykonywane w klamrach funkcji

(5÷7)

(6)

Funkcja

kończy swoją pracę i

wraca do miejsca skąd została
wywołana. Widoczna jest wartość,
którą zdecydowaliśmy zwrócić jako
rezultat wykonania tej funkcji

Zaczynamy

Ku-ku ! Ku-ku ! Ku-ku ! Ku-ku ! Ku-
ku !

Na koniec m=77

Dyrektywy preprocesora

(0)

Przykłady deklaracji

funkcji:

float kwadrat (int bok) ;

void fun (int stopien, char znaczek, int nachylenie) ;

int przypadek (void) ;

char znak_x( ) ;

void pin(….) ;

•

kwadrat

jest funkcją wywołaną z jednym argumentem typu

int

, która

zwraca w rezultacie wartość typu

float

•

fun

jest funkcją wywołaną z 3 argumentami typu

int

char

int

, która

nie zwraca żadnej wartości (

jeśli przez pomyłkę będziemy próbowali uzyskać z tej

funkcji jakąś wartość a kompilator to zauważy – pokaże błąd

)

•

przypadek

to funkcja bez argumentu, zwraca wartość typu

int

•

znak_x

to funkcja, jest wywołana bez żadnych argumentów, zwraca

wartość typu

char

•

jest funkcją, która teraz jeszcze nie ma nieokreślonych

argumentów i nie zwraca żadnej wartości ->

f( ); oznacza f(void)

;

Nazwy argumentów, lecz nie typy można
pominąć np.

void fun (int, char, int) ;

Przekazywanie przez wartość

Polega

kopiowaniu

wartości

argumentów aktualnych do pamięci
argumentów

formalnych,

czyli

funkcja

nigdy

nie ma dostępu do

swoich argumentów aktualnych (do
oryginałów)

Zawartość argumentów aktualnych
przekazywanych przez wartość

nie ulega

zmianie

Ograniczenia:

gdy przekazywany argument zajmuje duży

obszar pamięci

gdy wartości argumentu muszą być

zmieniane przez

funkcję

Moduł główny
main()

Moduł funkcji
potega(x)

liczba=20;

wynik=potega(li
czba);

400

x=x*x; zmienna x zawiera
teraz 400

a wartość 21
znikła

kopiowanie
wartości
zmiennej liczba
do zmiennej x

kopiowanie
wartości
zmiennej x do
zmiennej wynik

Chociaż wartość 20 została zmieniona we wnętrzu funkcji to w module

głównym main() wartość zmiennej liczba nie została zmieniona

Przekazywanie przez wartość

#include <iostream.h>

#include <conio.h>

double silnia (unsigned n);

//prototyp funkcji

main() {

clrscr();

int x;

cout<<"Podaj x=";

cin>>x;

cout<<endl<<x<<"!="<<silnia(x)<<endl<<endl;

//wywolanie funkcji

getch();

return 0;}

double silnia (unsigned n)

//definicja

funkcji

{

unsigned i;

double wynik;

if (n!=0)

{

wynik=1;

for (i=1;i<=n;i++)

wynik*=i;

return wynik;

}

else

return 1.0;

}

Obliczanie
silni

#include <iostream.h>

#include <conio.h>

void zamiana (int x, int y);

//prototyp funkcji

main()

{

clrscr();

int a=10, b=20;

cout<<"przed zamiana a="<<a<<"

b="<<b<<endl<<endl;

zamiana(a,b);

//wywolanie

funkcji

cout<<"po zamianie

a="<<a<<"

b="<<b<<endl<<endl;

getch();

return 0;

}

void zamiana (int x, int y)

//definicja funkcji

{

int pomoc=y;

y=x;

x=pomoc;

}

Niebezpieczeństwo

gdy wartości argumentów muszą być zmieniane przez funkcję

Zamiana wartości między zmiennymi

Przekazywanie przez wskaźnik

Jest właściwie odmianą przekazywania

przez wartość Funkcja otrzymuje po

prostu kopię wskaźnika

Przypisanie

wartości

zmiennej

wskazywanej

przez

parametr

wskaźnikowy

pozwala

zmieniać

wartość

zmiennych utworzonych w innych funkcjach programu

Główne wykorzystanie:

do przekazywania dużych struktur danych

(np. tablice, łańcuchy)

w celu umożliwienia zwrócenia

zmodyfikowanego

argumentu przez

funkcję

- w celu umożliwienia zwrócenia
zmodyfikowanej lub więcej niż jednej
wartości przez funkcję

#include <iostream>

#include <conio.h>

using namespace std;

void zamien(int *x, int *y);

//prototyp funkcji

main()

{

int a=10, b=20;

cout<<"Przed zamiana a="<<a<<"

b="<<b<<endl<<endl;

zamien(&a,&b);

//wywołanie

funkcji

cout<<"Po zamianie a="<<a<<"

b="<<b<<endl;

getch();

return 0;

}

void zamien(int *x, int *y)

//definicja funkcji

{

int z=*x;

*x=*y;

*y=z;

}

Przekazywanie przez wskaźnik -
przykład

Przekazywanie przez referencję (adres)

Przekazywanie argumentów przez

zmienne

Operacje  są  przeprowadzane  albo  bezpośrednio
na  zmiennej,  której  referencję  przekazano  do
funkcji,  albo  na  zmiennej  tymczasowej,  (co  ma
miejsce

przypadku

niezgodności

typu

referencyjnego i zmiennej), do której utworzono
referencję

Powszechnie

używa

się

argumentów

referencyjnych

przekazywania

dodatkowych wyników wywołania funkcji

#include <iostream>

#include <conio.h>

using namespace std;

void zamien(int &x, int &y);

//prototyp

funkcji

main()

{

int a=15, b=25;

cout<<"Przed zamiana a="<<a<<"

b="<<b<<endl<<endl;

zamien(a,b);

//wywołanie funkcji

cout<<"Po zamianie a="<<a<<"

b="<<b<<endl;

getch();

return 0;

}

void zamien(int &x, int &y)

//definicja funkcji

{

int z=x;

x=y;

y=z;

}

Przekazywanie przez referencję -
przykład

// Zwracanie wielu wartości funkcji z wykorzystaniem referencji

#include<iostream>

#include<conio.h>

using namespace std;

enum kod_bledu {pech,sukces};

//typ wyliczeniowy

kod_bledu potegi(int x, int &y, int &z);

//prototyp funkcji

main()

{ int liczba, kw, sz;

kod_bledu wynik;

cout<<"Podaj liczbe od 1 do 15 \n";

cin>>liczba;

wynik=potegi(liczba,kw,sz);

//wywołanie

funkcji

if(wynik==sukces)

{

cout<<"liczba="<<liczba<<endl;

cout<<"kwadrat="<<kw<<endl;

cout<<"szescian="<<sz<<endl;

}

else

cout<<"wystapil blad !!!";

getch();

return 0;}

kod_bledu potegi (int x, int &y, int &z)

//definicja funkcji

{ if (x>15)

return pech;

else

{

y=x*x;

z=x*x*x;

return sukces;

}

#include <iostream.h>

#include <conio.h>

void zastap(double &d)

//deklaracja i definicja

funkcji zastap

{

d=d*d;

}

main()

{

clrscr();

int i=10;

double x=10.0;

zastap(i);

//wywołanie 1 funkcji

zastap(x);

//wywołanie 2 funkcji

cout<<"i="<<i<<endl;

cout<<"x="<<x<<endl;

getch();

return 0;

}

NIEBEZPIECZEŃSTWA przy przekazywaniu przez

referencję

przy niezgodności typów

#include <iostream.h>

#include <conio.h>

using namespace std;

int suma_kwadratow(int x);

main()

{

int n, wynik;

cout<<"podaj wartosc zmiennej n"<<endl;

cin>>n;

wynik=suma_kwadratow(n);

cout<<"Suma kwadratow dla n="<<n<<"

wynosi "<<wynik;

getch();

return 0;

}

int suma_kwadratow(int x)

{

int i, suma=0;

for (i=1;i<=x;i++)

suma+=i*i;

return suma;

}

Napisz program do obliczania następującej sumy
1

+ ... +n

Prototyp
funkcji

Wywołanie
funkcji

Definicja
funkcji

#include <iostream>
#include <conio.h>
using namespace std;
int suma_kwadratow(int x);

main()
{
int n, wynik;
cout<<"podaj wartosc zmiennej n"<<endl;
cin>>n;
wynik=suma_kwadratow(n);
cout<<"Suma kwadratow dla n="<<n<<"

wynosi "<<wynik;
getch();
return 0;
}
int suma_kwadratow(int x)
{
int i, suma=0;
for (i=1;i<=x;i++)
suma+=i*i;
return suma;
}

Wykonanie programu z zastosowaniem funkcji

Wykonani

sekwencyj

programu

Wywołanie

funkcji (skok

do funkcji)

Powrót do

miejsca

wywołania

funkcji

Funkcje - co warto zapamiętać

Pięć ?

powodów:

1. Prototyp

funkcji

musi

zostać

umieszczony

przed

początkiem

programu głównego (main). (int

FUN1(int x, int y)

2. Format definicji funkcji w C++ jest

bardzo

podobny

formatu

programu głównego

3. Funkcja może być wywoływana z

wnętrza kodu programu głównego

lub z wnętrza innej funkcji (gdy

jest globalna)

4. Funkcja w C++ może zwrócić tylko

pojedynczy rezultat
(Jeśli dwa lub więcej należy użyć

więcej funkcji albo wywołać tę

samą funkcję kilka razy)

Funkcje - co warto zapamiętać cd

5. Zmienna

lokalna/wewnętrzna

taka

zmienna,

która

została

zadeklarowana we wnętrzu danej

funkcji

6. Wszystko co zostało zadeklarowane

przed użyciem słowa kluczowego

main jest traktowane w C++ jako

zewnętrzne/globalne i może być

stosowana w dowolnym miejscu

programu (przesłanianie zmiennych

globalnych)

7. Rezultat zwracany przez funkcję

musi być typu prostego

Document Outline