C++ Wykład IV 2006 2007 M Ch

background image

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

background image

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

background image

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ą

background image

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;}

background image

Typ referencyjny -

ograniczenia

ograniczenia

Nie wolno konstruować:

-

referencji do referencji

float

&&rx;

-

wskaźników zmiennych referencyjnych

int

&*wsk_ref;

-

tablic referencji

double

&_ref[100];

background image

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)

background image

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

background image

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

background image

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]

background image

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

background image

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)

background image

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

background image

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

background image

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;

background image

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;

background image

#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;

background image

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

background image

.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

background image

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,

background image

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.

background image

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

background image

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

background image

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

background image

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)
{

}

background image

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)

background image

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) ;

background image

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

background image

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ę

background image

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ść

background image

#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

background image

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;
}

background image

#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

background image

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ę

background image

#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

background image

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

background image

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

background image

#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

background image

// 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;

}

}

}

}

background image

background image

background image

#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

background image

#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

background image

#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

background image

background image

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)

background image

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


Document Outline


Wyszukiwarka

Podobne podstrony:
C++ Wykład III 2006 2007 M Ch
C++ Wykład III 2006 2007 M Ch
Wyklad z ekonomiki 2006-2007, WZ-stuff, semestr 2, nauka o przedsiębiorstwie
Wstęp do socjologii - Wykłady Motak - 2006-2007, Religioznawstwo, Wstęp do socjologii
Wykłady MSG 2006-07, Ekonomia UWr WPAIE 2010-2013, Semestr IV, Miedzynarodowe stosunki gosp, MSG
etyka - wykład IV - 26.10.2006, semestr V
C Wykład IV 2005 2006 s
PWiK - Wykład 05-11-2007, Budownictwo S1, Semestr IV, PWiK, Wykłady, PWiK 2
PWiK - Wykład 13-12-2007, Budownictwo S1, Semestr IV, PWiK, Wykłady, PWiK 2
PWiK - Wykład 15-10-2007, Budownictwo S1, Semestr IV, PWiK, Wykłady, PWiK 2
KPA wyklady 2006-2007, Historia sądownictwa administracyjnego
Międzyszkolne Zawody Matematyczne 2006-2007, Klasa IV(1)
PWiK - Wykład 22-11-2007, Budownictwo S1, Semestr IV, PWiK, Wykłady, PWiK 2
Karta odpowiedzi- Szkolne Zawody 2006-2007, Klasa IV(1)
Wykłady 2006-2007 dr Brygida Kuźniak, PRAWO, ROK 3, Prawo ROK II - semestr I, ORGANIZACJE MIĘDZYNARO

więcej podobnych podstron