Bardzo szybkie podsumowanie: wykład 2

Bardzo szybkie podsumowanie: wykªad 2
wer. 6 z drobnymi mody kacjami!
Wojciech Myszka
2016-05-08 17:54:41 +0200
Uwagi
1. Obowi¡zuje caªy materiaª!
2. Tu tylko podsumowanie.
Funkcje
main
wer. 6 z drobnymi mody kacjami
pierwiastek
lepszy
blisko
Wojciech Myszka
2016-05-08 15:56:16 +0200
Funkcje
1. Funkcje to sposób na podzielenie duzego programu na mniejsze,
ªatwiejsze w zarz¡dzaniu fragmenty.
2. Odpowiedni (umiej¦tny) podziaª programu na moduªy (funkcje)
pozwala na powtórne (i wielokrotne) wykorzystanie ich w innych
programach.
3. Ukrycie pewnych fragmentów pod postaci¡ funkcji pozwala na
uproszczenie struktury programu i uczynienie go bardziej czytelnym.
4. Funkcje to, wreszcie, podstawa programowania strukturalnego.
5. Praktycznie kazdy j¦zyk programowania wyposazony jest
w mechanizmy podziaªu na moduªy oraz tworzenia funkcji (i
procedur).
6. W matematyce pod poj¦ciem funkcji rozumiemy twór, który pobiera
pewn¡ liczb¦ argumentów i zwraca wynik. Je±li dla przykªadu
we¹miemy funkcj¦ sin(x) to x b¦dzie zmienn¡ rzeczywist¡, która
okre±la k¡t, a w rezultacie otrzymamy inn¡ liczb¦ rzeczywist¡
sinus tego k¡ta.
Budowa funkcji
De nicja funkcji wygl¡da w sposób nast¦puj¡cy
typ_powrotu nazwa_funkcji ( d e k l a r a c j a parametr ów )
{
deklaracje i instrukcje
}
1. Funkcja musi by¢ zadeklarowana przed pierwszym jej uzyciem!
2. Funkcja zwraca warto±¢ b¦d¡c¡ wynikiem jej dziaªania.
3. Funkcj¦ wywoªuje si¦ najcz¦±ciej w nast¦puj¡cy sposób:
a = nazwa_funkcji ( parametry f u n k c j i ) ;
zwªaszcza gdy zalezy nam na zapami¦taniu, lub dalszym przetwarzaniu, wyniku
zwracanego przez funkcj¦. Gdy nie jest on potrzebny (istotny) lub funkcja nie zwraca
zadnych wyników mozna wykona¢ tak:
nazwa_funkcji ( parametry f u n k c j i ) ;
W ten sposób najcz¦±ciej wywoªywana jest funkcja printf
4. Jezeli funkcja zwraca jak¡± warto±¢ w±ród instrukcji powinna znale¹¢ si¦ instrukcja
return wyra z enie ;
powoduje ona, ze warto±¢ wyrazenia przypisywana jest jako warto±¢ funkcji!
Budowa funkcji
Najprostsza funkcja
dummy ( )
{
}
I
I
I
Funkcja nie ma parametrów.
Funkcja nie zwraca zadnej warto±ci.
Funkcja nic nie robi
Uzycie:
dummy ( ) ;
Program z funkcj¡
void dummy( void )
{}
i n t main ( )
{
dummy ( ) ;
return ( 0 ) ;
}
Program z funkcj¡
void dummy( void )
{
glupia ( ) ;
}
void g l u p i a ( void )
{}
i n t main ( )
{
dummy ( ) ;
return ( 0 ) ;
}
™le !!!
Program z funkcj¡
void g l u p i a ( void )
{}
void dummy( void )
{
glupia ( ) ;
}
i n t main ( )
{
dummy ( ) ;
return ( 0 ) ;
}
OK !!!
Funkcje zagniezdzone
i n t main ( void )
{
void dummy( void )
{
void g l u p i a ( void ) { }
glupia ( ) ;
}
dummy ( ) ;
return 0 ;
}
™le !!!
Argumenty funkcji
1. Funkcja nie musi mie¢ argumentów.
i n t smieszna ( )
{
return 7 ;
}
i n t smieszna ( void )
{
return 7 ;
}
2. W takim wypadku wywoªanie funkcji ma posta¢:
a = smieszna ( ) ;
Nawiasy musz¡ by¢ nawet jak nie ma argumentów!
Argumenty funkcji
1. Funkcja nie musi mie¢ argumentów.
i n t smieszna ( )
{
return 7 ;
}
i n t smieszna ( void )
{
return 7 ;
}
2. W takim wypadku wywoªanie funkcji ma posta¢:
a = smieszna ( ) ;
Nawiasy musz¡ by¢ nawet jak nie ma argumentów!
Wynik wykonania funkcji
1. Funkcja (na ogóª) zwraca jakie± wyniki.
2. Do przekazania wyników na zewn¡trz funkcji sªuzy
instrukcja return.
3. Program wywoªuj¡cy moze zignorowa¢ zwrócone
wyniki.
4. Gdy funkcja nie zwraca wyników nazywana bywa
procedur¡.
Procedury
1. Procedur¦ deklaruje si¦
w nast¦puj¡cy sposób:
void procedurka ( i n t x )
{
p r i n t f ( "−−−−−−\n " \
" %d \ n " \
"−−−−−−\n " , \
x );
}
2. Procedur¦ wywoªuje si¦
w nast¦puj¡cy sposób:
i n t main ( )
{
i n t z = 123;
procedurka ( z + 7 ) ;
return 1 ;
}
Kompletny program b¦dzie wygl¡daª
tak:
#include < s t d i o . h>
void procedurka ( i n t x )
{
p r i n t f ( "−−−−−−\n " \
" %d \ n " \
"−−−−−−\n " , \
x );
}
i n t main ( )
{
i n t z = 123;
procedurka ( z + 7 ) ;
return 1 ;
}
Procedury
kilka uwag
1. Kazda procedura (jak i funkcja) powinna by¢
zadeklarowana przed pierwszym jej uzyciem.
2. Deklaracja to de nicja albo prototyp (a de nicja pó¹niej).
3. Bardzo wiele procedur systemowych deklarowanych jest
w plikach nagªówkowych.
4. Pliki nagªówkowe powinny by¢ wczytywane na pocz¡tku.
5. Ogólna struktura programu powinna by¢ zatem taka:
I
I
I
wczytanie plików nagªówkowych,
de nicje wszystkich procedur,
program gªówny.
Deklaracja funkcji (prototyp) wygl¡da (jako±) tak:
typ nazwa (parametry i ich typ);
Program z funkcj¡ i prototypy
void g l u p i a ( void ) ;
void dummy( void ) ;
i n t main ( )
{
dummy ( ) ;
return ( 0 ) ;
}
void dummy( void )
{
glupia ( ) ;
}
void g l u p i a ( void )
{}
Teraz kolejno±¢ nie jest juz istotna.
De nicje i deklaracje lokalne
1. Kazda zmienna musi by¢ zadeklarowana.
2. Zmienna dost¦pna jest tylko w bloku, w którym zostaªa
zadeklarowana (i wszystkich blokach w nim zawartych. S¡
to zmienne lokalne.
3. Uwaga: blok to zazwyczaj wszystko co si¦ znajduje
wewn¡trz nawiasów klamrowych { }
4. Deklaracje w blokach nizszych przysªaniaj¡ deklaracje z
bloków wyzszego poziomu.
5. Po wyj±ciu z bloku zmienne lokalne znikaj¡ . S¡
niedost¦pne, a ich zawarto±¢ jest zapominana.
6. Po powrocie do bloku nie ma dost¦pu do poprzedniej
warto±ci zmiennej!
7. Po powrocie do funkcji (w zasadzie) nie ma dost¦pu do
poprzednich warto±ci zmiennych.
De nicje i deklaracje globalne
1. Zmienne zadeklarowane na zewn¡trz
wszystkich moduªów (funkcje,
procedury, funkcja main) nazywane
s¡ zmiennymi globalnymi.
2. Zmienne globalne dost¦pne s¡ we
wszystkich blokach. . .
3. . . . chyba, ze zostan¡ przysªoni¦te
przez de nicj¡ lokaln¡.
4. Zmienne globalne mog¡ by¢
wykorzystanie do przekazywania
dodatkowych wyników zwracanych
przez funkcj¦. Nie jest to najlepsze
rozwi¡zanie. . .
#include < s t d i o . h>
i n t v = 100;
void procedurka ( i n t x )
{
int v = 7;
p r i n t f ( "−−−−−−\n " \
" %d \ n " \
"−−−−−−\n " , \
x );
p r i n t f ( " v = %d \ n " , v ) ;
}
i n t main ( )
{
i n t z = 123;
procedurka ( z + 7 ) ;
procedurka ( v ) ;
return 1 ;
}
Czym si¦ rózni?
int i ;
i n t main ( void )
{
return 1 ;
}
i n t main ( void )
{
int i ;
return 1 ;
}
Funkcja main
1.
2.
3.
4.
Kazdy program w j¦zyku C musi mie¢ segment gªówny.
Segment gªówny musi nazywa¢ si¦ main. . .
. . . i jest funkcj¡!
Warto±¢, któr¡ zwraca funkcja main przekazywana
jest do systemu operacyjnego.
5. Warto±¢ ta zazwyczaj informuje czy program
zako«czyª si¦ z bª¦dami i, czasami, o typie (rodzaju)
bª¦du.
6. Standardowe kody zako«czenia programu
zde niowane s¡ w pliku nagªówkowym stdlib.h s¡ to
#define
#define
EXIT_FAILURE
EXIT_SUCCESS
1
0
/∗ F a i l i n g e x i t s t a t u s . ∗/
/∗ S u c c e s s f u l e x i t s t a t u s . ∗/
7. Kazdy segment gªówny powinien si¦ ko«czy¢
poleceniem return.
Funkcja main
1. To jest wªa±ciwie poprawny program w j¦zyku C
void main ( void )
{
;
}
Nic nie robi, nie zwraca zadnej informacji. Kompilator sygnalizuje
komunikat warning: return type of `main' is not `int '
2. Zamiana pierwszego void na int
i n t main ( void )
{
;
}
powoduje komunikat warning: control reaches end of non-void
function
3. Poprawny program powinien wygl¡da¢ jako± tak:
i n t main ( void )
{
return 0 ;
}
Rekurencja
1. Przypadek gdy funkcja (lub procedura) wywoªuje
sam¡ siebie nazywamy rekurencj¡.
2. Nie potra ¦ powiedzie¢, czy rekurencja to dobra czy
zªa technika programowania.
3. Rekurencja byªa bardzo pozyteczna podczas
tworzenia algorytmów.
4. W realizacjach programowych (zwªaszcza bardzo
skomplikowanych problemów) stwarza wiele
kªopotów.
5. Problemy wynikaj¡ z konieczno±ci przechowania
wszystkich argumentów i caªej struktury danych
uzywanej przez funkcj¦ gdy wywoªuje ona sam¡
siebie.
Rekurencja
Silnia
schemat blokowy
silnia
N
n==0
return n *
silnia(n-1)
T
return 1
Koniec
Rekurencja
Silnia
# include < s t d i o . h>
# include < s t d l i b . h>
float s i l n i a ( int n)
{
i f ( n == 0 )
return 1 . ;
else
return n ∗ s i l n i a ( n −1);
}
i n t main ( i n t cnt , char ∗∗ arg )
{
int n;
n= a t o l ( arg [ 1 ] ) ;
p r i n t f ( " %d ! = %g \ n " , n , s i l n i a ( n ) ) ;
return 0 ;
}
Ci¡g Fibonacciego
Rekurencja
Fn :=



0



1
Fn−1 + Fn−2
dla n = 0
dla n = 1
dla n > 1.
Ci¡g Fibonacciego
Rekurencja
# include
unsigned
unsigned
{
k ++;
if (
}
< s t d i o . h>
long i n t k ;
long i n t f i b ( i n t n )
n == 0 )
return 0 ;
e l s e i f ( n == 1 )
return 1 ;
else
return f i b ( n − 1 ) + f i b ( n − 2 ) ;
i n t main ( i n t argc , char ∗∗ ar gv )
{
i n t n , m;
f o r ( n = 0 ; n < 100; n++ )
{
k = 0;
m = fib (n);
p r i n t f ( " %lu , %lu , % l u \ n " , n , m, k ) ;
}
return 0 ;
}
Idea programowania strukturalnego
Metoda Newtona-Raphsona: pierwiastek dowolnego stopnia
Zaªózmy, ze mamy wyznaczy¢ pierwiastek stopnia n
z liczby w, czyli znale¹¢ tak¡ liczb¦ x, ze:
lub inaczej:
xn = w
(1)
xn − w = 0
(2)
Jezeli oznaczymy f(x) = xn − w to zadanie to mozna
zapisa¢ ogólniej: nalezy znale¹¢ takie x, ze f(x) = 0.
Idea programowania strukturalnego
Metoda Newtona-Raphsona: pierwiastek dowolnego stopnia
Jezeli zadanie dodatkowo upro±cimy zakªadaj¡c:
I funkcja ma dokªadnie jedno miejsce zerowe,
I jest rózniczkowalna,
I jej pochodna w caªym przedziale jest albo dodatnia
albo ujemna;
to mozemy naszkicowa¢ nast¦puj¡cy rysunek ilustruj¡cy
nasze zadanie:
Idea programowania strukturalnego
Metoda Newtona-Raphsona: pierwiastek dowolnego stopnia
f(g)
g
g’
g’’
Idea programowania strukturalnego
Metoda Newtona-Raphsona: pierwiastek dowolnego stopnia
Zaczynamy w punkcie g; warto±¢ funkcji w tym punkcie
wynosi f(g). Musimy w jaki± sposób zdecydowa¢ w którym
kierunku nalezy wykona¢ nast¦pny krok. Zauwazmy, ze
mozemy w tym celu wykorzysta¢ pochodn¡ (czerwona,
przerywana linia na poprzednim rysunku). Jezeli
przyblizymy funkcj¦ za pomoc¡ pochodnej (stycznej do
funkcji, przechodz¡cej przez punk (g, f(g) to nast¦pnym
przyblizeniem b¦dzie punkt przeci¦cia stycznej z osi¡ x.
Idea programowania strukturalnego
Metoda Newtona-Raphsona: pierwiastek dowolnego stopnia
Z równania prostej mamy:
czyli
f(g) − 0
= f 0 (g)
0
g−g
(3)
f(g)
= g − g0
f 0 (g)
(4)
f(g)
f 0 (g)
(5)
i dalej
g0 = g −
Idea programowania strukturalnego
Metoda Newtona-Raphsona: pierwiastek dowolnego stopnia
Jezeli zauwazymy, ze f(x) = xn − w oraz, ze f 0 (x) = nxn−1 to kolejne
przyblizenie wyliczane b¦dzie ze wzoru:
g0 = g −
gn − w
ngn−1
(6)
albo
ngn − gn + w
(n − 1)gn + w
1
w
g =
=
=
(n − 1)g + n−1
ngn−1
ngn−1
n
g
0
Gdy n = 2, wówczas
!
1
w
g =
g+
.
2
g
0
!
(7)
(8)
Umawiamy si¦, ze program ko«czy prac¦ gdy kolejna poprawka g0 nie
rózni si¦ zbytnio od poprzednio wyliczonej warto±ci g, czyli |g − g0 | < ε.
Idea programowania strukturalnego
Realizacja programowa
Program b¦dzie si¦ skªadaª z trzech cz¦±ci:
1. blisko(g, gprim) funkcja o warto±ciach logicznych
sprawdzaj¡ca czy |g − g0 | ≤ ε,
2. lepszy(n, w, g) funkcja rzeczywista wyliczaj¡ca
nast¦pne, lepsze przyblizenie pierwiastka,
3. pierwiastek(n, w, g) funkcja (rzeczywista)
wyliczaj¡ca pierwiastek stopnia n z w zaczynaj¡c od
przyblizenia g.
Uwaga: Dalszy przykªad zakªada n = 2
Realizacja programowa
lepszy(w, g)
Start
lepszy =
0.5*(g+w/g)
Koniec
Realizacja programowa
blisko(g, gprim)
Start
T
abs(g-gprim)
<=
EPSILON
blisko
= TRUE
N
blisko
= FALSE
Koniec
Realizacja programowa
pierwiastek(w, g)
Start
gprim
= lepszy(w,g)
T
blisko (g,
gprim)
F
pierwiastek
= pierwiastek (w,
gprim)
pierwiastek
= gprim
Koniec
Realizacja programowa
Program gªówny
Start
wprowad¹
w
ustal 1.
przyblizenie g
wynik =
pierwiastek(w, g)
wydrukuj
wynik
Koniec
Metoda Newtona
Realizacja programowa
Program skªada si¦ z trzech cz¦±ci:
1. blisko(g, gprim) funkcja o warto±ciach logicznych
sprawdzaj¡ca czy |g − g0 | ≤ ε,
2. lepszy(n, w, g) funkcja rzeczywista wyliczaj¡ca
nast¦pne, lepsze przyblizenie pierwiastka,
3. pierwiastek(n, w, g) funkcja (rzeczywista)
wyliczaj¡ca pierwiastek stopnia n z w zaczynaj¡c od
przyblizenia g.
Uwaga: Dalszy przykªad zakªada n = 2
Realizacja programowa
lepszy(w, g)
Start
lepszy =
0.5*(g+w/g)
Koniec
double l e p s z y ( double w, double g )
{
return 0.5 ∗ ( g + w/g ) ;
}
Metoda Newtona
blisko(g, gprim)
Start
T
abs(g-gprim)
<=
EPSILON
blisko
= TRUE
N
blisko
= FALSE
Koniec
i n t b l i s k o ( double g ,
\
double gprim )
{
return f a b s ( g − gprim ) \
< EPSILON ;
}
Metoda Newtona
pierwiastek(w, g)
Start
gprim
= lepszy(w,g)
T
blisko (g,
gprim)
F
pierwiastek
= pierwiastek (w,
gprim)
pierwiastek
= gprim
Koniec
double p i e r w i a s t e k ( double w, \
double g )
{
double gprim ;
gprim = l e p s z y (w, g ) ;
i f ( b l i s k o ( g , gprim ) )
return gprim ;
else
return p i e r w i a s t e k (w, \
gprim ) ;
}
Metoda Newtona
Program gªówny
Start
wprowad¹
w
ustal 1.
przylizenie g
wynik =
pierwiastek(w, g)
wydrkuj
wynik
Koniec
i n t main ( void )
{
double w, g , wynik ;
w = 2.;
g = 1.;
wynik = s q r t f (w) ;
p r i n t f ( " % f \ n " , wynik ) ;
wynik = p i e r w i a s t e k (w, g ) ;
p r i n t f ( " P i e r w i a s t e k kwadratowy z l i c z b y " \
" % f wynosi % f \ n " , w, wynik ) ;
return 0 ;
}
Metoda Newtona-Raphsona
Zadanie domowe
1. Narysowa¢ schemat blokowy dla dowolnego n
(wszystko to co byªo to byªo dla n = 2.
2. Napisa¢ program (w C) realizuj¡cy ten schemat
blokowy.
Tablice (tablice jedno
i wielowymiarowe), ªa«cuchy znaków
wer. 7 z drobnymi mody kacjami
Wojciech Myszka
2016-05-08 15:57:12 +0200
Zmienne
Przypomnienie/podsumowanie
1. Wszystkie zmienne musz¡ by¢ zadeklarowane.
2. Nazwa zmiennej skªada si¦ z liter i cyfr, a rozpoczyna
si¦ liter¡; znak podkre±lenia zalicza si¦ do liter.
3. Nazwy zmiennych nie powinny si¦ zaczyna¢ od znaku
podkre±lenia (tak nazywaj¡ si¦ zmienne systemowe).
4. Deklaracja obowi¡zuje wewn¡trz bloku (i we
wszystkich blokach znajduj¡cych si¦ nizej ).
5. W C wyst¦puj¡ zmienne globalne (zewn¦trzne)
i lokalne.
6. Deklaracja lokalna przysªania deklaracj¦ globaln¡
(jezeli nawa zmiennej jest taka sama).
Tablice
1. Gdy potrzebujemy przechowa¢ kilka zmiennych tego
samego typu (i jako± powi¡zanych ze sob¡) stosujemy
tablic¦.
2. Tablica to ci¡g zmiennych o tej samej nazwie; dost¦p
do poszczególnych elementów odbywa si¦ przez
podanie numeru zmiennej (indeksu).
0 1 2 3 4 5 6 7 8 9
3. Elementy numerowane s¡ pocz¡wszy od zera.
4. Deklaracja wygl¡da tak:
typ nazwa_tablicy[rozmiar];
Tablice
1. Tablica jest zmienn¡ zªozon¡ (struktur¡ pewnego rodzaju).
2. Sªuzy do przechowywania danych tego samego typu.
3. Jezeli chcemy nada¢ elementom tablicy warto±ci
pocz¡tkowe
int tablica[3] = {1,2,3};
4. To jest równiez poprawna deklaracja:
int tablica[20] = 1,;
(pierwszy element tablicy ma warto±¢ 1, pozostaªe maj¡
warto±¢ 0)
5. Nie zawsze trzeba podawa¢ rozmiar tablicy czasami
kompilator moze si¦ domy±li¢ sam:
int tablica[] = 1, 2, 3, 4, 5;
zostanie zadeklarowana tablica o pi¦ciu elementach.
Wielko±¢ tablic
1
2
3
4
5
6
7
8
9
#include < s t d i o . h>
i n t main ( void )
{
int t [ ] = {1 , 2 , 3 , 4 , } ;
int i ;
f o r ( i = −1; i < 7 ; i ++)
p r i n t f ( " t [%d ] = %d \ n " , i , t [ i ] ) ;
return 0 ;
}
Ile elementów ma tablica t?
Wykonany po raz pierwszy
t[-1] = 11131
t[0] = 1
t[1] = 2
t[2] = 3
t[3] = 4
t[4] = -1296194160
t[5] = 32767
t[6] = 0
Wykonany po raz drugi
t[-1] = 10955
t[0] = 1
t[1] = 2
t[2] = 3
t[3] = 4
t[4] = -868000288
t[5] = 32767
t[6] = 0
Wykonany po raz trzeci
t[-1] = 11015
t[0] = 1
t[1] = 2
t[2] = 3
t[3] = 4
t[4] = -143761264
t[5] = 32767
t[6] = 0
Zmienne zewn¦trzne i wewn¦trzne
# include < s t d i o . h>
i n t a ; // <−−− Zmienna zewnetrzna
i n t main ( void )
{
i n t b ; // <−−− Zmienna wewnetrzna
...
Zmienne zewn¦trzne nazywane bywaj¡ zmiennymi
globalnymi (czyli dost¦pnymi dla kazdej funkcji
programu).
Zmienne statyczne i automatyczne
Troch¦ zam¦tu
1. Dodatkowo mozna zaz¡da¢ od zmiennej zeby byªa statyczna
(co deklaruje si¦ dodaj¡c sªowo kluczowe static przed nazw¡
typu).
static int x;
2. Zmienna statyczna zewn¦trzna pozostaje zde niowana tylko dla
funkcji zde niowanych w jednym pliku ¹ródªowym (ukryta jest
dla funkcji z innych plików ¹ródªowych).
3. Zmienna statyczna wewn¦trzna zachowuje swoj¡ warto±¢
pomi¦dzy kolejnymi wywoªaniami funkcji.
4. Zmienne, które nie s¡ statyczne nie musz¡ zachowywa¢
warto±ci mi¦dzy wej±ciami do funkcji (ale mog¡) nie mozna
na to liczy¢!
5. Dodatkowo zmienne statyczne wewn¦trzne inicjowane s¡ na
warto±¢ zero (jezeli programista nie zaz¡da zeby byªo inaczej).
Zmienne statyczne i automatyczne
# include < s t d i o . h>
void f ( void )
{
s t a t i c i n t x ; /∗ zmienna s t a t y c z n a ∗/
int y = 0;
/∗ zmienna automatyczna ∗/
x ++;
y ++;
p r i n t f ( " X=%d , Y=%d \ n " , x , y ) ;
}
i n t main ( )
{
f ();
f ();
f ();
return 0 ;
}
Inicjowanie I
1. W deklaracji obiektu mozna zawrze¢ warto±¢
pocz¡tkow¡ deklarowanego identy katora.
2. Inicjator, który poprzedza si¦ operatorem = jest albo
wyrazeniem, albo list¡ inicjatorów zawart¡
w nawiasach klamrowych.
3. Lista moze ko«czy¢ si¦ przecinkiem.
4. Dla obiektów i tablic statycznych wszystkie wyrazenia
w inicjatorach musz¡ by¢ wyrazeniami staªymi.
5. Nie inicjowany jawnie obiekt statyczny jest
inicjowany tak, jakby jemu, (lub jego skªadowym)
przypisano warto±¢ zero.
Inicjowanie II
6. Pocz¡tkowa warto±¢ nie zainicjowanego jawnie
obiektu automatycznego jest niezde niowana.
7. Inicjatorem dla obiektu arytmetycznego jest
pojedyncze wyrazenie (by¢ moze uj¦te w nawiasy
klamrowe).
8. Inicjatorem dla struktury jest albo wyrazenie tego
samego typu albo uj¦ta w nawiasy klamrowe lista
inicjatorów dla jej kolejnych skªadowych.
9. Inicjatorem dla tablicy jest uj¦ta w klamry lista
inicjatorów dla jej kolejnych elementów.
10. Je±li nie jest znany rozmiar tablicy to rozmiar ten
wylicza si¦ na podstawie liczby inicjatorów.
Inicjowanie III
11. Je±li tablica ma ustalony rozmiar liczba inicjatorów
nie moze przekroczy¢ liczby elementów tablicy; je±li
lista jest krótsza uzupeªniana jest zerami.
12. Specjalnym przypadkiem jest tablica znakowa, która
moze by¢ inicjowana napisem (kolejne znaki napisu
inicjuj¡ kolejne elementy tablicy).
13. Jezeli nie jest znany rozmiar tablicy znakowej jest on
wyliczany na podstawie liczby znaków w napisie
(wª¡czaj¡c w to ko«cowy znak zerowy).
Tablice wielowymiarowe
Przykªad
#include < s t d i o . h>
i n t main ( void )
{
int a [4][3] = {
{1 , 3 , 5} ,
{2 , 4 , 6} ,
{3 , 5 , 7} ,
};
int i , j ;
for ( i = 0; i < 4; i ++){
f o r ( j = 0 ; j < 3 ; j ++)
p r i n t f ( " %d | " , a [ i ] [ j ] ) ;
printf ( " \n" );
}
return 0 ;
}
Tablice wielowymiarowe
Wynik dziaªania programu
1
2
3
0
|
|
|
|
3
4
5
0
|
|
|
|
5
6
7
0
|
|
|
|
Tablice wielowymiarowe
Zadanie domowe
Zmody kowa¢ tak przykªadowy progam, zeby drukowaª
wyniki w nast¦puj¡cej postaci:
|
|
|
|
1
2
3
0
|
|
|
|
3
4
5
0
|
|
|
|
5
6
7
0
|
|
|
|
Tablice wielowymiarowe
Inicjowanie
warianty
int a [4][3] = {
1, 3, 5, 2, 4, 6, 3, 5, 7
};
1
2
3
0
|
|
|
|
3
4
5
0
|
|
|
|
5
6
7
0
|
|
|
|
Tablice wielowymiarowe
Inicjowanie
warianty
int a [4][3] = {
{ 1 }, { 2 }, { 3 }, { 4 }
};
1
2
3
4
|
|
|
|
0
0
0
0
|
|
|
|
0
0
0
0
|
|
|
|
Napisy
1. Staªa znakowa (zªozona z jednego znaku) zapisywana jest tak
’c’ ( c to dowolny znak lub specjalna staªa zªozona ze znaku
backslash (\) i specjalnego symbolu.
2. Staªa tekstowa zapisywana jest w cudzysªowach (podwójne
apostrofy) "Ala ma kota"
3. S¡siaduj¡ce ze sob¡ napisy ª¡czone s¡ w jeden napis
("Ala" "ma" "kota" tworzy napis "Alamakota";
"Ala " "ma" " kota" tworzy "Ala ma kota").
4. Na ko«cu napisu umieszczany jest znak null ('\x00') pozwalaj¡cy
rozpozna¢ koniec tekstu.
5. W napisach mozna uzywa¢ wszystkich symboli specjalnych
dost¦pnych w staªych znakowych.
6. Typem do przechowywania znaków jest char.
7. Napisy trzeba przechowywa¢ w tablicach typu char.
8. Polskie znaki na razie proponuj¦ o tym zapomnie¢!
Tablice znakowe
To jest poprawna deklaracja. Tablica b¦dzie miaªa rozmiar 14 (13 znaków napisu
i znak null ko«cz¡cy napis). Mozna to sprawdzi¢ za pomoc¡ funkcji sizeof(tekscik).
char t e k s c i k [ ] = " Ala ma k o t a l a " ;
Ponizej równiez poprawna deklaracja tablicy (o ª¡cznym rozmiarze 21 znaków).
Liczba wierszy wyliczana jest automatycznie podczas kompilacji.
char t e k s t y [ ] [ 7 ] = {
{ " Ala " } ,
{ "ma" } ,
{ " kotala " }
};
To niepoprawna forma deklaracji:
char t e k s t y [ 3 ] [ ] = {
{ " Ala " } ,
{ "ma" } ,
{ " kotala " }
};
Tablice jako argumenty funkcji
1. Trzeba bardzo uwaza¢ i my±le¢ zanim si¦ co± zrobi!
2. Wi¦cej o tym b¦dzie pó¹niej!