20:30 <@adam_i`2> ----------------------------------------------------------czesc 3 ----------------------------------------------------
20:30 <@Gynvael> dobra
20:30 <@j00ru> etc
20:30 <@Gynvael> bede za 2 min
20:30 <@phoenix__> !time
20:30 <@j00ru> bubel: zdrjca!
20:30 -phoe:#gynkurs- 20:29:06
20:30 <@bubel> no wlasnie Gynvael czy to jest dobra idea?
20:30 <@Gynvael> u mnie 20:28 ;p
20:30 <@Gynvael> bubel: tzn ?
20:30 <@phoenix__> Gyn zle ci zegar chodzi'
20:30 <@bubel> ekhm
20:30 <@bubel> nvm
20:30 <@d0b0c0p> u mnie 30
20:30 <@phoenix__> no dobra !time
20:30 -phoe:#gynkurs- 20:29:26
20:30 <@bubel> j00ru: ty bestio szatana
20:30 <@mati_> nie prawda
20:30 <@mati_> !
20:30 <@mati_> ;]
20:30 <@bubel> idz i sie powies!:p
20:30 <@mati_> +3min
20:30 <@mati_> dobra 2
20:31 <@mati_> roznica czasowa
20:31 -!- Mr_gh0st was kicked from #gynkurs by Mr_gh0st [w wielkim stylu ;)]
20:31 -!- mode/#gynkurs [+m] by phoenix__
20:31 <@j00ru> ehh
20:31 <@j00ru> bubel: nie potrafie sie porozumiec
20:31 -!- kiero [avalanche@host-81-190-204-245.gorzow.mm.pl] has joined #gynkurs
20:31 -!- mode/#gynkurs [+o kiero] by phoe
20:31 <@j00ru> z ta dzisiejsza mlodzieza
20:31 <@bubel> j00ru: ekhm ja ciebie nie znam ;p
20:31 <@mati_> :>
20:31 <@j00ru> jacys tacy hamscy
20:31 <@seraphin_> hehehehhehe
20:31 <@bubel> chamscy :PPP
20:31 <@kiero> jol
20:31 <@j00ru> bubel: wiem, ja cie tez nie
20:31 <@seraphin_> mlodzieza :P
20:31 <@kiero> kiedy wyklad? :>
20:31 <@seraphin_> dobre sobie ;p
20:32 <@bubel> no wiec co biadolisz 3 po 3 ;p
20:32 <@j00ru> bubel: ale twoj nick mowi sam za siebie
20:32 <@bubel> j00ru: ?
20:32 <@seraphin_> j00ru: prv
20:32 <@phoenix__> Gynvael: ja juz od 20.15 mam konsolke wlaczona
20:32 <@phoenix__> dobra zaczynaj
20:32 <@phoenix__> !time
20:32 -phoe:#gynkurs- 20:31:10
20:32 <@Gynvael> ok
20:32 <@j00ru> bubel: nvm, proponuje zawieszenie broni
20:32 <@Gynvael> ;>
20:32 <@Gynvael> wiec csiii ;>
20:32 <@phoenix__> ------------------------------------ czesc 3 ----------------------------------------------
20:32 <@bubel> dobra zamknac ryje!
20:32 <@bubel> bubel mowi
20:32 <@bubel> Gynvael: a wiec pytalem sie:
20:32 <@d0b0c0p> pfff
20:33 <@bubel> 20:29 <@bubel> Gynvael: wiec tak czy dobre jest to:
20:33 <@bubel> 20:29 <@j00ru> dobra bubelku
20:33 <@bubel> 20:29 <@j00ru> ja musze cie opuscic
20:33 <@bubel> 20:29 <@bubel> Gynvael ja sie za pare miechow wezme za c, jak sie naucze php, sql, js
20:33 <@phoenix__> ------------------------------------------------------------------------- czesc 3 -------------------------------------------------------------- Gyn MOWI i CICHO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
20:33 <@bubel> qrwa mac 
20:33 <@bubel> ja mowie
20:33 <@bubel> !
20:33 <@Gynvael> hehe jeszcze odpowiem bubelowi tylko ;>
20:33 <@Gynvael> taki spragniony odpowiedzi ;>
20:33 <@Gynvael> i zaczynami ;>
20:33 <@bubel> no ;>
20:33 <@d0b0c0p> ciiiiiiii
20:33 <@Gynvael> bubel: pytasz czy dobrze jest zaczac od php/js ?
20:34 <@Gynvael> bubel: a potem dopiero C ?
20:34 <@bubel> nie
20:34 <@Gynvael> a o... ?
20:34 <@bubel> pytam czy dobre jest wyznaczac ze naucze sie tego
20:34 <@bubel> potem tego
20:34 <@bubel> i tego
20:34 <@Gynvael> ;>
20:34 <@bubel> za pare miechoow
20:34 <@Gynvael> czemu nie ;>
20:34 <@Gynvael> jak czlowiek ma cel
20:34 <@Gynvael> jest mu latwiej
20:34 <@Gynvael> ;>
20:34 <@bubel> czy skakanie
20:34 <@bubel> z kwiatka na kwiatek
20:34 <@bubel> to dobre jest
20:34 <@bubel> takie zadaje pytanie
20:34 <@Gynvael> skakanie uczy wielu spojrzen na jeden problem
20:34 <@bubel> i sie zegnam ;>
20:34 <@d0b0c0p> ciiii
20:35 <@phoenix__> ************************************ czesc 3 *************************************** 
20:35 <@adam_i`2> Ma to swoje wady I zalety
20:35 <@Gynvael> siedzac tylko w C znasz C, ale jesli skoczysz na inny jezyk na chwile, spojrzysz na C z innej strony
20:35 <@d0b0c0p> to jest gyn kursa
20:35 <@d0b0c0p> tfu
20:35 <@d0b0c0p> kurs gyna ;p
20:35 <@Gynvael> i byc moze cie to nauczy czegos
20:35 <@d0b0c0p> ale wyszlo
20:35 <@phoenix__> CICHO CICHO !!!!!!!!!!!!!!!|
20:35 <@d0b0c0p> "gyn kursa" rotfl
20:35 <@phoenix__> Gyn zaczynaj 
20:35 <@Gynvael> imho nie mozna siedziec non stop na jednym jezyku
20:35 <@Gynvael> ok
20:35 <@Gynvael> wiec zaczynam ;>
20:35 <@Gynvael> czesc 3 ;>
20:35 <@phoenix__> ---------------------- czesc 3 -----------start -----------------
20:35 <@Gynvael> Witam wiec wszystkich 
20:35 <@Gynvael> na czesci 3ciej mojego skromnego kursu poswieconego podstawa jezyka C
20:36 <@Gynvael> poprzednie dwie czesci ktore sciagnely az 17 osob byly o:
20:36 <@Gynvael> - hello world, czyli skladania C i jak zaczac
20:36 <@Gynvael> oraz
20:36 <@Gynvael> - zmienne i ich wypisywanie
20:36 <@Gynvael> oraz wzmianka byla
20:37 <@Gynvael> o formatowaniu w printf, ASCII oraz return code'ach w main
20:37 <@Gynvael> dzisiejsza lekcja bedzie poswiecona funkcja
20:37 <@Gynvael> glownie beda to proste funkcje ktore chcemy napisac
20:37 <@Gynvael> prawdopodobnie przewinie sie jakis "if", czyli tzw instrukcja warunkowa
20:38 <@Gynvael> a na koniec dla zaawansowanych jesli jacys beda zainteresowani
20:38 <@Gynvael> powiem o funkcjach z nieokreslona badz dowolna liczba argumentow
20:38 <@Gynvael> oraz o sposobach odczytu i identyfikacji tychze argumentow/parametrow
20:38 <@Gynvael> ok
20:38 <@Gynvael> zaczynamy wiec
20:38 <@Gynvael> najpierw 3 slowa o funkcji ktora juz znamy
20:38 <@Gynvael> jest to mianowicie glowna-startujaca funkcja, czyli "main
20:38 -!- d9k [criptin@cfl52.neoplus.adsl.tpnet.pl] has joined #gynkurs
20:38 -!- mode/#gynkurs [+o d9k] by phoe
20:38 <@Gynvael> "main"
20:38 -!- Blizzus [blizzard@frycek.net] has joined #gynkurs
20:39 -!- mode/#gynkurs [+o Blizzus] by phoe
20:39 -!- xaos_ [xaos@host-81-190-204-245.gorzow.mm.pl] has joined #gynkurs
20:39 -!- mode/#gynkurs [+o xaos_] by phoe
20:39 <@Gynvael> deklaracja funkcji sklada sie z nastepujacych czesci:
20:39 <@Necrium> Gynvael: o funkcjach z nieokreslona badz dowolna liczba arguemtnow powiedzial bys takze cos o pascalu ?
20:39 <@Gynvael> TYP NAZWA(ARGUMENTY...)
20:39 -!- Blizzard [blizzard@l33t.zief.pl] has quit ["leaving"]
20:39 <@Gynvael> Necrium: ne, dzisiaj tylko C ;>
20:39 <@salv4tion> co :|
20:39 -!- Nekrataal [~Nekrataal@dfy82.neoplus.adsl.tpnet.pl] has joined #gynkurs
20:39 -!- mode/#gynkurs [+o Nekrataal] by phoe
20:39 <@salv4tion> omg
20:39 <@salv4tion> soiznilem sie ;p sory
20:39 <@Necrium> eee ;D
20:39 <@Gynvael> ok csii csii
20:39 <@phoenix__> CIIIII
20:39 <@Gynvael> wiec
20:40 <@Gynvael> -=203647=- <@Gynvael> TYP NAZWA(ARGUMENTY...)
20:40 -!- Blizzard [blizzard@l33t.zief.pl] has joined #gynkurs
20:40 <@Gynvael> w przypadku funkcji main sa to:
20:40 -!- mode/#gynkurs [+o Blizzard] by phoe
20:40 <@Gynvael> int main(void)
20:40 -!- mode/#gynkurs [+i] by mati_
20:40 <@Gynvael> int jest TYPEM ZWRACANYM
20:40 <@Gynvael> jak wiemy z doswiadczenia badz wczorajszej lekcji
20:40 <@Gynvael> jest to 4ro bajtowy typ calkowity
20:40 <@Gynvael> majacy zasieg od -2G do 2G (mniej wiecej)
20:40 <@Gynvael> main jest NAZWA funkcji
20:41 <@Gynvael> nazwa moze sie skladac z duzych liter, malyc liter, znaku _
20:41 <@Gynvael> oraz cyfr, POD WARUNKIEM ZE NIE SA ONE PIERWSZYM ZNAKIEM FUNKCJI
20:41 <@Gynvael> przykladowe poprawne nazwy to:
20:41 <@Gynvael> main
20:41 <@mati_> - a void?
20:41 <@Gynvael> aLaMaKoTa
20:41 <@Gynvael> (mati: po kolei ;>)
20:41 <@Gynvael> _
20:41 <@Gynvael> funkcja_3D
20:42 <@Gynvael> natomiast nieprawidlowymi sa:
20:42 <@Gynvael> 1234
20:42 <@Gynvael> 123_
20:42 <@Gynvael> !#%!@$
20:42 <@Gynvael> etc
20:42 <@Gynvael> dodatkowo
20:42 <@Gynvael> nazwa funkcji i zmiennej nie moga byc SLOWA KLUCZOWE
20:42 <@Gynvael> sa to NAZWY TYPOW ZMIENNYCH, oraz ze znanych narazie slowo "return"
20:42 <@Gynvael> nastepnie w nawiasie sa argumetny funkcji
20:42 <@Gynvael> int main(void)
20:42 <@Gynvael> void - proznia, nicosc (eng)
20:43 <@Gynvael> oznacza w C BRAK ARGUMENTOW
20:43 <@Gynvael> w jezyku C zadne inne oznaczenie nie oznacza braku argumentow
20:43 <@Gynvael> jest to jedna z roznic miedzy jezykiem C a C++
20:43 <@Gynvael> w C++ mozna bylo brak argumentow oznaczyc przez (), np int main()
20:43 <@Gynvael> natomiast w C () jest oznaczenie NIEOKRESLONEJ ILOSCI ARGUMENTOW, ale o tym w czesci dla zaawansowanych
20:44 <@Gynvael> czasami spotyka sie deklaracje main:
20:44 <@Gynvael> void main(void)
20:44 <@d0b0c0p> ble
20:44 <@Gynvael> jednak z punktu windzenia programowania jest to NIEPOPRAWNA definicja, z uwagi na BRAK MOZLIWOSCI ZWROCENIA ODPOWIEDZI (return code) DO SYSTEMU O POPRAWNOSCI WYWKONANIA PROGRAMU
20:44 <@Gynvael> wiec nie nalezy jej stosowac
20:45 <@mati_> -[ nie pier... do mnie jak Balcerowicz, mow do mnie po ludzku] :P
20:45 <@mati_> :s
20:45 <@Gynvael> (main ma rowniez inne formy, ale narazie zapoznajmy sie dokladnie z int main(void))
20:45 <@d0b0c0p> mati_: ciii
20:45 <@Gynvael> teraz troche brzytkiej terminologii
20:45 <@Gynvael> ktorej nikt nie lubi
20:45 <@Gynvael> albo nie
20:45 <@Gynvael> najpierw przyklad funkcji
20:46 <@Gynvael> http://gynvael.vexillium.org/gk3_1.c
20:46 <@Gynvael> sciagnijcie i skompilujcie
20:46 <@Gynvael> gcc gk3_1.c -o gk3_1 -Wall -pedantic
20:46 <@mati_> ;ss
20:46 <@d0b0c0p> kazdy musi komplikowac?
20:46 <@bubel> Gynvael: powiedz im dlaczego tam jest void
20:46 <@mati_> daj cos mocniejszego
20:47 <@Gynvael> csiii
20:47 <@bubel> bo mowiles ze tego sie nie stosuje
20:47 <@Gynvael> pytania jak powiem ze pytania
20:47 <@mati_> ja robilem inaczej w c
20:47 <@Gynvael> bubel: nie stosuje do main ;>
20:47 <@bubel> no teraz lepiej ;>
20:47 <@Gynvael> mati_: CSIIIIII
20:47 <@Gynvael> a
20:47 <@Gynvael> ok
20:47 <@phoenix__> CISZA!!!!!!!!
20:47 <@Gynvael> przypomnienie zasad ;>
20:47 <@Gynvael> bo pare nowych osob jest ;>
20:47 <@mati_> Gynvael: deop all +m
20:47 <@mati_> tyle.
20:47 <@Gynvael> kazdy ma opa, ale to tak zebysmy sie nie czuli jak w obozie koncentracyjnym
20:48 <@Gynvael> w momencie kiedy na kanale jest flaga +m, jestescie cicho, a ja nawijam swoje ;>
20:48 <@Gynvael> jak bedzie pora na pytania, to zdejmuje -m ;>
20:48 <@bubel> a ops
20:48 <@Gynvael> i wtedy zalewacie mnie pytaniami ;>
20:48 -!- mode/#gynkurs [-o bubel] by bubel
20:48 <@Gynvael> jesli to nie wyjdzie to zrobimy jak mi pare osob proponuje, czyli -o wszystkim ;>
20:48 <@Gynvael> ale jak mowilem, to nie ma byc oboz koncentracyjny ;>
20:48 <@Gynvael> ok
20:48 <@Gynvael> wiec nawijam dalej ;>
20:49 <@Blizzard> wczoraj bylo git;)
20:49 <@Gynvael> tak, jedyna osoba ktora wczoraj mi przerywala byl Blizzard  ;pppp
20:49 <@Gynvael> hehehe ok, csiii juz ;>
20:49 <@Gynvael> wiec, precyzujac to czego bubel sie przyczepil
20:49 <@Necrium> ok :-)
20:49 <@Gynvael> tym zwracany "void" NIE POWINIEN BYC UZYWANY PRZY FUNKCJI "main"
20:49 <@Gynvael> przy wszytkich innych funkcjach moze byc, zgodnie z naszym widzimisie, ale nie musi
20:50 <@Gynvael> ok
20:50 <@Gynvael> teraz tak
20:50 <@Gynvael> przy kompilacji doszly dwie nowe flagi
20:50 <@Gynvael> ktorych wczoraj nie uzywalem
20:50 <@Gynvael> mianowiscie -Wall -pedantic
20:50 <@Gynvael> sa to flagi ktore powinien uzywac KAZDY programista kompilujacy gcc
20:50 <@Gynvael> -Wall -pedantic powoduja WYSWIETLENIE OSTRZEZEN O WSZYSTKICH NIEPEWNYCH DLA KOMPILATORA RZECZACH UZYTYCH W KODZIE
20:51 <@Gynvael> dzieki temu latwiej wysledzic wszystkie bledy
20:51 <@Gynvael> i je usunac
20:51 <@Gynvael> oraz uczy to porzadnego pisania ;>
20:51 <@Gynvael> a nie na lapu-capu ;>
20:51 <@Gynvael> ok
20:51 <@Gynvael> wracajac do kodu
20:51 <@Gynvael> przykladu ;>
20:51 <@Gynvael> po kompilacji mozemy odpalic
20:51 <@Gynvael> i zobaczymy:
20:52 <@Gynvael> root@yume:/code/kurs# ./gk3_1 
20:52 <@Gynvael> Jestem main()
20:52 <@Gynvael> Jestem moja_funkcja();
20:52 <@Gynvael> cos takiego
20:52  * d0b0c0p zw :|
20:52 <@Gynvael> teraz co jest co
20:52 <@Gynvael> i troche slownictwa:
20:52 -!- Blizzard [blizzard@l33t.zief.pl] has quit ["leaving"]
20:52 -!- Blizzus is now known as Blizzard
20:52 <@Gynvael> void moja_funkcja(void)
20:52 <@Gynvael> { puts("Jestem moja_funkcja();");
20:52 <@Gynvael> }
20:52 <@Gynvael> to jest DEFINICJA FUNKCJI moja_funkcja
20:53 <@Gynvael> DEFINICJA FUNKCJI nazywamy funkcje z cialem
20:53 <@Gynvael> CIALO FUNKCJI to to miedzy { }
20:53 <@Gynvael> jak widac funkcja nazywa sje "moja_funkcja", typem zwracanym jest void, czyli proznia, nic
20:53 <@Gynvael> nic nie jest zwracane 
20:53 <@Gynvael> i nie ma tez argumentow (void)
20:54 <@Gynvael> w ciele funkcji jest WYWOLANIE FUNKCJI "puts"
20:54 -!- d9k [criptin@cfl52.neoplus.adsl.tpnet.pl] has quit [""]
20:54 <@Gynvael> z JEDNYM PARAMETREM, napisem "Jestem moja_funkcja();"
20:54 <@Gynvael> funkcje puts znamy z wczoraj, jest to funkcja wypisujaca cos na "ekran" (standardowy strumien wyjscia, stdout, ale niewazne;p)
20:54 <@Gynvael> i dodajce enter
20:54 <@Gynvael> cos == napis
20:55 <@Gynvael> czym sie rozni PARAMETR od ARGUMENTU ?
20:55 <@Gynvael> ARGUMENT jest w DEKLARACJI funkcji, a PARAMETR przy jej WYWOLANIU
20:55 <@Gynvael> ale tego sie czasem uzywa zamiennie
20:55 <@Gynvael> ;>
20:55 <@Gynvael> to tylko terminologia ;>
20:55 <@Gynvael> ok
20:55 <@Gynvael> czyli lopatologicznie
20:55 <@Gynvael> funkcja "moja_funkjca" wypisuje na ekran "Jestem moja_funkcja();" i przechodzi do nowej linii
20:56 <@Gynvael> druga funkcja w programie jest nieslawny "main"
20:56 <@Gynvael> int
20:56 <@Gynvael> main(void)
20:56 <@Gynvael> { puts("Jestem main()"); moja_funkcja(); 
20:56 <@Gynvael> return 0;
20:56 <@Gynvael> }
20:56 <@Gynvael> cialo main to 3 instrukcje
20:56 <@Gynvael> puts("Jestem main()"); - wypisanie na ekran Jestem main() i przejscie do nowej linii
20:56 <@Gynvael> moja_funkcja(); - wywolanie mojej funkcji
20:57 <@Gynvael> return 0; - wyjscie z main (z programu) i zwroceniu 0 do systemu (0 - WSZYSTKO OK)
20:57 <@Gynvael> teraz taka uwaga
20:57 <@Gynvael> ZEBY UZYC FUNKCJI, KOMPILATOR MUSIAL WCZESNIEJ WIDZIEC JEJ DEKLARACJE BADZ DEFINICJE
20:57 <@Gynvael> deklaracja "puts" jest w <stdio.h> (patrz pierwsza lekcja)
20:58 <@Gynvael> natomiast definicja "moja_funkcja" jest NAD main ;>
20:58 <@Gynvael> a co zrobic jak bysmy chcieli DEFINICJE funkcji dac PO main ?
20:58 <@Gynvael> http://gynvael.vexillium.org/gk3_2.c
20:58 <@Gynvael> rzuccie okiem na ten sam przyklad, ale odrobine zmodyfikowany
20:59 <@Gynvael> mianowicie przyklad sklada sie z 3ch czesci
20:59 <@Gynvael> 1) DEKLARACJA funkcji "moja_funkcja"
20:59 <@Gynvael> void moja_funkcja(void);
21:00 <@Gynvael> czym sie to rozni od DEFINICJI ?
21:00 <@Gynvael> miaonowicie: FUNKCJA NIE MA CIALA
21:00 <@Gynvael> jest to tylko INFORMACJA DLA KOMPILATORA ZE POJAWI SIE KIEDYS FUNKCJIA "moja_funkcja" NIE PRZYJMUJACA ARGUMENTOW I NIC NIE ZWRACAJACA
21:00 <@Gynvael> dzieki temu kompilator nie zdziwi sie jak spotka wywolanie tej funkcji, mimo ze nie bedzie wiedziec co ona robi
21:01 <@Gynvael> 2) DEFINICJA funkcji "main"
21:01 <@Gynvael> 3) DEFINICJA funkcji "moja_funkcja"
21:01 <@Gynvael> co by sie stalo gdyby byla deklaracja funkcji, a nie bylo jej definicji ?
21:01 <@Gynvael> powstal by blad linker
21:02 <@Gynvael> z w/w przykladu usune definicje "moja_funkcja" i wkleje blad kompilatora (linkera dokladniej)
21:02 <@Gynvael> root@yume:/code/kurs# gcc gk3_2.c -Wall -pedantic -o gk3_2
21:02 <@Gynvael> /tmp/cc8vWVAj.o(.text+0x21): In function `main':
21:02 <@Gynvael> : undefined reference to `moja_funkcja'
21:02 <@Gynvael> collect2: ld returned 1 exit status
21:02 <@Gynvael> root@yume:/code/kurs# 
21:03 <@Gynvael> czyli kompilator mowi ze NIE WIE JAK DZIALA I GDZIE JEST "moja_funkcja", MIMO ZE WIEDZIAL ZE COS TAKIEGO BEDZIE
21:03 <@Gynvael> analogicznie, usune teraz deklaracje, a zostawie PO MAIN definicje MOJA_FUNKCJA
21:03 <@Gynvael> root@yume:/code/kurs# gcc gk3_2.c -Wall -pedantic -o gk3_2
21:03 <@Gynvael> gk3_2.c: In function `main':
21:03 <@Gynvael> gk3_2.c:21: warning: implicit declaration of function `moja_funkcja'
21:03 <@Gynvael> gk3_2.c: At top level:
21:03 <@Gynvael> gk3_2.c:28: warning: type mismatch with previous implicit declaration
21:03 <@Gynvael> gk3_2.c:21: warning: previous implicit declaration of `moja_funkcja'
21:03 <@Gynvael> gk3_2.c:28: warning: `moja_funkcja' was previously implicitly declared to return `int'
21:03 <@Gynvael> bledow juz troche iwecej
21:04 <@Gynvael> ogolnie kompilator powiedziel ze nie wie co to za funkcja
21:04 <@Gynvael> DEFAULTOWO KOMPILATOR GCC PRZYJMUJE WYWOLANIA DO NIEZDEKLAROWANYCH FUNKCJI JAKO WYWOLANIA DO int nazwa(void)
21:04 <@Gynvael> ALE NIE NALEZY Z TEGO KORZYSTAC ;>
21:04 <@Gynvael> TRZEBA DEKLAROWAC, SORRY ;p
21:05 <@Gynvael> ok
21:05 <@Gynvael> narazie tyle
21:05 -!- mode/#gynkurs [-m] by Gynvael
21:05 <@Gynvael> pytania ?
21:05 <@adam_i`2> Gynvael: blad gcc gk3_2.c -o gk3_2.c -Wall -pedantic powino byc exe
21:05 <@adam_i`2> W gk_2.c
21:05 <@adam_i`2> Raczj nei exe ale bez .c
21:06 <@salv4tion> ee
21:06 <@mati_> jak z lina sie robi
21:06 <@mati_> to nie :P
21:06 <@salv4tion> zara
21:06 <@Gynvael> adam_i`2: e bez .ct
21:06 <@salv4tion> ;p
21:06 <@Gynvael> adam_i`2: e bez .c
21:06 <@salv4tion> albo nic juz;p
21:06 <@Gynvael> adam_i`2: ma razje ofc ;>
21:06 <@Gynvael> *racje
21:06 <@mati_> chociaz nie probowalem dawac .c
21:06 <@Gynvael> jeszcze jakies pytania ?
21:06 <@phoenix__> DALEJ
21:06 <@mati_> o grafice
21:06 <@mati_> nawijaj
21:06 <@mati_> w c
21:06 <@mati_> jak zrobic tlo
21:06 <@Gynvael> ;p
21:07 <@mati_> albo kolorowy tekst za pomoca jakiegos liba
21:07 <@mati_> :P
21:07 < bubel> oO'
21:07 <@Gynvael> mati_: ehhehehe to kiedys indziej ;>
21:07 <@adam_i`2> mati_: po kolei
21:07 <@mati_> ok
21:07 <@salv4tion> lol
21:07 <@mati_> salv4tion?
21:07 <@salv4tion> nic
21:07 <@Gynvael> dobra
21:07 < bubel> ok let's go party
21:07 <@Gynvael> jakies pytania ?
21:07 <@Gynvael> jak nie to jade dalej
21:07 <@salv4tion> ja moze bym mial
21:07 <@phoenix__> i kurs dla zaawansowanych to bedzie dla tychg oc umia C czy dka tych kursowicziw?>
21:07 <@salv4tion> ale nie cyztalem calego bo mnie przy kompie nie bylo ;f
21:07 -!- mode/#gynkurs [-i] by mati_
21:07 <@salv4tion> ale to nie teraz
21:07 <@phoenix__> *"kursowicziow"
21:08 <@mati_> poco to tak rozpisywac
21:08 <@mati_> :P
21:08 <@phoenix__> Gyn odpowiedz ?:> 
21:08 <@Gynvael> phoenix__: dla tych co umieja C, ofc nowi tez moga sluchac, ale to beda "ciekawsze i mniej proste rzeczy" ;p
21:08 < bubel> Gynvael: +m and go ;>
21:08 <@phoenix__> szkoda :(
21:08 <@Gynvael> phoenix__: to bedzie wszystko za pare tygodni powtarzane "dla nowych" ;p
21:08  * d0b0c0p is back czyta od poczatku
21:08 <@Gynvael> ok
21:08 <@Gynvael> to lecimy
21:08 -!- mode/#gynkurs [+m] by Gynvael
21:08 <@Gynvael> wiec
21:09 <@Gynvael> mniej wiecej znamy nudna terminologie
21:09 <@Gynvael> teraz "jak dziala funkcja", czyli cytat z pierwszej lekcji
21:09 <@Gynvael> funkcja to jest COS co jest wywolywane, robi costam (jakies okreslone zadanie) i wraca tam gdzie byl przed wywolaniem
21:09 <@Gynvael> np.
21:09 <@Gynvael> siedzimy przed kompem
21:10 <@Gynvael> mama wola nas na obiad (funkcja obiad())
21:10 <@Gynvael> idziemy
21:10 <@Gynvael> jemy
21:10 <@Gynvael> zmywamy
21:10 <@Gynvael> wracamy przed kompa, czyli tam gdzie bylismy przed wywolaniem
21:10 <@Gynvael> ogolnie funkcje sa po to zeby 10 razy nie pisac tego samego kawalka kodu
21:10 <@Gynvael> ok
21:10 <@Gynvael> lecimy dalej
21:10 <@Gynvael> przyklad nastepny
21:10 -!- Blizzard [blizzard@frycek.net] has quit [Operation timed out]
21:10 <@Gynvael> http://gynvael.vexillium.org/gk3_3.c
21:11 <@Gynvael> tym razem funkcja z argumentami
21:11 <@Gynvael> program dzieli sie na 2 czesci:
21:11 <@Gynvael> 1) definicja funkcji dodaj
21:11 <@Gynvael> funkcja zwraca int, oraz przyjmuje DWA ARGUMENTY
21:11 <@Gynvael> argumenty sa oddzielone przecinkami 
21:11 <@Gynvael> i maja budowe taka sama jak DEKLARACJA ZMIENNYCH
21:11 <@Gynvael> czyli:
21:11 <@Gynvael> TYP_ZMIENNEJ ZMIENNA
21:11 <@phoenix__> Gyn znowu blad co adam_i mowil ale lec dalelj 
21:11 <@Gynvael> w przypadku dodaj argumenty sa DWA
21:12 <@Gynvael> (yep, znowu blad, tam .c nie powinno byc po -o)
21:12 <@Gynvael> w przypadku dodaj argumenty sa DWA
21:12 <@Gynvael> int a
21:12 <@Gynvael> i int b
21:12 -!- mati_ is now known as mati_sql
21:12 <@Gynvael> czyli FUNKCJA SPODZIEWA SIE ZE DOSTANIE OD PROGRAMISTY DWIE DANE O TYPIE CALKOWITYM
21:12 <@Gynvael> w ciele funkcji jest tylko jedna instrukcja:
21:12 <@Gynvael> return a+b;
21:13 <@Gynvael> return powoduje wyjscie z funkcji i zwrocenie wartosci podanej
21:13 <@Gynvael> podana wartoscia jest WYRAZENIE a + b
21:13 <@Gynvael> czyli
21:13 <@Gynvael> np wywolujac funkcje
21:13 <@Gynvael> dodaj(1, 2);
21:13 <@Gynvael> dzieje sie:
21:13 <@Gynvael> return 1 + 2;
21:13 <@Gynvael> return 3;
21:13 <@Gynvael> i nastepuje wyjscie z funkcji i zwrocenie "3"
21:14 <@Gynvael> 2) definicja funkcji glownej main()
21:14 <@Gynvael> cialo funkcji main to 2 instrukcje
21:14 <@Gynvael>   printf(" 1 + 2 = %i\n", dodaj(1, 2));
21:14 <@Gynvael>   
21:14 <@Gynvael>   return 0;
21:14 <@Gynvael> pierwsza jest wywolanie znanej z wczoraj funkcji formatujacej i wypisujacej napis "printf"
21:15 <@Gynvael> trzeba zauwazyc ze jednym z parametrow (drugim) prinf jest wywolanie funkcji dodaj z PARAMETRAMI 1 i 2
21:15 <@Gynvael> czyli mozna z kodu wyczytac ze wypisane na ekran zostanie wynik dodawania 1 i 2
21:15 <@Gynvael> druga instrukcja jest return 0;, ktore znamy ;>
21:15 <@Gynvael> teraz tak
21:15 <@Gynvael> kompilujemy i odpalamy program. co sie dzieje ?
21:16 <@Gynvael> main(): printf(" 1 + 2 = %i\n", dodaj(1, 2));
21:16 <@Gynvael> tutaj nastepuje wywolanie dodaj(1,2), wkoncu trzeba znac wynik funkcji zeby wstawic za %i
21:16 <@Gynvael> dodaj(1,2): return 1+2;
21:16 <@Gynvael> dodaj(1,2): return 3;
21:16 <@Gynvael> i zostaje zwrocone 3
21:16 <@Gynvael> main(): printf(" 1 + 2 = %i\n", 3);
21:16 <@Gynvael> main(): printf(" 1 + 2 = 3\n");
21:17 <@Gynvael> EKRAN: 1 + 2 = 3
21:17 <@Gynvael> main(): return 0;
21:17 <@Gynvael> koniec, wyjscie i zwrocenie 0
21:17 <@Gynvael> teraz troche o tym jak dziala PRZEKAZYWANIE PARAMETROW DO FUNKCJI
21:18 <@Gynvael> mianowicie funkcja dostaje !!!!!!KOPIE PARAMETROW!!!!!!
21:18 <@Gynvael> jakie sa tego implikacje ?
21:18 <@Gynvael> spojrzmy na kolejny przyklad
21:18 <@Gynvael> http://gynvael.vexillium.org/gk3_4.c
21:18 <@Gynvael> 2 funkcjie 
21:18 <@Gynvael> 1) void zmien(int a) { a = 5; }
21:19 <@Gynvael> funkcja ta nic nie zwraca, dostaje KOPIE ZMIENNEJ a, po czym zmienia WARTOSC KOPIII na 5
21:19 <@Gynvael> NIE ZMIENIA WARTOSCI ZMIENNEJ UZYTEJ JAKO PARAMETR!!!
21:19 <@Gynvael> 2) definicja main
21:19 <@Gynvael> a w niej 6 instrukcji
21:19 <@Gynvael> int b; - DEKLARACJA zmiennej "b", ktora jest typu calkowitego int
21:19 <@Gynvael> b = 10; - nadanie zmiennej b WARTOSCI 10
21:20 <@Gynvael> printf("b przed zmien() jest rowne %i\n", b);
21:20 <@Gynvael> wypisanie na ekran wartosci b
21:20 -!- mati_sql [mati@62.233.144.147] has quit [":>"]
21:20 <@Gynvael> zmien(b) - wywolanie funnkcji "zmien" z parametrem "b"
21:20 <@Gynvael> printf("b po zmien() jest rowne %i\n", b); - wypisanie wartosci b
21:20 <@Gynvael> return 0; - to znamy
21:20 -!- BeOm_ [^r00t@ccn21.neoplus.adsl.tpnet.pl] has joined #gynkurs
21:20 -!- mode/#gynkurs [+o BeOm_] by phoe
21:20 <@Gynvael> kompilujemy i odpalamy
21:21 <@Gynvael> root@yume:/code/kurs# gcc gk3_4.c -Wall -pedantic -o gk3_4
21:21 <@Gynvael> root@yume:/code/kurs# ./gk3_4 
21:21 <@Gynvael> b przed zmien() jest rowne 10
21:21 <@Gynvael> b po zmien() jest rowne 10
21:21 <@Gynvael> jak widac WARTOSC ZMIENNEJ b NIE ZMIENILA SIE
21:21 <@Gynvael> jak program dziala ?
21:21 <@Gynvael> po kolei
21:21 <@BeOm_> kurfa slim
21:21 <@Gynvael> najpierw main
21:21 <@Gynvael> main(): int b;
21:21 <@Gynvael> main(): b = 10;
21:21 <@Gynvael> main(b=10): printf....
21:21 <@Gynvael> main(b=10): zmien(b);
21:22 <@Gynvael> main(b=10): zmien(10);
21:23 <@Gynvael> zmien(a=10): a=5;
21:23 <@Gynvael> zmien(a=5):
21:23 <@Gynvael> main(b=10): printf......;
21:23 <@Gynvael> main(b=10): return 0;
21:23 <@Gynvael> koniec
21:23 <@Gynvael> czyli zmien dostaje w sumie nie tyle zmienna "b" co jej wartosc
21:23 <@Gynvael> ok
21:23 -!- mode/#gynkurs [-m] by Gynvael
21:23 <@Gynvael> pytania ?
21:23 <@d0b0c0p> ja ne
21:23 <@seraphin_> jak spowodaowac zeby zmien() dostalo prawdziwe b?
21:23 <@phoenix__> hmm
21:23 <@d0b0c0p> !time
21:23 <@seraphin_> wskaznikiem?
21:23 -phoe:#gynkurs- 21:21:53
21:23 <@Gynvael> seraphin_: tak, ale o tym za chwile
21:23 <@adam_i`2> B=zmien
21:23 <@seraphin_> (a w zasadzie jego kopia)
21:23 <@d0b0c0p> Gynvael: zmien(int &a)?
21:23 <@seraphin_> adam_i`2: ale nie o takie cos mi chodzi
21:24 <@Gynvael> d0b0c0p: to nie C++ ;>
21:24 <@phoenix__> czy kurs dla zaawansowanych bedzie w miare rozumnych dla tych co ucza sie kursu?
21:24 <@Gynvael> phoenix__: powinien byc ;>
21:24 <@Gynvael> phoenix__: ale nie wiem czy ta wiedza bedzie im bardzo przydatna
21:24 <@phoenix__> Gynvael: zrob prosty ;>
21:24 <@Gynvael> ok
21:24 <@Gynvael> jesli brak pytan
21:24 <@Gynvael> to jade dale
21:24 <@Gynvael> *dalejh
21:24 <@phoenix__> im nie ale mi tak
21:24 <@d0b0c0p> Gynvael: to powiesz jak? :]
21:24 <@Gynvael> d0b0c0p: powiem ;>
21:24 <@Gynvael> ok
21:24 <@d0b0c0p> jadymy...
21:24 <@Gynvael> to jade dalej
21:24 <@d0b0c0p> thX
21:24 -!- mode/#gynkurs [+m] by Gynvael
21:24 <@Gynvael> ok
21:25 <@Gynvael> a teraz nowe rodzaje zmiennych
21:25 <@Gynvael> POINTERY (wskazniki)
21:25 <@Gynvael> to jest w sumie utrapienie WSZYSTKICH UCZACYC SIE C
21:25 <@Gynvael> i to trzeba na prawde dobrze zrozumiec
21:25 <@Gynvael> i o tym bedzie jeszcze pare razy
21:25 <@Gynvael> dzisiaj krotki wstep tylko
21:25 <@Gynvael> wiec
21:26 <@Gynvael> pointer jest ADRESEM ZMIENNEJ
21:26 <@Gynvael> przykladowo
21:26 <@Gynvael> mamy sobie typ DOM (taki dom, wiecie, dach, sciany, ludzie w srodku)
21:26 <@Gynvael> kazdy znas ma jakis tam dom
21:26 <@Gynvael> zalozmy wiec ze mamy zmienne:
21:26 <@Gynvael> dom gyna, adama, neka;
21:27 <@d0b0c0p> i bubla
21:27 <@Gynvael> gyna, adama i neka to sa DOMY ;> przez "gyna" rozumiemy CALY DOM, ZE WSZYSTKIM CO MA WEWNATRZ, ZE WSZYSTKIMI SCIANAMI ETC
21:27 <@Gynvael> i teraz zalozmy ze d0b0c0p ktory sie odezwal chce siesc do adama
21:27 <@Gynvael> wiec adam mu musi jakos powiedziec gdzie mieszka
21:28 <@Gynvael> ZLYM POMYSLEM bylo by danie mu CALEGO DOMU "adama" i powiedzenie "SZUKAJ DOKLADNIE CZEGOS TAKIEGO" ;>
21:28 <@Gynvael> najlepszym pomyslem jest po prostu podanie mu adresu ;>
21:28 <@Gynvael> w jezyku C adres zmiennej uzyskuje sie WSTAWIAJAC PRZED NAZWE ZMIENNEJ ZNAK AMPERSAND ;p czyli & ;>
21:29 <@Gynvael> wiec, d0b0c0p dostanie adres domu adama: &adama
21:29 <@Gynvael> zalozmy ze d0b0c0p chcial by utworzyc ZMIENNA KTORA BEDZIE PRZECHOWYWALA NIE DOM, A ADRES DOMU
21:30 <@Gynvael> zmienna taka tworzy sie poprzed WSTAWIENIE ZNAKU ASTERISK * (gwiazdka ;p) PRZED NAZWE PRZY DEKLARACJI ZMIENNEJ
21:30 <@Necrium> gdzie adres jest odzwierciedleniem zmiennej w pamieci, adres zawiera segment i offset segment:offset
21:30 <@Gynvael> np
21:30 <@Necrium> :]
21:30 <@Gynvael> Necrium: mieszasz ;> i to ostro ;> nie te czasy ;>
21:30 <@Gynvael> wiec pisamy
21:30 <@Gynvael> dom *adres_dla_d0b0c0pa;
21:30 <@Gynvael> adres_dla_d0bocopa = *adama;
21:30 <@Gynvael> e
21:30 <@Gynvael> literowka --
21:30 <@Gynvael> adres_dla_d0bocopa = &adama;
21:31 <@Gynvael> tak jest poprawnie
21:31 <@Necrium> ;P
21:31 <@salv4tion> Necrium: stul pysk
21:31 -!- mode/#gynkurs [-o Necrium] by d0b0c0p
21:31 <@Gynvael> i teraz, odwolanie do DOMU KTORY JEST POD ADRESEM adres_dla_d0b0c0pa 
21:31 <@Gynvael> robi sie uzywajac znaku * WSTAWIONEGO PRZED NAZWE ZMIENNEJ
21:31 <@Gynvael> czyli
21:31 <@Gynvael> adres_dla_d0b0c0pa to typ (dom*)
21:32 <@Gynvael> adama to typ (dom)
21:32 <@Gynvael> &adama to typ (dom*)
21:32 <@Gynvael> a *adres_dla_d0b0c0pa to typ (dom) ;>
21:32 <@Gynvael> ok
21:32 <@Gynvael> a teraz uzycie tego w C
21:32 <@seraphin_> w8
21:32 <@seraphin_> moge przerwac?
21:32 <@Gynvael> mow
21:33 <@seraphin_> czemu w (dmo*) gwiazda jest ZA nazwa dom?
21:33 <@Gynvael> seraphin_: to okreslenie typu tylko ;>
21:33 <@seraphin_> 21:31 <@Gynvael> dom *adres_dla_d0b0c0pa;
21:33 <@seraphin_> tu jest gwiazda przed
21:33 <@Gynvael> seraphin_: to co jest w nawiasie to jest UZYCIE PRZY DEKLARACJI
21:33 <@phoenix__> dom * adres 
21:33 <@Gynvael> seraphin_: czyli CO TRZEBA PRZY DEKLARACJI NAPISAC ZEBY TAKI TYP UZYSKAC
21:33  * d0b0c0p uwaza, ze to literokwa
21:34 <@Gynvael> roznica jest taka
21:34 <@Gynvael> dom *adres; - adres to ADRES DOMU
21:34 <@Gynvael> *adres - to jest ODWOLANIE DO DOMU POD ADRESEM adres
21:34 <@Gynvael> dom *adres; - adres to ADRES DOMU (deklaracja)
21:34 <@Gynvael> przykladowo dla normlanych typow:
21:34 <@Gynvael> int a;
21:34 <@Gynvael> a to jest (int)
21:34 <@Gynvael> float b;
21:34 <@Gynvael> b to jest (float)
21:35 <@Gynvael> int *c;
21:35 <@Gynvael> c to jest (int*)
21:35 <@Gynvael> ----int *----c;
21:35 <@Gynvael> stad to int*
21:35 <@Gynvael> *c (odwolanie do tego co jest pod adresem "c") to jest int*
21:35 <@Gynvael> e
21:35 <@Gynvael> *c (odwolanie do tego co jest pod adresem "c") to jest int
21:35 <@Gynvael> int *c <=- "c" jest ADRESEM ZMIENNEJ O TYPIE "int"
21:35 <@seraphin_> hmmm... a w c istnieje formalnie zapis "zmienna*" ?
21:35 <@Gynvael> ADRES ZMIENNEJ O TYPIE int to "int *"
21:36 <@Gynvael> seraphin_: przy rzutowaniu (casting), ale o tym potem
21:36 <@phoenix__> Namotaliscie
21:36 <@Gynvael> bo rzutownaie pointerow to pol wieczoru
21:36 <@Gynvael> nvm
21:36 <@Gynvael> przyklad
21:36 <@d0b0c0p> mysle, ze przerwijmy
21:36 <@phoenix__> d0b0c0p: tak 
21:36 <@d0b0c0p> i dokonczmy
21:36 <@Gynvael> ok
21:36 <@Gynvael> tzn
21:36 <@Gynvael> d0b0c0p: tzn kontynuowac czy pytania ?
21:36 <@d0b0c0p> a potem pytania...
21:36 <@phoenix__> i Gyn wytlaumacz dokladniej
21:37 <@d0b0c0p> Gynvael: mysle, ze dokonczmy
21:37 <@phoenix__> tzn bardziej po ludzku
21:37 <@d0b0c0p> a potem pytania
21:37 <@seraphin_> huhu ta gwiazdka z tylu namieszala drobinke
21:37 <@d0b0c0p> ale to ofc moje zdanie
21:37 <@Gynvael> dobra
21:37 <@Gynvael> nvm
21:37 <@d0b0c0p> seraphin_: ;)
21:37 <@Gynvael> csii ja dam przyklad
21:37 <@Gynvael> i na przykladzie to wytlumacze
21:37 <@Gynvael> kk ?
21:37 <@phoenix__> wlasnie
21:37 <@salv4tion> k
21:37 <@Gynvael> tam sa gwiazdeczki i inne ksiezyce
21:37 <@Gynvael> ;>
21:37 <@seraphin_> k
21:37 <@d0b0c0p> k
21:37 <@phoenix__> good idea ;]
21:37 <@Gynvael> http://gynvael.vexillium.org/gk3_5.c
21:37 -!- Necrium [healscream@sido.us] has left #gynkurs []
21:38 <@Gynvael> ok
21:38 <@Gynvael> wiec
21:38 -!- SlimFast [~1234@gate.olnet.com.pl] has joined #gynkurs
21:38 -!- mode/#gynkurs [+o SlimFast] by phoe
21:38 <@Gynvael> przed oczyma powinniscie miec kod
21:38 <@Gynvael> znowu dwie funkcje
21:38 <@Gynvael> analogiczne jak poprzednim razem
21:38 <@Gynvael> ale ze zmianami
21:38 <@Gynvael> mianowicie
21:38 <@xaos_> ja mam biale myszki, jest ok? :P
21:38 <@Gynvael> 1) funkcja zmien
21:38 <@Gynvael> void zmien(int *a)
21:38 <@Gynvael> {
21:39 <@Gynvael>  *a = 5;
21:39 <@Gynvael> }
21:39 <@Gynvael> co tu sie dzieje.. po kolei
21:39 <@Gynvael> zmien przyjmuje JEDEN ARGUMENT
21:39 <@Gynvael> o typie (int*) (adres zmiennej typu int, tzw wskaznik na inta)
21:39 <@Gynvael> zmienna "a" jest ADRESEM ZMIENNEJ TYPU INT
21:39 <@Gynvael> *a = 5;
21:40 <@Gynvael> a <=- adres zmiennej typu int
21:40 <@Gynvael> *a <=- ODWOLADNIE SIE DO TEGO CO JEST POD ADRESEM "a"
21:40 <@Gynvael> *a <=- POD ADRESEM "a" JEST JAKAS ZMIENNA TYPU "int"
21:40 <@Gynvael> *a <=- NIE INTERESUJE NAS JAK TA ZMIENNA SIE NAZYWA, ALE MAMY JEJ ADRES
21:40 <@Gynvael> *a <=- WIEC MOZEMY ZDEMOLOWAC JEJ CHALUPE
21:40 <@Gynvael> ee chyba sie zapedzilem --;
21:41 <@Gynvael> *a <=- WIEC MOZEMY ZMIENIC JEJ WARTOSC (tej zmiennej ktorej adres znamy)
21:41 <@Gynvael> *a = 5; <=- ZMIENIAMY WARTOSC ZMIENNEJ WSKAZYWANEJ PRZEZ "a" na 5
21:41 <@Gynvael> *a = 5; <=- ZMIENIAMY WARTOSC ZMIENNEJ ZMIENNEJ POD ADRESEM "a" na 5
21:41 <@Gynvael> ok dalej
21:41 <@Gynvael> teraz 2) main
21:41 <@Gynvael> tam zmiana jest jedna
21:41 <@Gynvael> nie ma "zmien(b);"
21:42 <@Gynvael> jest "zmien(&b)"
21:42 <@Gynvael> &b jest ADRESEM ZMIENNEJ "b" (ktora jest typu int)
21:42 <@Gynvael> -=213646=- <@Gynvael> zmien przyjmuje JEDEN ARGUMENT
21:42 <@Gynvael> -=213702=- <@Gynvael> o typie (int*) (adres zmiennej typu int, tzw wskaznik na  inta)
21:42 <@Gynvael> czyli "zmien" spodziewa sie adresu i adres dostaje
21:42 <@Gynvael> wiec zmien dostaje KOPIE (o tym mowilem wczesniej) ADRESU (&) ZMIENNEJ b KTORA MA TYP int
21:43 <@Gynvael> co sie teraz dzieje po kolei:
21:43 <@Gynvael> main():
21:43 <@Gynvael> main(): int b;
21:43 <@Gynvael> main(): b = 10;
21:43 <@Gynvael> main(b=10): printf...
21:43 <@Gynvael> main(b=10): zmien(&b)
21:43 <@Gynvael> main(b=10): zmien(TUTAJ WSKAKUJE ADRES B)
21:43 <@Gynvael> zmien(a=adres b):
21:43 <@Gynvael> zmien(a=adres b): *a = 5;
21:43 <@Gynvael> zmien(a=adres b): *(adres b) = 5;
21:43 <@Gynvael> zmien(a=adres b): b = 5;
21:44 <@Gynvael> main(b=5): printf.....
21:44 <@Gynvael> main(b=5): return 0;
21:44 -!- ron4in [p-135-186@tygrysek.krosnowice.pbsi.pl] has joined #gynkurs
21:44 -!- mode/#gynkurs [+o ron4in] by phoe
21:44 <@Gynvael> kompilacja i sprawdzamy czy tak jest
21:44 <@Gynvael> root@yume:/code/kurs# gcc gk3_5.c -o gk3_5
21:44 <@Gynvael> root@yume:/code/kurs# ./gk3_5 
21:44 <@Gynvael> b przed zmien() jest rowne 10
21:44 <@Gynvael> b po zmien() jest rowne 5
21:44 <@Gynvael> root@yume:/code/kurs# 
21:44 <@Gynvael> wartosc sie zmienila, wiec faktycznie musi tak byc
21:44 <@Gynvael> ok, pytanka
21:44 -!- mode/#gynkurs [-m] by Gynvael
21:44 <@d0b0c0p> pytania...?
21:45 <@gRl> o co chodzi?
21:45 <@gRl> wogole co to bylo?
21:45 <@gRl> bo jakos tego nie kapuje ; F
21:45 <@Gynvael> gRl: pointery ;p
21:45 <@d0b0c0p> no to ja zaczne :). czy int b; (int*)b == &b; ?
21:45 <@adam_i`2> A ja wrszcie to kapuej w kursach innych nei kapowalem
21:45 <@Gynvael> d0b0c0p: nie, to co jest w nawiasie to jest rzutownaie ;>
21:46 <@Gynvael> (ad adam_i`2: chlip, czyli jednak jestem do czegos uzyteczny =^^=)
21:46 <@d0b0c0p> Gynvael: ale czy wynik bedzie taki sam?
21:46 <@Gynvael> d0b0c0p: nie do konca
21:46 <@seraphin_> Gynvael: ja mam pytanie
21:46 <@phoenix__> adam_i`2: w syfoni jest extra wytlumaczone o wskoaznikach
21:46 <@phoenix__> adam_i`2: extra
21:46 <@Gynvael> d0b0c0p: (int*)b to ZMUSZENIE KOMPILATORA ZEBY MYSLAL ZE "b" TO ADRES TO ZMIENNEJ TYPU INT, mimo ze tak naprawde to to bedzie zmienna typu int
21:46 <@Gynvael> seraphin_: mow mow
21:46 <@phoenix__> Gynvael: czy wskazniki w C++ sa takie same jak w C ?
21:46 <@Gynvael> phoenix__: tak
21:46 <@phoenix__> aha
21:46 <@phoenix__> to fajnie
21:46 <@Gynvael> phoenix__: z tym ze w C jest troche lepiej ;>
21:46 <@seraphin_> Gynvael: co by sie stalo gdyby funkcje zmien() zadeklaroawc w taki sposob : zamiast zmien(*a) to dac zmien(&a)
21:47 <@phoenix__> Gynvael: w symgoni jest extra
21:47 <@adam_i`2> Gynvael: tylko pytanei jaki to ma cel? Szybsze dzilacniae ?
21:47 <@phoenix__> *symfoni
21:47 <@Gynvael> seraphin_: blad kompilatora ;ppp
21:47 <@phoenix__> adam_i`2: tak
21:47 <@Gynvael> seraphin_: w C nie ma int &a, to jest w C++
21:47 <@seraphin_> Gynvael: a czemu to?
21:47 <@Gynvael> adam_i`2: o celu bedzie za chwile ;>
21:47 <@Gynvael> seraphin_: jakos tak na poczatku C nie wymyslili ze moze byc cos takiego jak referencja ;ppp
21:47 <@phoenix__> Gynvael: co mnie klamiesz jak nie jest tak sam o :P
21:48 <@d0b0c0p> adam_i`2: fajnie to wyjasnil grebosz: "Amerykanie mowia mozna zyc bez Coca-coli, ale po co?" ;)
21:48 <@Gynvael> phoenix__: podac ci roznice ?:P
21:48 <@phoenix__> Gynvael: poprosze ;]
21:48 <@Gynvael> phoenix__: w C++ sa referencje o ktorych seraphin_ mowi
21:48 <@phoenix__> a w C niema
21:48 <@seraphin_> Gynvael: ja nie wiem co jest w C++ ale pomyslalem sobie ze rownie dobrze mozna by dac zmien(&a) bo to tez adres
21:48 <@phoenix__> seraphin_: ja wole tak jak tam jesyt 
21:48 <@Gynvael> phoenix__: po za tym jesli w C funkcja zwraca typ void* (wskaznik na nic) to nie trzeba wykonywac rzutowania potem, jesli jej wartosc przypisujemy jakiemus wskaznikowi, a w C++ trzeba
21:48 <@phoenix__> ja sie z symfoni tak nei uczylem
21:49 <@seraphin_> (wskaznik na nic... ql... n/c)
21:49 <@phoenix__> btw nie wiem co to rzutowanie ;P
21:49 <@Gynvael> phoenix__: wczoraj bylo rzutownaie ;>
21:49 <@phoenix__> seraphin_: nom
21:49 <@salv4tion> phoenix__: przeksztalcanie typow zmiennych
21:49 <@Gynvael> seraphin_: ehehe zebys ty wiedzial ile to ma zastosowan ;pppppppp
21:49 <@salv4tion> czy jakos tak ;F
21:49 <@phoenix__> Gynvael: a dokladniej o tym bedzie ?> 
21:49 <@Gynvael> phoenix__: bedzie bedzie, ale duzo pozniej
21:49 <@phoenix__> Gynvael: bo nie kapuje tego 
21:49 <@Gynvael> phoenix__: jeszcze if, for, while etc zostaly ;>
21:50 <@phoenix__> tzn tak troche
21:50 <@Gynvael> ok
21:50 <@Gynvael> to jedziemy dalej ?
21:50 <@phoenix__> Gynvael: to proste
21:50 <@Gynvael> zastosowania wskaznikow ;>
21:50 <@phoenix__> Gynvael: to w kazdum jezyku jest
21:50 <@seraphin_> Gynvael: ja sugeruje zebys pokazal instrukcje takie jak if, else, switch, for, while, break itp
21:50 <@Gynvael> phoenix__: na koniec wykladu zrobimy glosowanie
21:50 <@d0b0c0p> ciii ;]
21:50 <@Gynvael> phoenix__: jesli kazdy bedzie znal je, to powiem tylko rzeczy nieoczywiste ktore ich dotycza
21:50 <@adam_i`2> phoenix__: ale jak kurs to musi byc wszytko
21:50 <@d0b0c0p> c.d.?
21:50 <@Gynvael> phoenix__: a ktore nie kazdy wie ;>
21:50 <@salv4tion> seraphin_: e moze cos ambitniejszego? moze listy w 4 czesci?
21:51 <@Gynvael> phoenix__: a jesli nie to pojade od podstaw
21:51 <@Gynvael> ok
21:51 <@Gynvael> cd o wskaznikach ?
21:51 <@salv4tion> taa
21:51 <@salv4tion> przyda sie ;>
21:51 <@Gynvael> to csiiiii ;>
21:51 -!- mode/#gynkurs [+m] by Gynvael
21:51 <@Gynvael> ok
21:51 <@Gynvael> po co sa te wskazniki ?
21:51 -!- mode/#gynkurs [+o bubel] by d0b0c0p
21:51 <@Gynvael> jedno z zastosowan przed chwila widzialiscie
21:51 <@Gynvael> czyli zmiane wartosci zmiennej wewnatrz funkcji
21:51 <@Gynvael> nieoczywista  rzecza o ktorej nie powiedzialem
21:52 <@Gynvael> jest to ze mamy dwa rodzaje zmiennych:
21:52 <@Gynvael> - globalne
21:52 <@Gynvael> - lokalne
21:52 <@Gynvael> jak narazie uzywalismy samych LOKALNYCH
21:52 <@Gynvael> sa to ZMIENNE "WIDOCZNE" TYLKO W DANEJ FUNKCJI
21:52 <@Gynvael> przykladowo "int b" z ostatniego przykladu jest "WIDOCZNE" (czyli mozna z jego nazwy korzystac) tylko w funkcji main
21:53 <@Gynvael> uzycie "b" w funkcji "zmien" bez jej wczesniejszej deklaracji tam, to blad kompilatora
21:53 <@Gynvael> natomiast nawet jesli zadeklarowalismy by zmienna o takiej samej nazwie, b, w funkcji zmien, to to by bylo INNE "b"
21:53 <@Gynvael> analogicznie do Real Life
21:53 <@Gynvael> na kazdej ulicy jest dom o numerze "1"
21:53 <@Gynvael> ale to nie znaczy ze to jeden i ten sam dom
21:54 <@Gynvael> funkcje to ulice, kazda ma swoje domy (zmienne) ;>
21:54 <@Gynvael> drugim rodzajem sa zmienne globalne
21:54 <@d0b0c0p> (dobry przyklad... brawo)
21:54 <@Gynvael> sa one deklarowane PO ZA FUNKCJAMI
21:54 <@Gynvael> NAJLEPIEJ NA POCZATKU PROGRAMU, PO #include
21:54 <@Gynvael> i sa one "WIDOCZNE" wszedzie
21:55 <@Gynvael> dwa fakty o tych zmiennych jeszcze
21:55 <@Gynvael> i jade dalej
21:56 <@Gynvael> zmienna lokalna MA INNA WARTOSC PRZY KAZDYM WYWOLANIU FUNKCJI, WIEC NIE NALEZY SIE SPODZIEWAC ZE JAK RAZ WEJDZIEMY DO ZMIEN, I NADAMY "a" wartosc 5, i za chwile znowu tam wejdziemy, to ze "a bedzie nadal = 5"
21:56 <@Gynvael> tak NIE BEDZIE
21:56 <@Gynvael> dodatkowo
21:56 <@Gynvael> zmienne lokalne PO DEKLARACJI, ALE PRZED NADANIEM WARTOSCI maja PRAWIE ZE LOSOWA WARTOSC (nie do konca losowa, ale o tym moze kiedys indziej, przy okazji asemblera ;>)
21:56 <@Gynvael> natomiast 
21:57 <@Gynvael> zmienne globalne maja na poczatku wartosc 0 ;>
21:57 <@Gynvael> zawsze 0 ;>
21:57 <@Gynvael> ok
21:57 <@Gynvael> wracamy do wskaznikow
21:57 <@Gynvael> wiec, po co sa te wskazniki cholerne
21:57 <@Gynvael> - zeby meczyc studentow (takie uzycie slyszalem na uczelni)
21:57 <@Gynvael> - zeby moc robic podobnie jak w zmien - zmieniac wartosc zmiennych znajac ich adres
21:58 <@Gynvael> niby mozna zrobic:
21:58 <@Gynvael> int zmien(int a) { a = 5; return a; }
21:58 <@Gynvael> i wywolac
21:58 <@Gynvael> b = zmien(b);
21:58 <@Gynvael> (czasem sie tak robi)
21:58 <@Gynvael> ALE, jak zrobic to samo jesli NARAZ CHCEMY ZMIENIC WARTOSCI 5 zmiennych ?
21:59 <@Gynvael> wtedy TRZEBA uzyc wskaznikow (albo robic jakies sztuczki haxxorskie, o ktorych kiedys indziej)
21:59 <@Gynvael> - dzieki wskaznika mozliwosc jest tworzenia wielu wirtualnych struktur danych (listy laczone, drzewa binarne etc) ktore sa odrobnie skomplikowane do implementacji, ale BAAAAAAAAARDZO ulatwiaja potem zycie
22:00 <@Gynvael> - w jezyku C 99% operacji na napisach, robi sie za pomoca wskaznikow (co jest utrapieniem wielu ludzi ;p)
22:00 -!- BeOm_ is now known as BeOm_soldat
22:00 <@Gynvael> o tym ostanim beda pewnie z 3 wyklady ;>
22:00 <@Gynvael> a o przedostatnim z 10 --;
22:00 <@Gynvael> ;p
22:00 <@Gynvael> ale nvm
22:00 <@gRl> Gynvael: albo uzyc globalnych zmiennych ;p
22:01 <@Gynvael> gRl: to jest zly pomysl,
22:01 <@Gynvael> gRl: jak by to znajomy powiedzial, "zasmiecanie namespace'u"
22:01 <@gRl> ale mozna
22:01 <@Gynvael> ;p
22:01 <@Gynvael> gRl: ofc, mozna ;>
22:01 <@Gynvael> ok
22:01 <@Gynvael> a teraz kolejny przyklad uzycia wskaznikow ;>
22:01 <@Gynvael> (w8 na serv wrzuce.. lag...)
22:02 <@j00ru> wow gynv ale ty ich tyu  meczysz =^^= 
22:02 <@j00ru> ide na film
22:02 <@j00ru> cya
22:02 <@phoenix__> cya
22:02 <@salv4tion> pa
22:02 <@phoenix__> i ciiiii
22:02 <@d0b0c0p> hieh ;]
22:02 <@d0b0c0p> papa
22:02 <@Gynvael> cyah
22:02 <@d0b0c0p> ciii
22:02 <@phoenix__> CIIIIIIIIIIIISSSSSSSSSSZZZZA
22:02 <@salv4tion> k, koniec porzednan ;p
22:02 <@salv4tion> porzegnan*
22:02 <@d0b0c0p> ((( -_- )))
22:03 <@phoenix__> nawijaj
22:03 <@phoenix__> Gyn
22:03 <@gRl> Gynvael: listy nie sa trudne : o
22:03 <@Gynvael> gRl: pisales je w C ?
22:03 <@d0b0c0p> gRl: ciii
22:03 <@salv4tion> gRl: nacpales sie?
22:03 <@gRl> w cpp : P
22:04 <@Gynvael> gRl: pisales czy uzywales vector ?;>
22:04 <@gRl> japy, i tak wrzuca dopier oprzyklad
22:04 <@gRl> pisalem w cpp
22:04 <@Gynvael> gRl: tyo respect ;>
22:04 <@salv4tion> oO
22:04 <@gRl> przeto o tyn w pasji c++ : P
22:04 <@adam_i`2> Co to te listy
22:04 <@Gynvael> gRl: mozesz wiec powiedziec ze masz wiedze studenta 2giego roku informy
22:04 <@salv4tion> Gynvael: hmm, kiedy dzisiaj konczymy?
22:04 <@Gynvael> adam_i`2: hehehe o tym pozniej ;>
22:04 <@phoenix__> wlasnie co to te listy?
22:05 <@Gynvael> salv4tion: jeszcze z 30 minut
22:05 <@salv4tion> acha
22:05 <@Gynvael> o listach POZNIEJ ;>
22:05 <@phoenix__> Gynvael: powiedz teraz 
22:05 <@Gynvael> przy okazji tablic
22:05 <@phoenix__> taki maly wstep
22:05 <@d0b0c0p> ;[
22:05 <@Gynvael> phoenix__: eheheh to lista danych ;>
22:05 <@Gynvael> phoenix__: serio nei teraz ;>
22:05 <@phoenix__> dobra dalej
22:05 <@gRl> HAHA! jestem fajny !
22:05 <@Gynvael> phoenix__: to BARZDO zly moment
22:05 -!- j00ru is now known as j00ru`aw
22:05 <@Gynvael> http://gynvael.vexillium.org/gk3_6.c
22:05 <@Gynvael> ok
22:05 <@Gynvael> takie cos
22:05 <@Gynvael> tylko definicja main
22:06 <@d0b0c0p> tutaj macie cos o listach (tak btw): http://galaxy.uci.agh.edu.pl/~chwastek/lectures/C/spis.html
22:06 <@Gynvael> uzycie wskaznikow do zmien wartosci dwoch zmiennych
22:06 <@Gynvael> wytlumacze tylko dzialanie programu:
22:06 <@Gynvael> main():
22:06 <@Gynvael> main(): int a, b, c, *adres; - deklaracje 4rech zmiennych, 3 typu int, 1 typu int*
22:06 <@Gynvael> main(a=?,b=?,c=?,d=?): a = 1;
22:07 <@Gynvael> main(a=1,b=?,c=?,d=?): b = 2;
22:07 <@Gynvael> main(a=1,b=2,c=?,d=?): c = 3;
22:07 <@Gynvael> main(a=1,b=2,c=3,d=?): printf... wypisze a = 1, b = 2, c = 3
22:07 <@Gynvael> nie "d" tylko "adres" tak btw --;
22:07 <@Gynvael> ;p
22:07 <@Gynvael> main(a=1,b=2,c=3,adres=?):
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=?): adres = &a;
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=?): adres = (adres a)
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=&a): 
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=&a): *adres = 10;
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=&a): *(&a) = 10;
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=&a): a = 10;
22:08 <@Gynvael> main(a=10,b=2,c=3,adres=&a):
22:08 <@Gynvael> main(a=1,b=2,c=3,adres=&a): adres = &b;
22:09 <@Gynvael> main(a=1,b=2,c=3,adres=&b): adres = (adres b);
22:09 <@kiero> o shit ! what is this? :D
22:09 <@Gynvael> eh
22:09 <@Gynvael> zgubilem
22:09 <@Gynvael> ;p
22:09 <@Gynvael> 2 ostatnie linie, a = 10
22:09 <@Gynvael> reszta ok
22:09 <@d0b0c0p> kiero: ciii
22:09 <@Gynvael> main(a=10,b=2,c=3,adres=&b): *adres = 11;
22:09 <@Gynvael> main(a=10,b=2,c=3,adres=&b): *(&b) = 11;
22:09 <@Gynvael> main(a=10,b=2,c=3,adres=&b): b = 11;
22:09 <@Gynvael> main(a=10,b=11,c=3,adres=&b): 
22:09 <@Gynvael> main(a=10,b=11,c=3,adres=&b): printf wypisze a = 10, b = 11, c = 3
22:10 <@Gynvael> main(a=10,b=11,c=3,adres=&b): return 0; - koniec, all ok
22:10 <@Gynvael> tak powinno wygladac dzialanie programu
22:10 <@Gynvael> kompilacja i odpalmy
22:10 <@Gynvael> root@yume:/code/kurs# gcc gk3_6.c -o gk3_6
22:10 <@Gynvael> root@yume:/code/kurs# ./gk3_6
22:10 <@Gynvael> a = 1, b = 2, c = 3
22:10 <@Gynvael> a = 10, b = 11, c = 3
22:10 <@Gynvael> czyli tak jak mowilem
22:10 <@Gynvael> ok
22:10 <@d0b0c0p> ty sie nie mylisz ;-)
22:10 <@d0b0c0p> tak btw ;]
22:11 <@Gynvael> d0b0c0p: -=220642=- <@Gynvael> eh
22:11 <@Gynvael> -=220644=- <@Gynvael> zgubilem
22:11 <@Gynvael> -=220644=- <@Gynvael> ;p
22:11 <@Gynvael> -=220650=- <@Gynvael> 2 ostatnie linie, a = 10
22:11 <@Gynvael> ;p
22:11 <@Gynvael> ok
22:11 <@Gynvael> teraz tak
22:11 <@Gynvael> na dzisiaj to koniec czesci dla poczatkujacych
22:11 <@Gynvael> za chwile bedzie czas na pytania
22:11 <@Gynvael> a potem powiem co nieco o funkcjach z niekreslona i dowolna liczba parametrow
22:12  * d0b0c0p sie cieszy... czeka na walke wieczoru (funkcje z nieokreslona liczba argumentow ;])
22:12 <@salv4tion> a kiedy bedzie czesc za hiper super zawansowanych ;>?
22:12 <@Gynvael> kolejny wyklad moze byc jutro o 10 do 12, albo pojutrze o 21
22:12 <@salv4tion> dla*
22:12 <@Gynvael> i zaraz przeglosujemy
22:12 <@Gynvael> o ktorej pasuje
22:12 <@phoenix__> Gynvael:  10 - 12
22:12 <@d0b0c0p> mi pasuje bardziej o 11 ;]
22:12 <@Gynvael> potem bedzie drugie glosowanie, czy mowic od podstaw o if/for/while/do/switch, czy tylko triki i ciekawostki
22:13 <@seraphin_> 10-12
22:13 <@salv4tion> miedzy 10-12 wstaje siec moze ;>
22:13 <@salv4tion> byc
22:13 <@Gynvael> a potem czas na pytania i czesc dla zaawansowanych
22:13 -!- mode/#gynkurs [-m] by Gynvael
22:13 <@Gynvael> ok
22:13 <@phoenix__> jak nie bedzie mnie przy kompie to loga poczytam
22:13 <@Gynvael> teraz kazdy niech mi privnie
22:13 <@Gynvael> czy pasuje od 10 do 12 jutro, badz czy woli pojutrze o 21
22:13 <@salv4tion> godzine?
22:13 <@seraphin_> Gynvael: czemu ty z roota zasuwasz?:P
22:13 <@Gynvael> seraphin_: bo lubie ;>
22:13 <@salv4tion> seraphin_: haxiorzysz gyna ;>>>
22:13 <@adam_i`2> Gynvael: a ja kebdze jutor o 10-12 to pojutrz niebedize o 21 ?
22:14 <@salv4tion> nieladnie ;p
22:14 <@Gynvael> adam_i`2: bedzie, tyle ze kolejna czesc
22:15 <@Gynvael> ok
22:15 <@Gynvael> ktos jeszcze glosuje ?
22:15 <@Gynvael> ok
22:15 <@salv4tion> Gynvael: ale ofc ja jutro bedzie wyklad nastepny ot pojutrze o 21 tez bedzie tyle ze o czyms innym?
22:15 <@Gynvael> wiec kolejny wyklad jutro o 10
22:16 <@Gynvael> salv4tion: tak
22:16 <@salv4tion> ok
22:16 <@salv4tion> ejj 10?
22:16 <@salv4tion> moze 11 ;p?
22:16 <@Gynvael> salv4tion: WSTTANIESZ WCZESNIEJ! ;ppppppp
22:16 <@salv4tion> :P
22:16 <@salv4tion> ehhh no moze mi sie uda ;D
22:16 <@Gynvael> ok
22:16 <@adam_i`2> salv4tion: tylko nim ze nbiebrsz ial neta o tej bo ja u ceibie logueje
22:16 <@Gynvael> teraz tak
22:16 <@phoenix__> Gynvael: za wczesnie
22:16 <@phoenix__> ja nie wstane
22:16 <@phoenix__> ale trudno
22:16 <@Gynvael> phoenix__: pozniej mnie nie ma --;
22:16 <@salv4tion> adam_i`2: co?
22:16 <@salv4tion> adam_i`2: pisz wyrazniej..
22:16 <@phoenix__> Gynvael: wiem domyslam sie
22:17 <@adam_i`2> salv4tion: niewzne
22:17 <@Gynvael> phoenix__: najwyzej ci jak bede odpowiem na p ytanka dot logow z wykladu
22:17 <@Gynvael> phoenix__: kk ?
22:17 <@phoenix__> kk
22:17 <@Gynvael> ok
22:17 <@Gynvael> teraz DRUGIE GLOSOWANIE
22:17 <@Gynvael> NIECH MI KAZDY NAPISZE NA PRIVA
22:17 <@Gynvael> CZY OMAWIAC FUNKCJE if/for/switch/while/do POBIERZENIE (triki) czy DOKLADNIE OD PODSTAW
22:19 <@Gynvael> dobra
22:19 <@Gynvael> wiec jednoglosnie wybrano OMAWIANIE POBIERZNIE, GLOWNIE TRIKI
22:19 <@phoenix__> KK
22:19 <@salv4tion> ^^
22:20 <@seraphin_> ;)
22:20 <@salv4tion> nyo ja za trikami bylem ;p
22:20 <@SlimFast> nie prawda !!
22:20 <@d0b0c0p> a teraz walka wieczoru?
22:20 <@phoenix__> ja tez 
22:20 <@SlimFast> nei jednoglsonie
22:20 <@SlimFast> ;d
22:20 <@seraphin_> 'rozumiem ze jutro 10-12?
22:20 <@Gynvael> ok
22:20 <@d0b0c0p> SlimFast: ciii
22:20 <@d0b0c0p> nie kloc sie z profesorem Gynvael'em ;]
22:20 <@salv4tion> Gynvael: no to teraz nawijaj dla hardkorowcow only ;>
22:20 <@d0b0c0p> seraphin_: 10:00
22:20 <@Gynvael> od godziny 9 bedzie mozna mnie na privie dorwac
22:20 <@Gynvael> i wtedy wytlumacze podstawy if/for.....
22:21 <@phoenix__> Gynvael: nile wstane o 9 ;]
22:21 <@Gynvael> a od 10 beda glownie triki i hacki
22:21 <@Gynvael> phoenix__: to przy okazji ;>
22:21 <@d0b0c0p> Gynvael: niech ci to Bog wynagrodzi
22:21 <@salv4tion> ;p
22:21 <@salv4tion> Gynvael: a ile planujesz czesci?
22:21 <@Gynvael> d0b0c0p: byle by nie w dzieciach ;p
22:21 <@gRl> godziny otwarcia gyna 9:00-12;00
22:21 <@gRl> :PPP
22:21 <@Gynvael> salv4tion: nie wiem, nie planuje ;>
22:21 <@salv4tion> hmm
22:21 <@Gynvael> gRl: ;p
22:21 <@Gynvael> ok
22:21 <@seraphin_> ja go podziwiam ze on ma czas....
22:21 <@d0b0c0p> lol
22:21 <@Gynvael> teraz.. pytania do tego co bylo
22:21 <@phoenix__> lol
22:21 <@salv4tion> tabliczke trzeba by wystawic ;p
22:21 <@d0b0c0p> kiedy walka wieczoru?
22:21 <@Gynvael> d0b0c0p: po pytaniach
22:21 <@Gynvael> jakies pytanka ?
22:21 <@salv4tion> ja mam
22:21 <@seraphin_> all clear
22:21 <@phoenix__> Gyn ale zes dowalil z tymi dziecmi
22:21 <@phoenix__> dobra nawijaj
22:22 <@seraphin_> [jakimi dziecmi? oO?]
22:22 <@salv4tion> co bylo na wczoraj odrobic na prace domowa? bo nie doczytalem zeby jakas byla zadawana ;p
22:22 <@seraphin_> salv4tion: nvm, olej to
22:22 <@d0b0c0p> salv4tion: sprawdzic rozmiar wszystkich typow w c
22:22 -!- Gynvael changed the topic of #gynkurs to: ciag dalszy (#4) o 10:00 (31.08) temat: if/for/switch/while/do (pobierznie + triki), archiwum kursow: http://salv4tion.ath.cx/~adam/gynkurs/ :] 
22:22 <@adam_i`2> Ja odrobilem
22:22 <@salv4tion> aa
22:22 <@salv4tion> no fakt
22:22 <@salv4tion> ee ja to juz z pol roku temu przerabialem ;p
22:22 <@Gynvael> salv4tion: wypisac wszystkie typy zmiennych i ich wielkosci
22:22 <@Gynvael> ok
22:22 <@Gynvael> teraz tak
22:22 <@Gynvael> good zem i przypomnieli
22:23 <@d0b0c0p> btw. jest to na pl.wikipedia.org
22:23 <@phoenix__> Gynvael: odrobilem ;P
22:23 <@Gynvael> JESLI KTOS MA PRACE DOMOWA, NIECH JA WYSLE NA gynvael@vexillium.org (to mail ;p)
22:23 <@salv4tion> :O
22:23 <@salv4tion> Gynvael: eee
22:23 <@seraphin_> ???
22:23 <@phoenix__> Gyn na priv ci zrodlo wysle
22:23 <@salv4tion> Gynvael: moja widziales keidys ;p
22:23 <@Gynvael> NIE JEST TO KONIECZNIE, PO PROSTU BEDE MOGL SKOMENTOWAC KOD ;>
22:23 <@Gynvael> phoenix__: ne, plz poczta ;>
22:23 <@salv4tion> Gynvael: ja musze ;P?
22:23 <@Gynvael> salv4tion: NIKT NIE MUSI ;>
22:23 <@Gynvael> salv4tion: ale kazdy moze ;>
22:23 <@phoenix__> czemu poczta?
22:23 <@seraphin_> no lol...
22:24 <@Gynvael> phoenix__: bo wtedy nie zginie mi ;>
22:24 <@d0b0c0p> przejdzmy do c moze ;]
22:24 <@seraphin_> ok next ;p
22:24 <@Gynvael> ok
22:24 <@Gynvael> dobra
22:24 <@salv4tion> ee nie che mi sie pisac, juz ci pisalem kiedys takie cos[tez praca domowa, ne gyn ;>?]
22:24 <@phoenix__> Gyn sprawdzisz raz dwa
22:24 <@Gynvael> salv4tion: nie usisz
22:24 <@Gynvael> phoenix__: jak bardzo chcesz to wrzuc
22:24 <@d0b0c0p> salv4tion: cii. plis
22:24 <@Gynvael> ok
22:24 <@Gynvael> phoenix__: ale skomentuje po drugiej czesci wykladu najwczesniej
22:24 <@Gynvael> ok
22:24 -!- mode/#gynkurs [+m] by Gynvael
22:24 <@Gynvael> teraz druga czesc
22:25 <@Gynvael> dla bardziej zaawansowanych
22:25 <@Gynvael> mianowicie funkcje z nieokreslona i dowolna liczba argumentow
22:25 <@Gynvael> najpierw wstep
22:25 <@Gynvael> jest cos takiego jak asembler
22:25 <@Gynvael> i tam jest cos takiego jak STOS
22:25 <@Gynvael> STOS jest to FRAGMENT PAMIECI KTORY ROSNIE W STRONE MNIEJSZYCH ADRESOW
22:26 <@Gynvael> ze stosu korzystaja ZMIENNE LOKALNE I PARAMETRY FUNKCJI
22:26 <@Gynvael> w moemencie wywolania funkcji, jej PARAMETRY SA WRZUCANE NA STOS
22:26 <@Gynvael> dzieki czemu funkcja w momencie wejscia do niej ma nastepujaca sytuacje
22:26 -seraphin_:#gynkurs- wypasnie sie zaczyna :P
22:27 <@phoenix__> ci
22:27 <@Gynvael> WSKAZNIK DNA STOSU (ebp) -> [to nas nie interesuje] [to tez nie] [PARAMETR 1] [PARAMETR 2] [PARAMETR 3]
22:27 <@Gynvael> KAZDY element stosu ma DOKLADNIE 4 bajty
22:27 <@Gynvael> (przez co np parametr typu double jest wrzucany na 2 miejsca w stosie)
22:28 <@Gynvael> jesli cos ma mniej niz 4 bajty (parametr), wtedy wolne miejsca DOPALNIANE SA ZERAMI
22:28 <@Gynvael> np jesli funkcja przyjmuje char, i wywolania jest z parametrem 0
22:28 <@Gynvael> np jesli funkcja przyjmuje char, i wywolania jest z parametrem 1
22:28 <@Gynvael> to na stos leca 3 bajty z zerami i baj z "1"
22:28 <@Gynvael> *bajt
22:28 <@Gynvael> ok
22:29 <@Gynvael> teraz tak
22:29 <@Gynvael> dzieki temu wiemy ze:
22:29 <@Gynvael> PARAMETR DRUGI LEZY DOKLADNIE 4ry BAJTY NA "PRAWO" OD PARAMETRY PIERWSZEGO
22:29 <@Gynvael> zakladajac ze kazdy z nich mial wielkosc 4 lub mniej bajtow
22:29 <@Gynvael> tyle jest wstepu ;>
22:29 <@Gynvael> teraz przyklad 
22:29 <@Gynvael> najpierw funkcje z dowolna iloscia parametrow
22:30 <@Gynvael> przykladem takiej funkcji jest "printf"
22:30 <@Gynvael> aha, odrazu na wstepie zaznaczam: NIE MA ZADNEJ SKUTECZNEJ I ZAWSZE DZIALAJACEJ METODY OKRESLENIA ---NIEJAWNIE--- ILOSCI PARAMETROW KTORE FUNKCJA DOSTALA
22:30 <@Gynvael> wiec trzeba funkcji w jakis posob powiedziec ile parametrow ma sie spodziewac
22:31 <@Gynvael> sposoby sa dwa, o nich za chwile
22:31 <@Gynvael> teraz przyklad funkcji:
22:31 -!- BeOm_soldat is now known as BeOm_
22:31 <@Gynvael> (wg znowu mam lagi do serva)
22:34 <@Gynvael> http://gynvael.vexillium.org/gkex3_1.c
22:34 <@Gynvael> ok
22:34 <@Gynvael> teraz tak
22:34 <@Gynvael> z czego sie sklada program
22:34 <@Gynvael> dwie rzeczy:
22:35 <@Gynvael> 1) definicja funkcji moja_funkcja
22:35 <@Gynvael> 2) definicja main
22:35 <@Gynvael> ale po kolei
22:35 <@Gynvael> definicja funkcji moja_funkcja pobiera:
22:35 <@Gynvael> - argument "ilosc" o typie int
22:35 <@Gynvael> - i inne argumenty w dowolnej ilosci, moze ich nawet nie byc
22:36 <@Gynvael> jak widac "inne argumenty" oznacza sie wielokropkiem, czyli 3ma kropkami
22:36 <@Gynvael> ...
22:36 <@Gynvael> po wielokropku NIE MOZE WYSTAPIC ZADEN JAWNY NAZWANY ARGUMENT
22:36 <@Gynvael> jesli tak zrobimy mozemy spodziewac sie bledu "parse error before ,"
22:37 <@Gynvael> ok
22:37 <@Gynvael> teraz dalej
22:37 <@Gynvael> jako ze wiemy ze argumenty leza na prawo od pierwszego
22:37 <@Gynvael> mozemy zrobic tak:
22:37 -!- kt [~kt@lostpackets.de] has left #gynkurs []
22:37 -!- adam_i`2 [~none@amw158.neoplus.adsl.tpnet.pl] has quit [Ping timeout]
22:37 <@Gynvael> - pobrac adres pierwszego argumentu
22:37 <@Gynvael> - dodac 4ry bajty
22:38 <@Gynvael> - odczytac pierwszy argument
22:38 <@Gynvael> - dodawac po 4ry bajty na kazdy inny argument
22:38 <@Gynvael> jak to w praktyce wyglada ?
22:38 <@Gynvael>   int *adres = &ilosc + 1;
22:38 <@Gynvael> z tego zapewne musze sie wytlumaczyc
22:38 <@Gynvael> caly czas mowie "4ry bajty" "4ry" etc
22:38 <@Gynvael> a tam dodaje sobie 1 
22:38 <@Gynvael> wtf?
22:38 <@Gynvael> o dziwo to nie jest blad ani literowka
22:39 <@Gynvael> jezyk C ma to jakos tak zrobione, ze przy operacjach na adresach
22:39 <@Gynvael> typu wlasnie dodawanie
22:39 <@Gynvael> liczba dodawana jest MNOZONA PRZEZ WIELKOSC ZMIENNEJ WSKAZYWANEJ PRZEZ WSKAZNIK
22:39 <@Gynvael> czyli
22:39 <@Gynvael> int *adres;
22:39 <@Gynvael> adres wskazuje na zmienna typu int
22:39 <@Gynvael> sizeof(int) == 4
22:39 <@Gynvael> wiec
22:39 <@Gynvael> &ilosc + 1
22:40 <@Gynvael> to tak naprawde
22:40 -!- adam_i`2 [~none@amw158.neoplus.adsl.tpnet.pl] has joined #gynkurs
22:40 -!- mode/#gynkurs [+o adam_i`2] by phoe
22:40 <@Gynvael> a
22:40 <@Gynvael> ilosc to "int"
22:40 <@Gynvael> a &ilosc to "int*" (adres inta)
22:40 <@Gynvael> wiec
22:40 <@Gynvael> &ilosc + 1 
22:40 <@Gynvael> to tak naprawde
22:40 <@Gynvael> &ilosc + 1 * sizeof(*(&ilosc))
22:40 <@Gynvael> czyli
22:40 <@Gynvael> &ilosc + 1 * sizeof(ilosc)
22:40 <@Gynvael> &ilosc + 1 * 4
22:41 <@Gynvael> &ilosc + 4 bajty
22:41 <@Gynvael> czyli do adresu jest dodawane / adres jest przesuwany o 4ry bajty
22:41 <@Gynvael> czyli na nastepny argument
22:41 <@Gynvael> o petlach bedzie jutro 
22:41 <@Gynvael> ale dzisiaj juz jedno zastosowanie
22:41 <@Gynvael> zreszta zaawansowani sie zetkneli z tym na pewno ;>
22:42 <@Gynvael> for(; ilosc > 0; ilosc--, adres++)
22:42 <@Gynvael>  printf("dostalem: %i\n", *adres);
22:42 <@Gynvael> czyli krotko
22:42 <@Gynvael> petla zostanie wykonana "ilosc" razy
22:42 <@Gynvael> za kazdym razem na koncu zostanie adres zwiekszony o 1*sizeof(*adres) czyli o 4ry bajty
22:42 <@Gynvael> a printf wypisze za kazdym razem to na co wskazuje adres
22:42 <@Gynvael> czyli kolejne argumenty
22:43 <@Gynvael> tyle jesli chodzi o moja_funkcja
22:43 <@Gynvael> teraz main
22:43 <@Gynvael> w main jest wywolanie moja_funkcja
22:43 <@ron4in> gynvael@vexillium.org/n
22:43 <@Gynvael> z 4rema argumentami
22:43 <@Gynvael> 3, 1, 2, 3
22:43 <@Gynvael> 3 jest liczba argumentow
22:43 <@Gynvael> a reszta to argumenty
22:43 <@Gynvael> "3" jest tylko UMOWNIE liczba argumentow
22:44 <@Gynvael> i jest to pierwszy (lepszy) ze sposobow przemycenia do funkcji ilosci argumentow
22:44 <@Gynvael> ok
22:44 <@Gynvael> kompilacja, odpalamy
22:44 <@Gynvael> root@yume:/code/kurs# gcc gkex3_1.c -Wall -pedantic -o gkex3_1
22:44 <@Gynvael> root@yume:/code/kurs# ./gkex3_1
22:44 <@Gynvael> dostalem: 1
22:44 <@Gynvael> dostalem: 2
22:44 <@Gynvael> dostalem: 3
22:44 <@Gynvael> czyli program ladnie wypisal 3 argumenty
22:45 <@Gynvael> gdybysmy jako ilosc podali "2"
22:45 <@Gynvael> tzn 2
22:45 <@Gynvael> ;>
22:45 <@Gynvael> wtedy wypisane by zostaly tylko 1 i 2
22:45 <@Gynvael> a gdybysmy podali 4
22:45 <@Gynvael> wtedy jako 4rty byly by jakies smieci wypisane
22:45 <@Gynvael> mozemy sprawdzic
22:45 <@Gynvael>   moja_funkcja(4, 1, 2, 3);
22:45 <@Gynvael> root@yume:/code/kurs# gcc gkex3_1.c -Wall -pedantic -o gkex3_1
22:45 <@Gynvael> root@yume:/code/kurs# ./gkex3_1
22:45 <@Gynvael> dostalem: 1
22:45 <@Gynvael> dostalem: 2
22:45 <@Gynvael> dostalem: 3
22:45 <@Gynvael> dostalem: 1075119628
22:45 <@d0b0c0p> Gynvael: a takie male btw... skad printf wie ile ma argumentow? liczy sobie w 1 argumencie ile ma np. %d?
22:45 <@Gynvael> to ostatnie to jakies smieci ktore sa na stosie, prawdopodobnie zmienna w poprzedniej funkcji, badz jakas inna "wazna "rzecz
22:46 <@Gynvael> d0b0c0p: tak
22:46 <@Gynvael> printf ma zastosowany ten sam sposob
22:46 <@Gynvael> co tutaj podalem
22:46 <@Gynvael> ale nie ma podane tego jako LICZBA
22:46  * d0b0c0p jednak mysli =^^=
22:46 <@Gynvael> on sobie po prostu liczy ilosc % w " "
22:46 <@Gynvael> ;>
22:46 <@seraphin_> w8
22:46 <@Gynvael> ok
22:46 <@Gynvael> teraz pytania
22:46 <@seraphin_> w8 w8 w8
22:46 -!- mode/#gynkurs [-m] by Gynvael
22:46 <@Gynvael> ?
22:46 <@salv4tion> ;>
22:47 <@salv4tion> niezly hardkor
22:47 <@d0b0c0p> eee
22:47 <@phoenix__> nyo
22:47 <@d0b0c0p> nie az taki (dla mnie przynajmniej)
22:47 <@seraphin_> a co sie stanie jak do printfa wsadze dwadzieescia %i na przyklad  a dam tylko 3 agrumrnty?
22:47 <@seraphin_> to nie jest az takie trudne
22:47 <@seraphin_> Gynvael: wywali mi kupe stosu?
22:47 <@salv4tion> eheh
22:48 <@gRl> pewnie wywali ... blad ;f
22:48 <@d0b0c0p> gRl: max. waring
22:48 <@Gynvael> seraphin_: tak
22:48 <@seraphin_> hmmm no to by sie zgadzalo
22:48 <@salv4tion> ta
22:48 <@Gynvael> gRl: przy -Wall -pedantic powinien wywalic warning
22:48 <@adam_i`2> Bedzie jezcze jaksi zawnsowyn kurs czy jzu robic loga ?
22:48 <@Gynvael> adam_i`2: dopiero 1/3 o tym
22:48 <@adam_i`2> aha
22:50 <@salv4tion> ;o
22:50 <@Gynvael> adam_i`2: jeszcze drugi sposob okreslania jawnego ilosci zmiennych
22:50 <@phoenix__> ;]
22:50 <@Gynvael> adam_i`2: biblioteka stdarg
22:50 <@seraphin_> mmm ciekawe
22:50 <@Gynvael> adam_i`2: i funkcje z nieokreslona liczba argumentow ;>
22:50 <@d0b0c0p> konec pytan (wyrecze Gynvael'a)? :)
22:50 <@Gynvael> ok
22:50 <@Gynvael> koniec pytan?
22:50 <@seraphin_> koniec
22:50 <@salv4tion> [;
22:50 -!- Blizzus [blizzard@frycek.net] has joined #gynkurs
22:50 -!- mode/#gynkurs [+o Blizzus] by phoe
22:50 <@adam_i`2> A neida sie jaks ze sie wrzcua najpeirw adres wirzchokla I potem na konie ct tez
22:50 <@Blizzus> skonczylo sie juz?
22:50 <@Blizzus> ;x
22:50 <@Blizzus> heh
22:50 <@d0b0c0p> ne ;p
22:50 <@Gynvael> Blizzus: ne, czesc zaawansowana wlasnie
22:50 <@d0b0c0p> teraz hardcore
22:50 <@d0b0c0p> (tzn. nie az taki :P) - przesadzilem
22:50 <@Gynvael> adam_i`2: jest to jedna z metod, ale powiedzmy szczerze, nie ma dobrej metody oprogramowania tego ;>
22:50 <@Gynvael> d0b0c0p: hardcore bedzie za chwile ;>
22:50 <@d0b0c0p> i dobrze =^^=
22:50 <@Gynvael> ok
22:50  * d0b0c0p lubi wyzwania
22:50 <@Gynvael> moge dalej ?
22:50 <@adam_i`2> ta
22:50 <@d0b0c0p> ofc
22:50 <@seraphin_> ta
22:51 -!- mode/#gynkurs [+m] by Blizzus
22:51 <@Blizzus> :)
22:51 <@Gynvael> ok
22:51 <@Blizzus> dajesz
22:51 <@Gynvael> teraz drugi sposob
22:51 <@Gynvael> http://gynvael.vexillium.org/gkex3_2.c
22:51 <@Gynvael> w pierwszym sposobie podawalismy ilosc zmiennych
22:51 <@Gynvael> w drugim stosujemy TERMINATOR
22:51 <@Gynvael> czyli JAKAS WARTOSC ZMIENNEJ, PO NAPOTKANIU KTOREJ NASZA FUNKCJA STWIERDZA ZE TO JUZ KONIEC ARGUMENTOW
22:51 <@Gynvael> void moja_funkcja(int arg1, ...)
22:51  * d0b0c0p wg mnie to nie jest taki bardzo hardcore
22:52 <@Gynvael> {
22:52 <@Gynvael>   int *adres = &arg1;
22:52 <@Gynvael> d0b0c0p: to jeszcze nie to o czym mowilem ;p
22:52 <@Gynvael>   for(; *adres != -1; adres++)
22:52 <@Gynvael>    printf("dostalem: %i\n", *adres);
22:52 <@Gynvael> }
22:52 <@d0b0c0p> ;]
22:52 <@Gynvael> teraz tak
22:52 <@Gynvael> jak to dziala
22:52 <@d0b0c0p> moge sie wtracic?
22:52 <@Gynvael> d0b0c0p: mow ...
22:52 <@d0b0c0p> sorki
22:52 <@Blizzus> o kurwa to juz sa wskazniki?
22:52 <@d0b0c0p> wg mnie to nie jest dobry pomysl, jak bedzie terminator 5, i bedzie wartosc 5 to kupa
22:53 <@Gynvael> Blizzus: ta
22:53 <@Gynvael> d0b0c0p: hehe wlasnie o tym chcialem mowic ;>
22:53 <@d0b0c0p> sorki, juz nei przeskadzam ;)
22:53 <@Gynvael> ok
22:53 <@Gynvael> wiec kontynuuje
22:53 -!- mode/#gynkurs [-o d0b0c0p] by d0b0c0p
22:53 <@Blizzus> dobra koncze z wami kurs bo ja tego nie czaje;\ chyba ze bylo fajnie wytlumaczone wyzej
22:53 -!- Necrium [healscream@sido.us] has joined #gynkurs
22:53 -!- mode/#gynkurs [+o Necrium] by phoe
22:53 <@Gynvael> Blizzus: bylo ;>
22:53 <@Blizzus> przeczytam potem
22:53 <@Gynvael> Blizzus: teraz jest czesc dla zzawansowanych ;> wskazniki byly w czesci dla poczatkujacych
22:53 -!- mode/#gynkurs [-o Blizzus] by Blizzus
22:53 <@Gynvael> Blizzus: poczekaj na loga i poczytaj ;>
22:54 <@Gynvael> ok
22:54 <@Gynvael> dalej
22:54 <@Gynvael> wiec
22:54 <@Gynvael> dziala to tak:
22:54 <@Gynvael> adres jest ustawiany na adres pierwszego argumentu
22:54 <@Gynvael> a potem dopoki to na co wskazuje adres nie ma wartosci -1, wypisuje wartosci
22:54 <@Gynvael> przykladowe wywolanie to
22:54 <@Gynvael> moja_funkcja(1,2,3,-1);
22:55 <@Gynvael> wypisze to
22:55 <@Gynvael> dostalem: 1
22:55 <@Gynvael> dostalem: 2
22:55 <@Gynvael> dostalem: 3
22:55 <@Gynvael> ofc sposob jest o tyle zly, ze jesli uzywamy PELNEGO ZAKRESU ZMIENNEJ, to nie mozemy uzyc zadnej wartosci jako terminator
22:55 <@Gynvael> np jesli chcieli bysmy podac -1 jako argument tutaj
22:55 <@Gynvael> to byl by problem
22:55 <@Gynvael> moja_funkcja(1,-1,2,3,-1);
22:55 <@Gynvael> to wypisze tylko "dostalem: 1"
22:56 <@Gynvael> wiec mozem przestawic -1 na -2
22:56 <@Gynvael> ale.. jak bysmy chcieli wypisac -2 jako argument... to...
22:56 <@Gynvael> etc
22:56 <@Gynvael> wiec albo jako terminatora uzywamy jakiejs wartosci ktora na 100% nie ma prawa sie pojawic
22:56 <@Gynvael> albo nie uzywamy tego sposobu
22:56 -!- d13t3r [~x@g31.softel.elblag.pl] has joined #gynkurs
22:57 -!- mode/#gynkurs [+o d13t3r] by phoe
22:57 <@Gynvael> ok
22:57 <@Gynvael> tyle o tym sposobie
22:57 <@Gynvael> a
22:57 <@seraphin_> moge wtracic?
22:57 <@Gynvael> jeszcze jedno
22:57 <@Gynvael> seraphin_: chwila ;>
22:57 <@seraphin_> k
22:57 <@Gynvael> zmienne podawane w ramach "..." moga miec dowolny typ
22:57 <@Necrium> Gynvael: mozesz na sekundeczke priv ?
22:57 <@Gynvael> my tutaj interpretujemy wszystko jako int
22:57 <@Gynvael> jesli parametrem bedzie cos innego niz int
22:57 <@Gynvael> to funkcja MUSI JAKOS O TYM WIEDZIEC
22:57 <@d13t3r> ee o czym mowa?
22:57 <@Gynvael> printf ma te swoje %f, %i %d 
22:58 <@Gynvael> dzieki temu wie jaki typ ma odczytywac ze stosu
22:58 <@phoenix__> d13t3r: ciii
22:58 <@Gynvael> ok
22:58 <@Gynvael> Necrium: ok
22:58 <@Gynvael> seraphin_: mow
22:58 <@seraphin_> Gynvael: wlasnie mi to wyjasniles ;)
22:58 <@d13t3r> oki o widze ze o stringach
22:58 <@Gynvael> seraphin_: ok
22:58 <@seraphin_> jasnowidz :D
22:58 <@Gynvael> d13t3r: ne, o funkcjach z dowlolna liczba argumentow
22:58 <@d13t3r> aha to proste
22:59 <@seraphin_> dobra ja zawijam, jutro lookne w loga
22:59 <@seraphin_> narazie
22:59 <@seraphin_> thx GYn
22:59 <@Gynvael> ok
22:59 <@Gynvael> ;>
22:59 <@Gynvael> pa seraphin_ 
22:59 <@Gynvael> teraz dalej
22:59 <@Gynvael> czyli biblioteka stdarg.h
22:59 <@Gynvael> poczytac o niej mozemy w manie: man stdarg
23:00 <@Gynvael> jest to w sumie zestaw makr i funkcji
23:00 <@Gynvael> ktore maja za zadanie ulatwic (?!) zycie przy ...
23:00 <@d13t3r> dobra lukne w loga a nie bede sie wtracal bye all
23:00 -!- d13t3r [~x@g31.softel.elblag.pl] has left #gynkurs []
23:00 <@Gynvael> przyklad leci na serv
23:00 -!- Blizzus [blizzard@frycek.net] has left #gynkurs []
23:00 -!- Blizzus [blizzard@frycek.net] has joined #gynkurs
23:00 -!- mode/#gynkurs [+o Blizzus] by phoe
23:01 <@Gynvael> lag..
23:01 <@Gynvael> wiec chwila na pytania dot tego co bylo
23:01 -!- mode/#gynkurs [-m] by Gynvael
23:01 <@Blizzus> Gynvael: btw. sa/beda zrodla(przyklady) na serv wrzucone?
23:01 <@Gynvael> Blizzus: sa
23:01 <@Blizzus> ok
23:01 < d0b0c0p> Gynvael: o co chodzi z stdarg.h? :|
23:01 <@Gynvael> Blizzus: http://gynvael.vexillium.org/gk3_1.c do 3_6.c
23:02 <@Gynvael> Blizzus: i teraz leci gkex3_1.c do 3_3 (bedzie do 3_4
23:02 <@Gynvael> d0b0c0p: o tym za chwile
23:02 < d0b0c0p> aha... kk ;)
23:03 < d0b0c0p> ale sie dzisiaj nasze spotkanie przeciagnelo ;)
23:04 < d0b0c0p> myslalem, ze to myk-myk, 30-min, a tu poand 2:30 h :)
23:04 < d0b0c0p> (to dobrze)
23:04 -!- Mnemonic_ [~m@ads133.internetdsl.tpnet.pl] has joined #gynkurs
23:04 -!- mode/#gynkurs [+o Mnemonic_] by phoe
23:04 <@Mnemonic_> hi all
23:04 <@Gynvael> ;>
23:05 <@Gynvael> ok
23:05 <@Gynvael> wiec dalej
23:05 -!- mode/#gynkurs [+m] by Gynvael
23:05 <@Gynvael> http://gynvael.vexillium.org/gkex3_3.c
23:05 <@Gynvael> to samo co ex3_1 ale zrobione za pomoca stdarg.h
23:05 <@Gynvael> o tym krotko bo tego nie lubie ;>
23:06 -!- Necrium [healscream@sido.us] has quit ["Lost terminal"]
23:06 <@Gynvael> najpierw tworzy sie zmienna typu "va_list"
23:06 <@Gynvael> jest to lista argumentow
23:06 -!- Nekrataal [~Nekrataal@dfy82.neoplus.adsl.tpnet.pl] has quit [Operation timed out]
23:06 <@Gynvael> nastepnie wywoluje funkcje (makro) va_start z ow zmienna w pierwszym parametrze
23:06 <@Gynvael> oraz nazwa pierwszego parametru w drugim parametrze
23:07 <@Gynvael> ona ustawia liste_argumentow argi na kolejne argumenty
23:07 <@Gynvael> tzn nei tyle pierwszego parametru nazwe sie podaje
23:07 <@Gynvael> co ostatniego przed "..."
23:07 <@Gynvael> ok
23:07 <@Gynvael> i dalej
23:07 <@Gynvael> teraz w printf jest wywolanie
23:07 <@Gynvael> (int) va_arg(argi, int)
23:07 <@Gynvael> (int) to rzutowanie tego co zwroci makro va_arg na typ int
23:07 <@Gynvael> (prawdopodobnie niekonieczne, ale dla bezpieczenstwa nie zaszkodzi)
23:08 <@Gynvael> argi to lista 
23:08 <@Gynvael> a int to typ za jaki uznajemy ten argument
23:08 <@Gynvael> va_arg zwraca wartosc argumentu danego, i przechodzi na nastepny
23:08 -!- Nekrataal [~Nekrataal@dfs168.neoplus.adsl.tpnet.pl] has joined #gynkurs
23:08 -!- mode/#gynkurs [+o Nekrataal] by phoe
23:08 <@Gynvael> po wszystkim nalezy wywolac va_end(argi)
23:08 <@Gynvael> wywoalanie jak w 3_1
23:08 <@Gynvael> czyli
23:09 <@Gynvael> moja_funkcja(3,1,2,3)
23:09 <@Gynvael> daje
23:09 <@Gynvael> root@yume:/code/kurs# ./gkex3_3
23:09 <@Gynvael> dostalem: 1
23:09 <@Gynvael> dostalem: 2
23:09 <@Gynvael> dostalem: 3
23:09 <@Gynvael> tyle jesli chodzi o to
23:09 <@Gynvael> ogolnie mozna tego uzywac
23:09 <@Gynvael> jest to pewniejsza rzecz niz te poprzednie sposoby
23:09 <@Gynvael> ale... ;>
23:09 <@Gynvael> jak widac wymaga wiecej zachodu
23:10 <@Gynvael> wspomne jeszcze tylko
23:10 <@Gynvael> ze w bibliotece stdarg.h sa funkcje takie jak
23:10 <@Gynvael> vsprintf, vfprintf, vsscanf etc
23:10 <@Gynvael> ktore dzialaja analogicznie jak printf czy scanf, z tym ze dzialaja dla argumentow naszej funkcji
23:11 <@Gynvael> (to sposob zeby printf przekazac nieokreslona ilosc argumentow)
23:11 <@Gynvael> ok
23:11 <@Gynvael> tyle o tym
23:11 <@Gynvael> jakies pytania ? jeszcze tylko pare slow bedzie o funkcjach z ()
23:11 -!- mode/#gynkurs [-m] by Gynvael
23:15 < d0b0c0p> wg mnie ciekawy sposob ;)
23:15 <@Gynvael> swoja droga to va_* to makra, ktore robia dokladnie to samo co podalem w 3_1 i 3_2
23:15 <@adam_i`2> Gynvael: a jak dzilaja te funkcje ?
23:15 <@Gynvael> adam_i`2: ktore ?
23:15 <@adam_i`2> Ok oto mo chodzilo
23:15 <@BeOm_> tia..dalej ten kurs jest?
23:15 <@Gynvael> hehe ta
23:15 <@Gynvael> wlasnie sie powoli konczy
23:15 < d0b0c0p> BeOm_: a czemu nie? ;>
23:15 <@Gynvael> wlasnie ostatnia rzecz bedzie
23:15 <@BeOm_> toporni ucznoiwie ? :P
23:15 < d0b0c0p> Gynvael: hardcore rzecz?
23:15 < d0b0c0p> BeOm_: ja tak ;>
23:15 <@Gynvael> d0b0c0p: yep;>
23:15 <@Gynvael> ok
23:15 <@Gynvael> to jeszcze pytania
23:15  * d0b0c0p walka wieczoru - ostatnia runda ;>
23:15 <@Gynvael> a ja przyklady na serv wrzuce
23:15 < d0b0c0p> tylo pytan?
23:15 <@Mnemonic_> Gynvael to konczmy ta flaszke ;)
23:17 <@adam_i`2> Tak patrz ze na 10 kursei tu juz ebdze wicj osb niz na #uw-team
23:18 <@phoenix__> adam_i`2: nio
23:18 <@phoenix__> ja jeszcze moze kogos siagne ;]
23:18 <@Gynvael> ok
23:18 <@Gynvael> wiec
23:18 <@Gynvael> lecimy
23:18 <@phoenix__> +m
23:18 -!- mode/#gynkurs [+m] by Gynvael
23:19 <@Gynvael> teraz czesc bardziej hardcore'owa
23:19 <@Gynvael> mianowicie przed chwila
23:19 <@Gynvael> mielismy podane przed ... jakies zmienne
23:20 <@Gynvael> i dzieki tym zmiennym moglismy ustalic dokladnie adres nastepnych zmiennych
23:20 <@Gynvael> a teraz pobawimy sie brakiem zmiennych wogole
23:20 <@Gynvael> mianowicie deklaracja funkcji z ()
23:20 <@Gynvael> void moja_funkcja()
23:20 -!- M34L [^M34L@ccn21.neoplus.adsl.tpnet.pl] has joined #gynkurs
23:20 -!- mode/#gynkurs [+o M34L] by phoe
23:20 <@Gynvael> przed przykladami powiem tylko jedna wazna rzecz
23:21 <@Gynvael> wspomnialem ze argumenty sa wrzucane na stos
23:21 -!- M34L [^M34L@ccn21.neoplus.adsl.tpnet.pl] has left #gynkurs [JA TU JESZCZE WROOCE!!!]
23:21 <@Gynvael> dodalem tez ze zmienne lokalne rowniez korzystaja ze stosu
23:21 <@Gynvael> zeby bylo smieszniej, sa one wrzucane na stos
23:21 <@Gynvael> wiec
23:21 <@Gynvael> powiedzmy ze nasza funkcja ma 3 zmienne lokalne
23:21 <@Gynvael> a b i c
23:21 <@Gynvael> deklarowane w tej kolejnosci:
23:21 <@Gynvael> int a, b, c;
23:22 <@Gynvael> wiec stos wyglada tak:
23:22 <@Gynvael> [c] [b] [a] WSKAZNIK_DNA_STOSU(ebp) -> [costam] [costam] [arg1] [arg2] [arg3]
23:22 <@Gynvael> czyli za pomoca adresu zmiennej a mozemy okreslic polozenie arg1
23:23 <@Gynvael> aha
23:23 <@Gynvael> wazna uwaga
23:23 <@Gynvael> to co teraz mowie DZIALA TYLKO BEZ OPTYMALIZACJI ;.
23:23 <@Gynvael> ;>
23:24 <@Gynvael> wiec nalezy to traktowac JAKO CIEKAWOSTKE ;>
23:24 <@Gynvael> funkcje z () uzywane sa tylko przy "wskaznikach na funkcje", ale o tym kiedys indziej
23:24 <@Gynvael> jako tako same dla siebie nie sa uzywane
23:24 <@Gynvael> ale kontynuujac
23:24 <@Gynvael> mozemy wiec powiedziec ze zmienna [a] lezy o 3 miejsca na lewo od [arg1]
23:24 <@Gynvael> czyli &arg1 == &a+3
23:24 <@Gynvael> wiec....
23:25 <@Gynvael> http://gynvael.vexillium.org/gkex3_5.c
23:25 <@Gynvael> e
23:25 <@Gynvael> nie to
23:25 <@Gynvael> http://gynvael.vexillium.org/gkex3_4.c
23:25 <@Gynvael> ;>
23:25 <@Gynvael> to pierwsze za chwile
23:25 <@Gynvael> ;>
23:25 <@Gynvael> void moja_funkcja()
23:25 <@Gynvael> {
23:25 <@Gynvael>   int *adres = ( (int*)&adres ) + 3;
23:25 <@Gynvael>   int ilosc = *adres++;
23:25 <@Gynvael>   for(; ilosc > 0; ilosc--, adres++)
23:25 <@Gynvael>     printf("dostalem: %i\n", *adres);
23:25 <@Gynvael> }
23:25 <@Gynvael> wiec
23:25 <@Gynvael> co sie dzieje
23:25 <@Gynvael> najpierw mamy taka ciekawa linie
23:25 <@Gynvael> int *adres = ( (int*)&adres ) + 3;
23:25 <@Gynvael> co tu sie dzieje ?
23:26 <@Gynvael> &adres to adres zmiennej "adres" zawierajacy adres do zmiennej typu int;p
23:26 <@Gynvael> jest on nastepnie rzutowany na adres (int*)
23:26 <@Gynvael> i dodawane jest do niego 3*sizeof(int) bajtow 
23:26 <@Gynvael> czyli przesuwany o 3 pola stosu w prawo
23:26 <@Gynvael> int ilosc = *adres++;
23:27 <@Gynvael> pierwszym argumentem jest u nas ilosc, wiec odcztuje ja do zmiennej ilosc i przesuwam dalej
23:27 <@Gynvael> a nastepnie jez znana z 3_1 petla ;>
23:27 <@Gynvael> to jest pierwszy sposoob
23:27 <@Gynvael> zobaczmy czy dziala
23:27 <@Gynvael> root@yume:/code/kurs# gcc gkex3_4.c -Wall -pedantic -o gkex3_4    
23:27 <@Gynvael> root@yume:/code/kurs# ./gkex3_4
23:27 <@Gynvael> dostalem: 1
23:27 <@Gynvael> dostalem: 2
23:27 <@Gynvael> dostalem: 3
23:27 <@Gynvael> wywolanei w main to ofc moja_funkcje(3,1,2,3)
23:27 <@Gynvael> wiec dziala
23:27 <@adam_i`2> int ilosc = *adres++;
23:28 <@adam_i`2> Nei tu
23:28 <@Gynvael> a
23:28 <@Gynvael> dodam ze int ilosc = *adres++ to sa 3 linie w jednym
23:28 <@Gynvael> mianowicie:
23:28 <@Gynvael> int ilosc;
23:28 <@Gynvael> ilosc = *adres;
23:28 <@Gynvael> adres++;
23:28 <@Gynvael> taka zaleta C ;> mozna ladnie zwiezle pisac ;>
23:28 <@Gynvael> ok
23:28 <@Gynvael> teraz tak
23:28 <@Gynvael> ten sposob opieral sie na adresie zmiennej lokalnej
23:28 <@Gynvael> jednak pokazalem na tym "diagramie" tez
23:28 <@Gynvael> [c] [b] [a] WSKAZNIK_DNA_STOSU(ebp) -> [costam] [costam]  [arg1] [arg2] [arg3]
23:29 <@Gynvael> ze jest cos takiego jak "esp", WSKAZNIK DNA STOSU
23:30 <@Gynvael> i on wskazuje na [costam] ktore jest o 2 miejsca od [arg1]
23:30 <@Gynvael> wiec mozna skorzystac z niego 
23:30 -!- b3x [buterux@pstryk.net] has quit [Ping timeout]
23:30 <@Gynvael> z tym ze tutaj trzeba uzyc wstawki asemblera
23:30 <@Gynvael> ktore w gcc sa wyjatkowo toporne ;>
23:30 <@Gynvael> http://gynvael.vexillium.org/gkex3_5.c
23:30 <@Gynvael> najdziwniejsza linia tam jest
23:31 <@Gynvael>   asm ( "movl %%ebp, %0" : "=g"(adres) );
23:31 <@Gynvael> nie zaglebiajac sie teraz w szczegoly (bo asm() w gcc to historia naa pare godzin)
23:31 <@Gynvael> powiem ze ta linia realizuje logicznie cos takiego:
23:31 <@Gynvael> adres = ebp; 
23:31 <@Gynvael> ;>
23:31 <@Gynvael> nastepnie mamy adres += 2; czyli przesuniecie o 2 pola stosu
23:31 <@Gynvael> a reszte juz znamy
23:31 <@Gynvael> sprawdzenie czy dziala
23:32 <@Gynvael> root@yume:/code/kurs# gcc gkex3_5.c -Wall -pedantic -o gkex3_5
23:32 <@Gynvael> root@yume:/code/kurs# ./gkex3_5
23:32 <@Gynvael> dostalem: 1
23:32 <@Gynvael> dostalem: 2
23:32 <@Gynvael> dostalem: 3
23:32 -!- b3x [buterux@pstryk.net] has joined #gynkurs
23:32 <@Gynvael> dodam tylko jeszcze ze przy dodaniu opcji optymalizacyjnych
23:32 <@Gynvael> czyli np -O3 albo -O2
23:33 <@Gynvael> oba sposoby sie ladnie wykszaczaja ;>>.
23:33 <@Gynvael> ok
23:33 <@Gynvael> tyle ;>
23:33 <@Gynvael> na dzisiaj dziekuje za uwage
23:33 -!- mode/#gynkurs [-m] by Gynvael
23:33 <@Gynvael> pytania ?
23:33 <@adam_i`2> Ja niemam
23:33 <@phoenix__> nie
23:33 < d0b0c0p> chyba wszyscy spia ;]
23:33 <@Gynvael> eheheh
23:33 <@Gynvael> anom
23:33 < d0b0c0p> bardzo dziekuje ;]
23:33 < d0b0c0p> na prawde, nie wiem jak sie odwdziecze ;>
23:33 <@Gynvael> adam_i`2: masz calego loga z dzisiaj ?
23:33 <@adam_i`2> Tez dziekuje
23:33 <@Gynvael> adam_i`2: bo cie pare razy wywalilo
23:33 < d0b0c0p> jakbys cos chcial (chociaz watpie) to wal smialo
23:33 <@ron4in> ja mam sieczke z mozgu po tym kursie ;P
23:33 <@Gynvael> hehehe spoko
23:33 <@adam_i`2> Gynvael: nom
23:34 <@Gynvael> adam_i`2: ok, tyo wrzuc plz ;> thx
23:34 < d0b0c0p> ja tylko z asm mam sieczke m00zg00
23:34 <@adam_i`2> Gynvael: utne tylko pcztek I wrzucam
23:34 <@Mnemonic_> ja musze sobie calego loga zassac
23:34 <@Gynvael> ok
23:34 <@Gynvael> thx