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
Różnice
Wskaźnik
– jego wartość to
adres wskazywanej
zmiennej
Referencja
– jej wartość to
inna zmienna
Typ referencyjny (odniesienie)
Zmienne typu referencyjnego służą do
reprezentacji innych zmiennych w programie
Czyli
wartością zmiennej typu
referencyjnego jest inna zmienna
w praktyce zmienne typu referencyjnego
służą do
przekazywania parametrów do
funkcji oraz zwracania wartości funkcji
Deklarowanie zmiennej
referencyjnej
int
x
,
&rx
=x
;
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ą
Przypisanie do referencji
#include <iostream>
#include <conio.h>
using namespace std;
main() {
int jeden;
int &r_jeden=jeden;
jeden=10;
cout<<"jeden="<<jeden<<endl;
cout<<"r_jeden="<<r_jeden<<endl;
cout<<"adres jeden="<<&jeden<<endl;
cout<<"adres r_jeden"<<&r_jeden<<endl;
int dwa=20;
r_jeden=dwa;
cout<<"jeden="<<jeden<<endl;
cout<<"dwa="<<dwa<<endl;
cout<<"r_jeden="<<r_jeden<<endl;
cout<<"adres jeden="<<&jeden<<endl;
cout<<"adres dwa="<<&dwa<<endl;
cout<<"adres r_jeden"<<&r_jeden<<endl;
getch();
return 0;}
Typ referencyjny -
ograniczenia
ograniczenia
Nie wolno konstruować:
-
referencji do referencji
float
&℞
-
wskaźników zmiennych referencyjnych
int
&*wsk_ref;
-
tablic referencji
double
&_ref[100];
Typy strukturalne
to uporządkowane,
wspólne zbiory
obiektów tego
samego lub różnego
typu.
2.
Typy
strukturalne
(złożone)
- tablice,
-
struktury
,
- unie,
- klasy.
Zmienne zdolne do przechowywania
więcej niż jednej wartości jednocześnie
to zmienne strukturalne (agregaty
danych)
Struktura to po prostu klasa, w
Struktura to po prostu klasa, w
której przez domniemanie
której przez domniemanie
wszystkie składniki są publiczne
wszystkie składniki są publiczne
Lp
Lp
marka
marka
cena_min
cena_min
cena_max
cena_max
1
1
FORD
FORD
35000
35000
200000
200000
2
2
BMW
BMW
70000
70000
400000
400000
3
3
AUDI
AUDI
80000
80000
350000
350000
4
4
SEAT
SEAT
30000
30000
120000
120000
marka
marka
FORD
FORD
BMW
BMW
AUDI
AUDI
SEAT
SEAT
Lp
Lp
1
1
2
2
3
3
4
4
cena_min
cena_min
cena_max
cena_max
35000
35000
200000
200000
70000
70000
400000
400000
80000
80000
350000
350000
30000
30000
120000
120000
można – tablice równoległe
int lp[4]
char marka[4][20] float[4][2]
Ale po co ??? – lepiej struktury
Struktura
pozwala na połączenie w jedną
całość wielu danych różnych typów
Struktura
jest to konstrukcja złożona z różnych danych
(typów danych) i jest deklarowana przy użyciu słowa
kluczowego
struct
Struktura jest w istocie definicją nowego „pomieszanego” rodzaju
danych
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
1
pola struktury
typ nazwa
2
pola struktury
typ nazwa
3
pola struktury
typ nazwa
4
pola struktury
struct pojazd
zdefiniowany, nowy typ
danych
użytkownika, który można wykorzystać do deklaracji
zmiennych
Deklaracja zmiennej typu pojazd
struct pojazd samochod;
może być pominięte
[opcjonalne]
nazwa nowego typu
nazwa zmiennej nowego typu pojazd
Zawiera 4 pola zdefiniowane w strukturze
pojazd
1 pole int lp
2 pole char marka[20]
3 pole float cena_min
4 pole cena_max
Odwoływanie się do poszczególnych pól struktury
(rekordu)
Notacja z użyciem kropki (dot notation)
samochod
.
marka
samochod
.
cena_max
Zainicjowanie pól struktury (rekordu)
strcpy (samochod.marka, „FORD”);
samochod.cena_max=200000;
Dostęp do pól struktury (rekordu)
cout<<samochod.cena_max;
cout<<samochod.marka;
Jeden rekord to w strukturze danych zbyt mało
Struktury jako elementy tablic
struct pojazd samochod[10];
(zmienna samochod może zawierać
10 rekordów
)
strcpy(samochod[0].marka,”FORD”);
strcpy(samochod[1].marka,”FIAT”);
samochod[0].cena_min=30000;
samochod[0].cena_max=200000;
#include<iostream.h>
#include<iostream.h>
\\tablica złożona ze
\\tablica złożona ze
struktur
struktur
#include<string.h>
#include<string.h>
#include<conio.c>
#include<conio.c>
struct pojazd
struct pojazd
{ int lp;
{ int lp;
char marka[20];
char marka[20];
float cena_min;
float cena_min;
float cena_max;};
float cena_max;};
main()
main()
{
{
struct pojazd samochod[10];
struct pojazd samochod[10];
int i;
int i;
samochod[0].lp=1;
samochod[0].lp=1;
strcpy(samochod[0].marka,"FORD");
strcpy(samochod[0].marka,"FORD");
samochod[0].cena_min=35000;
samochod[0].cena_min=35000;
samochod[0].cena_max=200000;
samochod[0].cena_max=200000;
samochod[1].lp=2;
samochod[1].lp=2;
strcpy(samochod[1].marka,"BMW");
strcpy(samochod[1].marka,"BMW");
samochod[1].cena_min=70000;
samochod[1].cena_min=70000;
samochod[1].cena_max=400000;
samochod[1].cena_max=400000;
samochod[2].lp=3;
samochod[2].lp=3;
strcpy(samochod[2].marka,"AUDI");
strcpy(samochod[2].marka,"AUDI");
samochod[2].cena_min=80000;
samochod[2].cena_min=80000;
samochod[2].cena_max=350000;
samochod[2].cena_max=350000;
samochod[3].lp=4;
samochod[3].lp=4;
strcpy(samochod[3].marka,"SEAT");
strcpy(samochod[3].marka,"SEAT");
samochod[3].cena_min=30000;
samochod[3].cena_min=30000;
samochod[3].cena_max=120000;
samochod[3].cena_max=120000;
cout<<"Lp\t"<<"marka "<<"cena_min
cout<<"Lp\t"<<"marka "<<"cena_min
"<<"cena_max"<<endl<<endl;
"<<"cena_max"<<endl<<endl;
for(i=0;i<4;i++)
for(i=0;i<4;i++)
{
{
cout<<samochod[i].lp<<'\t'<<samochod[i].marka;
cout<<samochod[i].lp<<'\t'<<samochod[i].marka;
cout<<'\t'<<samochod[i].cena_min<<'\t'<<samochod[i].cena_max
cout<<'\t'<<samochod[i].cena_min<<'\t'<<samochod[i].cena_max
<<endl;
<<endl;
}
}
getch();
getch();
return 0;
return 0;
}
}
Lp marka cena_min
Lp marka cena_min
cena_max
cena_max
1 FORD 35000
1 FORD 35000
200000
200000
2 BMW 70000
2 BMW 70000
400000
400000
3 AUDI 80000
3 AUDI 80000
350000
350000
4 SEAT 30000
4 SEAT 30000
120000
120000
.lp
.marka
.cena_min
.cena_max
1
„FORD”
35000
200000
.lp
.marka
.cena_min
.cena_max
2
„BMW”
70000
400000
.lp
.marka
.cena_min
.cena_max
3
„AUDI”
80000
350000
.lp
.marka
.cena_min
.cena_max
4
„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
i
uruchomienia
programu
można
oddzielnie
sprawdzać
poszczególne funkcje a następnie uruchomić
cały program,
-
programowanie
to
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
po
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
na
Pamię
taj
średni
k
Argumenty
formalne
Definicja (ciało) funkcji w
C++
float funkcja1 (int x, int y, float z)
{
float a,wynik;
a=pow(x,y);
wynik=a*z;
return wynik;
}
Nagłówek funkcji
jest powtórzeniem
prototypu
Zapamiętaj
Brak średnika
Normalny kod C+
+ zawarty w ciele
funkcji
Argumenty
formalne
Wywołanie funkcji w C++
Y=funkcja1
(a,b,c);
Przy wywołaniu argumenty funkcji mogą nazywać się
zupełnie inaczej, niż je nazywa sama funkcja w
prototypie i definicji
Funkcję w C++ mało lub nawet
wcale
nie
obchodzi jak argument nazywa się w "świecie
zewnętrznym"
Wywołujemy
funkcję poprzez
nazwę
Przekazujemy
funkcji
argumenty
aktualne
Nazwy
rzeczywiste
argumentów
Dyrektywy preprocesora
Prototypy
funkcji
Funkcja główna
Wywołania
funkcji
Definicje
funkcji
#
float Funkcja_1(int x, float y,float z);
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);
void Funkcja_2(int X, int DD)
{
}
Przykład programu zawierającego
Przykład programu zawierającego
funkcję
funkcję
#include <iostream.h>
#include <iostream.h>
//
//
0
0
int kukulka(int ile) ;
int kukulka(int ile) ;
//
//
1
1
/*******************************************/
main ( )
{
int m=20 ;
cout<<”zaczynamy”<<endl ;
m=kukulka(5) ;
//
2
cout<<”\nNa koniec m= ” <<m ;
//
3
}
/*******************************************/
int kukulka (int ile)
//
4
{
//
5
int i ;
for ( i=0 ; i < ile ; i++ )
{
cout << ”Ku-ku ! ” ;
}
return 77 ;
//
6
}
//
7
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ą
m
(3)
Na dowód
m
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
Przykłady deklaracji
funkcji:
funkcji:
float kwadrat (int bok) ;
float kwadrat (int bok) ;
void fun (int stopien, char znaczek, int nachylenie) ;
void fun (int stopien, char znaczek, int nachylenie) ;
int przypadek (void) ;
int przypadek (void) ;
char znak_x( ) ;
char znak_x( ) ;
void pin(….) ;
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
int
char
char
int
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
•
pin
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) ;
void fun (int, char, int) ;
Przekazywanie argumentów
(parametrów)
Przekazywanie argumentów do funkcji
polega na umieszczaniu wartości
argumentów aktualnych w pamięci
przydzielanej argumentom formalnym
funkcji
W
C++
parametry
mogą
być
przekazywane przez:
1. Wartość
2. Wskaźnik
3. Referencję
przez adres
przez adres
Przekazywanie przez wartość
Polega
na
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:
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);
20
400
400
20
x
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
Chociaż wartość 20 została zmieniona we wnętrzu funkcji to w module
głównym main() wartość zmiennej liczba nie została zmieniona
głównym main() wartość zmiennej liczba nie została zmieniona
Przekazywanie przez wartość
#include <iostream.h>
#include <iostream.h>
#include <conio.h>
#include <conio.h>
double silnia (unsigned n);
double silnia (unsigned n);
//prototyp funkcji
//prototyp funkcji
main() {
main() {
clrscr();
clrscr();
int x;
int x;
cout<<"Podaj x=";
cout<<"Podaj x=";
cin>>x;
cin>>x;
cout<<endl<<x<<"!="<<silnia(x)<<endl<<endl;
cout<<endl<<x<<"!="<<silnia(x)<<endl<<endl;
//wywolanie funkcji
//wywolanie funkcji
getch();
getch();
return 0;}
return 0;}
double silnia (unsigned n)
double silnia (unsigned n)
//definicja
//definicja
funkcji
funkcji
{
{
unsigned i;
unsigned i;
double wynik;
double wynik;
if (n!=0)
if (n!=0)
{
{
wynik=1;
wynik=1;
for (i=1;i<=n;i++)
for (i=1;i<=n;i++)
wynik*=i;
wynik*=i;
return wynik;
return wynik;
}
}
else
else
return 1.0;
return 1.0;
}
}
Obliczanie
silni
I
double silnia
(unsigned n)
{
unsigned i;
double wynik;
if (n!=0)
{
wynik=1;
for (i=1;i<=n;i++)
wynik*=i;
return wynik;
}
else
return 1.0;
}
//definicje funkcji silnia
II
double silnia
(unsigned n)
{
double wynik=1;
for (;n;--n)
wynik*=n;
return wynik;
}
#include <iostream.h>
#include <iostream.h>
#include <conio.h>
#include <conio.h>
void zamiana (int x, int y);
void zamiana (int x, int y);
//prototyp funkcji
//prototyp funkcji
main()
main()
{
{
clrscr();
clrscr();
int a=10, b=20;
int a=10, b=20;
cout<<"przed zamiana a="<<a<<"
cout<<"przed zamiana a="<<a<<"
b="<<b<<endl<<endl;
b="<<b<<endl<<endl;
zamiana(a,b);
zamiana(a,b);
//wywolanie
//wywolanie
funkcji
funkcji
cout<<"po zamianie
cout<<"po zamianie
a="<<a<<"
a="<<a<<"
b="<<b<<endl<<endl;
b="<<b<<endl<<endl;
getch();
getch();
return 0;
return 0;
}
}
void zamiana (int x, int y)
void zamiana (int x, int y)
//definicja funkcji
//definicja funkcji
{
{
int pomoc=y;
int pomoc=y;
y=x;
y=x;
x=pomoc;
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 <iostream>
#include <conio.h>
#include <conio.h>
using namespace std;
using namespace std;
void zamien(int *x, int *y);
void zamien(int *x, int *y);
//prototyp funkcji
//prototyp funkcji
main()
main()
{
{
int a=10, b=20;
int a=10, b=20;
cout<<"Przed zamiana a="<<a<<"
cout<<"Przed zamiana a="<<a<<"
b="<<b<<endl<<endl;
b="<<b<<endl<<endl;
zamien(&a,&b);
zamien(&a,&b);
//wywołanie
//wywołanie
funkcji
funkcji
cout<<"Po zamianie a="<<a<<"
cout<<"Po zamianie a="<<a<<"
b="<<b<<endl;
b="<<b<<endl;
getch();
getch();
return 0;
return 0;
}
}
void zamien(int *x, int *y)
void zamien(int *x, int *y)
//definicja funkcji
//definicja funkcji
{
{
int z=*x;
int z=*x;
*x=*y;
*x=*y;
*y=z;
*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
w
przypadku
niezgodności
typu
referencyjnego i zmiennej), do której utworzono
referencję
Powszechnie
używa
się
argumentów
referencyjnych
do
przekazywania
dodatkowych wyników wywołania funkcji
Moduł główny
main()
Moduł funkcji
potega(x)
wskaźnik
wynik=potega(li
czba);
Powoduje, że
wskaźnik x
wskazuje adres
FF00 tak samo
jak wskaźnik
liczba
FF00
FF00
x
x=x*x;
Powoduje, że zawartość
adresu pamięci FF00
zmienia się z 20 na 400
20
400
FF00
Oryginalna
zawartość
została
zmieniona
Przekazywanie przez adres
#include <iostream>
#include <iostream>
#include <conio.h>
#include <conio.h>
using namespace std;
using namespace std;
void zamien(int &x, int &y);
void zamien(int &x, int &y);
//prototyp
//prototyp
funkcji
funkcji
main()
main()
{
{
int a=15, b=25;
int a=15, b=25;
cout<<"Przed zamiana a="<<a<<"
cout<<"Przed zamiana a="<<a<<"
b="<<b<<endl<<endl;
b="<<b<<endl<<endl;
zamien(a,b);
zamien(a,b);
//wywołanie funkcji
//wywołanie funkcji
cout<<"Po zamianie a="<<a<<"
cout<<"Po zamianie a="<<a<<"
b="<<b<<endl;
b="<<b<<endl;
getch();
getch();
return 0;
return 0;
}
}
void zamien(int &x, int &y)
void zamien(int &x, int &y)
//definicja funkcji
//definicja funkcji
{
{
int z=x;
int z=x;
x=y;
x=y;
y=z;
y=z;
}
}
Przekazywanie przez referencję -
przykład
// Zwracanie wielu wartości funkcji z wykorzystaniem referencji
// Zwracanie wielu wartości funkcji z wykorzystaniem referencji
#include<iostream>
#include<iostream>
#include<conio.h>
#include<conio.h>
using namespace std;
using namespace std;
enum kod_bledu {pech,sukces};
enum kod_bledu {pech,sukces};
//typ wyliczeniowy
//typ wyliczeniowy
kod_bledu potegi(int x, int &y, int &z);
kod_bledu potegi(int x, int &y, int &z);
//prototyp funkcji
//prototyp funkcji
main()
main()
{ int liczba, kw, sz;
{ int liczba, kw, sz;
kod_bledu wynik;
kod_bledu wynik;
cout<<"Podaj liczbe od 1 do 15 \n";
cout<<"Podaj liczbe od 1 do 15 \n";
cin>>liczba;
cin>>liczba;
wynik=potegi(liczba,kw,sz);
wynik=potegi(liczba,kw,sz);
//wywołanie
//wywołanie
funkcji
funkcji
if(wynik==sukces)
if(wynik==sukces)
{
{
cout<<"liczba="<<liczba<<endl;
cout<<"liczba="<<liczba<<endl;
cout<<"kwadrat="<<kw<<endl;
cout<<"kwadrat="<<kw<<endl;
cout<<"szescian="<<sz<<endl;
cout<<"szescian="<<sz<<endl;
}
}
else
else
cout<<"wystapil blad !!!";
cout<<"wystapil blad !!!";
getch();
getch();
return 0;}
return 0;}
kod_bledu potegi (int x, int &y, int &z)
kod_bledu potegi (int x, int &y, int &z)
//definicja funkcji
//definicja funkcji
{ if (x>15)
{ if (x>15)
return pech;
return pech;
else
else
{
{
y=x*x;
y=x*x;
z=x*x*x;
z=x*x*x;
return sukces;
return sukces;
}
}
}
}
#include <iostream.h>
#include <iostream.h>
#include <conio.h>
#include <conio.h>
void zastap(double &d)
void zastap(double &d)
//deklaracja i definicja
//deklaracja i definicja
funkcji zastap
funkcji zastap
{
{
d=d*d;
d=d*d;
}
}
main()
main()
{
{
clrscr();
clrscr();
int i=10;
int i=10;
double x=10.0;
double x=10.0;
zastap(i);
zastap(i);
//wywołanie 1 funkcji
//wywołanie 1 funkcji
zastap(x);
zastap(x);
//wywołanie 2 funkcji
//wywołanie 2 funkcji
cout<<"i="<<i<<endl;
cout<<"i="<<i<<endl;
cout<<"x="<<x<<endl;
cout<<"x="<<x<<endl;
getch();
getch();
return 0;
return 0;
}
}
NIEBEZPIECZEŃSTWA przy przekazywaniu przez
referencję
przy niezgodności typów
#include <iostream.h>
#include <iostream.h>
#include <conio.h>
#include <conio.h>
using namespace std;
using namespace std;
int suma_kwadratow(int x);
int suma_kwadratow(int x);
main()
main()
{
{
int n, wynik;
int n, wynik;
cout<<"podaj wartosc zmiennej n"<<endl;
cout<<"podaj wartosc zmiennej n"<<endl;
cin>>n;
cin>>n;
wynik=suma_kwadratow(n);
wynik=suma_kwadratow(n);
cout<<"Suma kwadratow dla n="<<n<<"
cout<<"Suma kwadratow dla n="<<n<<"
wynosi "<<wynik;
wynosi "<<wynik;
getch();
getch();
return 0;
return 0;
}
}
int suma_kwadratow(int x)
int suma_kwadratow(int x)
{
{
int i, suma=0;
int i, suma=0;
for (i=1;i<=x;i++)
for (i=1;i<=x;i++)
suma+=i*i;
suma+=i*i;
return suma;
return suma;
}
}
Napisz program do obliczania następującej sumy
1
2
+2
2
+3
2
+ ... +n
2
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
e
sekwencyj
ne
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
do
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
to
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