OldComp.cz

Komunitní diskuzní fórum pro fanoušky historických počítačů


Právě je 28.03.2024, 18:13

Všechny časy jsou v UTC + 1 hodina [ Letní čas ]




Odeslat nové téma Odpovědět na téma  [ Příspěvků: 159 ]  Přejít na stránku Předchozí  1, 2, 3, 4, 5 ... 11  Další
Autor Zpráva
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 09:25 
Offline
Óm Nejvyšší

Registrován: 22.05.2013, 21:14
Příspěvky: 3642
Bydliště: Bratislava
Has thanked: 371 times
Been thanked: 788 times
Zopar poznamok :slap: z pohladu demosceny :poke:

Pravidlo srozumitelnosti: Srozumitelnost je lepší než šikovnost.
Efektivita je este lepsia ako zrozumitelnost.

Pravidlo oddělování: Oddělujte postupy od mechanismů; oddělujte rozhraní od nástrojů.
Oddelte svoje myslenie od klasickych zauzivanych zvykov a snazte sa na problem pozriet z uplne opacnej strany.

Pravidlo přehlednosti: Programujte přehledně, aby byly audity kódu a odstraňování chyb jednodušší.
Ak budete programovat prehladne, druhi vase postupy a algoritmy rychlejsie okopiruju.

Pravidlo robustnosti: Robustnost je potomek přehlednosti a jednoduchosti.
Robustnost je nepriatelom efektivity.

Pravidlo nejméně překvapivého: Při návrhu rozhraní vždy dělejte tu nejméně překvapivou věc.
Prave prekvapive veci umoznia program vyznamne zefektivnit.

Pravidlo opravy: Musíte-li selhat, selžete hlasitě a co nejdříve.
Zlyhanie je nepripustne. Ak sa "musi zlyhat", prvotna pricina chyby bude pravdepodobne niekde medzi stolickou a klavesnicou.

Pravidlo úspornosti: Programátorův čas je drahý, šetřte ho použitím strojového času.
Problem ale nastava ked ten strojovy cas je obmedzeny, resp. potrebujeme do daneho strojoveho casu natlacit co najviac cinnosti. V takom pripade sa situacia obracia - strojovy cas je drahsi ako cas programatora.

Pravidlo rozmnožování: Vyhněte se ručnímu psaní kódu; kdykoliv to jde, pište programy, které píšou další programy.
Ziadny program (vratane kompilerov) nedokaze napisat tak efektivny program ako clovek ktory pozna danu platfotmu. Pokial ma byt program co najefektivnejsi ako je to len mozne, rucne pisanie kodu je jedina spravna cesta.

Pravidlo optimalizace: Vytvořte správně fungující program, než ho začnete optimalizovat.
Na optimalizaciu je potrebne mysliet hned od zaciatku, pretoze ked sa 'nejak zlepi' sice funkcny, ale velmi neefektivny program, clovek sa tym obvykle "zabetonuje" do urciteho typu myslenia (daneho (casto prisernou) stavbou napisaneho programu) a tazsie sa mu potom vymysla ako dany problem vyriesit lepsie a efektivnejsie.

Pravidlo ticha: Nemá-li program co nového říct, neměl by říkat nic.
Toto je hadam jedine pravidlo s ktorym sa da bezvyhradne suhlasit.

:lol:


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 10:47 
Offline
Radil

Registrován: 08.10.2013, 18:00
Příspěvky: 296
Has thanked: 12 times
Been thanked: 228 times
Shrnul bych to tak, že je to pro všechny lidské činnosti stejné:

Aby se člověk ze začátečníka stal pokročilým, potřebuje se naučit a vžit si základní pravidla.
Aby se z pokročilého stal mistr, musí se naučit kdy, proč a jak pravidla porušit :)


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 17:57 
Offline
Pan Generální
Uživatelský avatar

Registrován: 23.03.2014, 20:13
Příspěvky: 2773
Has thanked: 224 times
Been thanked: 601 times
berk píše:
C-čko se narodilo pro UNIX, tak snad nebudu příliš off-topic když uvedu následující:

Filosofie Unixu podle Eric S. Raymonda:

Pravidlo modularity: Pište jednoduché části, které budou spojeny bezchybným rozhraním.
Pravidlo srozumitelnosti: Srozumitelnost je lepší než šikovnost.
Pravidlo kompozice: Navrhujte programy tak, aby mohly být napojeny na jiné programy.
Pravidlo oddělování: Oddělujte postupy od mechanismů; oddělujte rozhraní od nástrojů.
Pravidlo jednoduchosti: Programujte jednoduše; složitě jen tam, kde je to nezbytné.
Pravidlo úspornosti: Pište rozsáhlé programy jen je-li zřejmé, že to jiným způsobem nejde.
Pravidlo přehlednosti: Programujte přehledně, aby byly audity kódu a odstraňování chyb jednodušší.
Pravidlo robustnosti: Robustnost je potomek přehlednosti a jednoduchosti.
Pravidlo reprezentace: Převeďte znalosti do kódu, aby mohl být program hloupý a robustní.
Pravidlo nejméně překvapivého: Při návrhu rozhraní vždy dělejte tu nejméně překvapivou věc.
Pravidlo ticha: Nemá-li program co nového říct, neměl by říkat nic.
Pravidlo opravy: Musíte-li selhat, selžete hlasitě a co nejdříve.
Pravidlo úspornosti: Programátorův čas je drahý, šetřte ho použitím strojového času.
Pravidlo rozmnožování: Vyhněte se ručnímu psaní kódu; kdykoliv to jde, pište programy, které píšou další programy.
Pravidlo optimalizace: Vytvořte správně fungující program, než ho začnete optimalizovat.
Pravidlo pestrosti: Nevěřte pouze v jedno správné řešení.
Pravidlo rozšiřitelnosti: Plánujte do budoucnosti, protože ta přijde dříve, než si myslíte.

Ano, klidně ti podepíšu cokoliv co ESR o programování prohlásí, dobře ví o čem mluví a má v každém bodě naprostou pravdu. Nakonec, jeho geniální "The Art of Unix Programming" je jedna z nejlepších učebnic programování jaké znám, přitom neobsahuje ani jediný příkaz jakéhokoliv programovacího jazyka!

Jenže ten samý ESR má na svém webu kultovní textík o Opravdovém Programátorovi, a nepřekvapilo by mě kdyby si ho četl na povzbuzení v těžkých chvílích: http://www.catb.org/jargon/html/story-of-mel.html

Céčko prostě umožňuje věci které by Mel Kaye nepochybně ocenil:
Kód:
printf("%d se %srovná %d\n",a,(a==b)?"":"ne",b);

Je to ten v košili vpravo nahoře:
Obrázek

_dworkin píše:
faraon píše:
Takže ANSI C nebo C90 je prostě jistota, zatímco novinky ve stylu for (int i=0;i<10;++i) těžko trávím.

Me to prave prijde jako lepsi reseni nez s tvarit ze ta promena je "globalni" a pouzit ji nekolikrat na ruzne veci.

Kromě toho, opravdoví borci dokážou ANSI C překládat do assembleru z hlavy přímo na papíře, a nepotřebují k tomu žádný optimalizující kompilátor, ten jazyk je prostě přenositelný assembler sám o sobě. Takže nevím jestli mu novinky převzaté z Javy a C# prospějí, mě připadá že kazí čistotu toho jazyka. Pro mě je nejpřehlednější mít všechny deklarace proměnných vždy na jednom místě - na začátku bloku. A tady se najednou můžou cpát i jinam, kde se ztrácí v ostatním kódu!

P.S. "Story of Mel" v češtině: http://www.zive.cz/clanky/hacky-a-hacke ... fault.aspx Trochu slabší překlad, ale stačí :)

_________________
Plesnivý sýr z Tesca, zatuchlé kuřecí řízky z Albertu, oslizlé hovězí a myší trus z Lidlu.
Nákup potravinářské inspekce v ČR, říjen 2023.


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 22:11 
Offline
Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1100
Has thanked: 100 times
Been thanked: 157 times
Ja to nechapu. Jaky je rozdil mezi
Kód:
main () {
   ...
   {
      int i;
      for (i=10;i;i--) neco();
   }
   ...
}
a
Kód:
main () {
   ...
   for (int i=10;i;i--) neco();
   ...
}

Oboji rika prekladaci, potrebuji na tuhle konkretni vec citac a pak si s tim... delej co chces. Jeden zapis se ti libi a druhy ne.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 22:29 
Offline
Radil
Uživatelský avatar

Registrován: 13.05.2013, 17:48
Příspěvky: 529
Bydliště: Košice
Has thanked: 423 times
Been thanked: 265 times
V prvom prípade je premenná i viditeľná aj po skončení cyklu.
V druhom prípade je premenná i lokálnou premennou v rámci bloku, ktorý je v tomto prípade reprezentovaný samotným cyklom for.

_________________
https://pmd85.borik.net - PMD 85 Emulátor, PMD 85, PMD 32-SD
https://pp01.borik.net - PP 01 Emulátor, PP 01, SD-ROM Modul


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 23:09 
Offline
Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1100
Has thanked: 100 times
Been thanked: 157 times
Schvalne jsem ten citac nepouzil po skonceni cyklu for. Protoze to ma byt lokalni pomocna promena a nezajima me co bylo predtim ani co bude potom, potrebuji ji jen v tom jednom miste. V obou pripadech uz neexistuje pri druhem "...".

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 23.10.2015, 23:24 
Offline
Radil

Registrován: 27.09.2014, 23:56
Příspěvky: 446
Has thanked: 436 times
Been thanked: 230 times
Ok. Specializací demoscény je tvorba tzv. dem, což jsou neinteraktivní audiovizuální díla ve formě počítačových programů...

>>Pravidlo srozumitelnosti: Srozumitelnost je lepší než šikovnost.
>Efektivita je este lepsia ako zrozumitelno
Níže je Gaussův program na výpočet dnu na který v daném roce padnou Velikonoce. Ten program obsahuje chybu. Najdeš jí?
10 INPUT R
20 LET D=MOD(19*MOD(R,19)+25,30)
30 LET D=22+D+MOD(5+2*MOD(R,4)+4*MOD(R,7)+6*D,7)
40 IF D < 57 THEN 60
50 LET D=D-7
60 IF D > 31 THEN 90
70 PRINT D; ". BREZNA"
80 STOP
90 PRINT D-31;". DUBNA"
100 END

>>Pravidlo oddělování: Oddělujte postupy od mechanismů; oddělujte rozhraní od nástrojů.
>Oddelte svoje myslenie od klasickych zauzivanych zvykov a snazte sa na problem pozriet z uplne opacnej strany.
Pravidlo oddělování je důležité kvůli znovupoužitelnosti algoritmů. Ale v demoscéně to asi není důležité.

>>Pravidlo přehlednosti: Programujte přehledně, aby byly audity kódu a odstraňování chyb jednodušší.
>Ak budete programovat prehladne, druhi vase postupy a algoritmy rychlejsie okopiruju.
Podle mě se dá kopírovat i nepřehledné

>>Pravidlo robustnosti: Robustnost je potomek přehlednosti a jednoduchosti.
>Robustnost je nepriatelom efektivity.
To by ale znamenalo, že efektvní není robusní a tedy je padací?

>Pravidlo nejméně překvapivého: Při návrhu rozhraní vždy dělejte tu nejméně překvapivou věc.
>>Prave prekvapive veci umoznia program vyznamne zefektivnit.
Dema jsou naštěstí zpravidla konzumenty rozhraní a nikoliv jejich producenty.

>Pravidlo opravy: Musíte-li selhat, selžete hlasitě a co nejdříve.
>>Zlyhanie je nepripustne. Ak sa "musi zlyhat", prvotna pricina chyby bude pravdepodobne niekde medzi stolickou a klavesnicou.
Z toho vyplývá, že dema jsou robusní a tedy neefektivní. Je to tak?

>Pravidlo úspornosti: Programátorův čas je drahý, šetřte ho použitím strojového času.
>>Problem ale nastava ked ten strojovy cas je obmedzeny, resp. potrebujeme do daneho strojoveho casu natlacit co najviac cinnosti. V takom pripade sa situacia obracia - strojovy cas je drahsi ako cas programatora.
Souhlas. Dříve si programátor musel program vyděrovat na děrný štítek a pak ho teprve pustili na chvilku k počítači.

>Pravidlo rozmnožování: Vyhněte se ručnímu psaní kódu; kdykoliv to jde, pište programy, které píšou další programy.
>>Ziadny program (vratane kompilerov) nedokaze napisat tak efektivny program ako clovek ktory pozna danu platfotmu. Pokial ma byt program co najefektivnejsi ako je to len mozne, rucne pisanie kodu je jedina spravna cesta.
Pokud je efektivita opak robusnosti, pak souhlasím.

>Pravidlo optimalizace: Vytvořte správně fungující program, než ho začnete optimalizovat.
>>Na optimalizaciu je potrebne mysliet hned od zaciatku, pretoze ked sa 'nejak zlepi' sice funkcny, ale velmi neefektivny program, clovek sa tym obvykle "zabetonuje" do urciteho typu myslenia (daneho (casto prisernou) stavbou napisaneho programu) a tazsie sa mu potom vymysla ako dany problem vyriesit lepsie a efektivnejsie.
Ano, do přehledného programu se později hůře zanášejí chyby.

>Pravidlo ticha: Nemá-li program co nového říct, neměl by říkat nic.
>>Toto je hadam jedine pravidlo s ktorym sa da bezvyhradne suhlasit.
V případě demoscény pravidlo chápu jako neopakuj stále to samé dokola :-)

_________________
ZX Spectrum DELTA, D80, Melodik, XY4150, Aritma 0512
PGP: A6EA 1F93 EF6B D8D1 35AD B6D7 1E79 73E5 1B28 17F9


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 24.10.2015, 07:35 
Offline
Pan Generální
Uživatelský avatar

Registrován: 23.03.2014, 20:13
Příspěvky: 2773
Has thanked: 224 times
Been thanked: 601 times
_dworkin: Já rozdíl vidím...
Kód:
int len(char *string)
    {
    int l=0;                        /* tohle je zastaralé z minulého století */
    for (int l=0;string[l];++l);    /* budeme moderní, ve škole nás učili Javu a tam je to takhle */
    return l;
    }

...

    char text[]={"nějaký text"};
    printf("délka: %d\n",len(text));

AU! :x

No, mě se tedy řídící proměnná po skončení cyklu občas hodí, a když je v nadřazeném bloku o jednu lokální víc, můžu jí v cyklech jdoucích za sebou použít víckrát. Samozřejmě není problém mít pro každý cyklus jednu ještě víc lokální, vždyť její alokace na zásobníku a následné uvolnění nezabere víc než pár bajtů a stovek tiků procesoru, při výkonu dnešních strojů si to přece můžeme klidně dovolit...
Takže já si jí radši nadeklaruji jen jednou, a pro jistotu ještě navíc statickou ;-)

berk: Že by byl nastavený pro dvacáté století?

berk píše:
>>Pravidlo přehlednosti: Programujte přehledně, aby byly audity kódu a odstraňování chyb jednodušší.
>Ak budete programovat prehladne, druhi vase postupy a algoritmy rychlejsie okopiruju.
Podle mě se dá kopírovat i nepřehledné

To je zcela určitě pravda. Tohle má být C++:
Kód:
int p,k,l,i,j,d,q,R,t,r;
  S1:    s=0; p=1;
  S2:    if (s==0) { i=1; j=n; k=n; l=2*n+1; }
         if (s==1) { i=n+1; j=2*n; k=0; l=n+1; }
         d=1; q=p; r=p;
  S3:    if (x[i]>K>x[j]->K) goto S8;
  S4:    k=k+d; x[k]=x[i]; c[k]=c[i];
  S5:    i+=1; q-=1; if (q>0) goto S3;
  S6:    k+=d; if (k==l) goto S13; else x[k]=x[j];c[k]=c[j];
  S7:    j-=1; r-=1; if (r>0) goto S6; else goto S12;
  S8:    k+=d; x[k]=x[j]; c[k]=c[j];
  S9:    j-=1; r-=1; if (r>0) goto S3;
  S10:   k+=d; if (k==l) goto S13; else x[k]=x[i];c[k]=c[i];
  S11:   i+=1; q-=1; if (q>0) goto S10;
  S12:   q=p; r=p; d=-d; t=k; k=l; l=t; if (j-i<p) goto S10; else goto S3;
  S13:   p+=p; if (p<n) { s=1-s; goto S2; }
         if (s==0) for (t=1; t<=n; t+=1) { x[t]=x[t+n];c[t]=c[t+n] }

Nepamatuji si už ve které učebnici BASICu jsem to před mnoha lety viděl, ale poznal jsem to na první pohled, když jsem na to na hovnokod.cz narazil :lol:

_________________
Plesnivý sýr z Tesca, zatuchlé kuřecí řízky z Albertu, oslizlé hovězí a myší trus z Lidlu.
Nákup potravinářské inspekce v ČR, říjen 2023.


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 24.10.2015, 19:31 
Offline
Óm Nejvyšší

Registrován: 22.05.2013, 21:14
Příspěvky: 3642
Bydliště: Bratislava
Has thanked: 371 times
Been thanked: 788 times
_dworkin píše:
Ja to nechapu. Jaky je rozdil mezi
Kód:
int i;
for (i=10;i;i--) neco();
a
Kód:
for (int i=10;i;i--) neco();
Oboji rika prekladaci, potrebuji na tuhle konkretni vec citac a pak si s tim... delej co chces. Jeden zapis se ti libi a druhy ne.
Mne osobne sa ovela viac lubi ten druhy zapis for(int i=... pretoze tento zapis jasne hovori o tom ze premenna i je pouziva iba v tom cykle a nemusim ju hladat nikde inde.
Samozrejme pokial je nutne mat k dispozicii hodnotu i po skonceni cyklu, je potrebne pouzit prvy zapis. Ale aj v tomto pripade som radsej ked je kazda premenna deklarovana az na mieste kde je pouzita, a nie vsetky premenne nakope na zaciatku bloku.
Z hladiska efektivnosti vykonavaneho kodu je to jedno pretoze kompiler vsetky lokalne premenne vo vsetkych blokoch vo funkcii aj tak interne presunie na zaciatok kodu funkcie, kde sa na zasobniku naraz vytvori miesto pre vsetky tieto premenne.


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 24.10.2015, 20:01 
Offline
Óm Nejvyšší

Registrován: 22.05.2013, 21:14
Příspěvky: 3642
Bydliště: Bratislava
Has thanked: 371 times
Been thanked: 788 times
Specializací demoscény je tvorba tzv. dem, což jsou neinteraktivní audiovizuální díla ve formě počítačových programů...
Nie su iba neinteraktivne. Vecsina old-school dem je interaktivnych, a napr. aj moja Echologia okrem (defaultneho) automatickeho rezimu ma aj manualny rezim kde si uzivatel mozne si jednotlive prvky a ich parametre v efektoch sam menit.

>>Pravidlo přehlednosti: Programujte přehledně, aby byly audity kódu a odstraňování chyb jednodušší.
>Ak budete programovat prehladne, druhi vase postupy a algoritmy rychlejsie okopiruju.
Podle mě se dá kopírovat i nepřehledné
Tu ide skor o to, ci sa ti v celom kode podari najst tu cast ktoru mas zaujem okopirovat.

>>Pravidlo robustnosti: Robustnost je potomek přehlednosti a jednoduchosti.
>Robustnost je nepriatelom efektivity.
To by ale znamenalo, že efektvní není robusní a tedy je padací?
Ked nieco nie je robustne, nemusi to hned nutne znamenat, ze je to padacie. Typicky priklad je napr. rutinka nieco vykreslujuca na obrazovku. Kedze prepocet suradnic na adresu obrazovky trva dlho, riadiaci algoritmus pracuje priamo s adresou do videoramky ktoru nasledne da vykreslovacej rutinke ako parameter. Ak by mala byt vykreslovacia rutinka robustna, mala by prezit pripad ak (omylom) dostane zly vstup - napr. adresu ktora neukazuje do videoramky, ale niekam do kodu samotnej rutinky. Je jasne, ze na to, aby rutinka toto prezila, musi v nej byt nejaky test platnosti adresy. Lenze tento test uz predstavuje urcite zdrzanie a vysledny program je potom menej efektivny. Kedze ale riadiaci algoritmus generuje iba platne adresy, demo efekt (z tejto priciny) nespadne.

>Pravidlo opravy: Musíte-li selhat, selžete hlasitě a co nejdříve.
>>Zlyhanie je nepripustne. Ak sa "musi zlyhat", prvotna pricina chyby bude pravdepodobne niekde medzi stolickou a klavesnicou.
Z toho vyplývá, že dema jsou robusní a tedy neefektivní. Je to tak?
V tomto pripade je nepripustne, aby riadiaci algoritmus vygeneroval chybnu adresu. Ak tak urobi, evidentne je v nom chyba.

>Pravidlo ticha: Nemá-li program co nového říct, neměl by říkat nic.
>>Toto je hadam jedine pravidlo s ktorym sa da bezvyhradne suhlasit.
V případě demoscény pravidlo chápu jako neopakuj stále to samé dokola :-)
Ano, presne tak :)


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 25.10.2015, 12:42 
Offline
Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1100
Has thanked: 100 times
Been thanked: 157 times
Busy píše:
_dworkin píše:
Ja to nechapu. Jaky je rozdil mezi
Kód:
int i;
for (i=10;i;i--) neco();
a
Kód:
for (int i=10;i;i--) neco();
Oboji rika prekladaci, potrebuji na tuhle konkretni vec citac a pak si s tim... delej co chces. Jeden zapis se ti libi a druhy ne.
Mne osobne sa ovela viac lubi ten druhy zapis for(int i=... pretoze tento zapis jasne hovori o tom ze premenna i je pouziva iba v tom cykle a nemusim ju hladat nikde inde.
Samozrejme pokial je nutne mat k dispozicii hodnotu i po skonceni cyklu, je potrebne pouzit prvy zapis. Ale aj v tomto pripade som radsej ked je kazda premenna deklarovana az na mieste kde je pouzita, a nie vsetky premenne nakope na zaciatku bloku.
Z hladiska efektivnosti vykonavaneho kodu je to jedno pretoze kompiler vsetky lokalne premenne vo vsetkych blokoch vo funkcii aj tak interne presunie na zaciatok kodu funkcie, kde sa na zasobniku naraz vytvori miesto pre vsetky tieto premenne.


Souhlasim se vsim, skoro nemam co dodat. .)

Na strance https://gcc.godbolt.org/ s parametry "x86 gcc 4.9.2" a "-O3" jsem vyzkousel tyto varianty:
Kód:
#include <stdio.h>

int main() {
  volatile int x = 100;
  int i; 
  for (i=32;i;i--) printf("%i\n",x++);
  for (i=32;i;i--) printf("%i\n",x--);
}
Kód:
#include <stdio.h>

int main() {
  volatile int x = 100;
  {
  int i; 
  for (i=32;i;i--) printf("%i\n",x++);
  }
  {
    int i;
    for (i=32;i;i--) printf("%i\n",x--);
  }
}
Kód:
#include <stdio.h>

int main() {
  volatile int x = 100;
   
  for (int i=32;i;i--) printf("%i\n",x++);
  for (int i=32;i;i--) printf("%i\n",x--);
}
Vsechny tri vygenerovaly shodny kod
Kód:
.LC0:
   .string   "%i\n"
main:
   pushq   %rbx
   movl   $32, %ebx
   subq   $16, %rsp
   movl   $100, 12(%rsp)
.L2:
   movl   12(%rsp), %edx
   movl   $.LC0, %esi
   movl   $1, %edi
   leal   1(%rdx), %eax
   movl   %eax, 12(%rsp)
   xorl   %eax, %eax
   call   __printf_chk
   subl   $1, %ebx
   jne   .L2
   movl   $32, %ebx
.L3:
   movl   12(%rsp), %edx
   movl   $.LC0, %esi
   movl   $1, %edi
   leal   -1(%rdx), %eax
   movl   %eax, 12(%rsp)
   xorl   %eax, %eax
   call   __printf_chk
   subl   $1, %ebx
   jne   .L3
   addq   $16, %rsp
   xorl   %eax, %eax
   popq   %rbx
   ret
pripadne x86 clang 3.5.1
Kód:
main:                                   # @main
   pushq   %rbp
   pushq   %rbx
   pushq   %rax
   movl   $100, 4(%rsp)
   movl   $-32, %ebx
   movl   $-32, %ebp
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
   movl   4(%rsp), %esi
   leal   1(%rsi), %eax
   movl   %eax, 4(%rsp)
   movl   $.L.str, %edi
   xorl   %eax, %eax
   callq   printf
   incl   %ebp
   jne   .LBB0_1
.LBB0_2:                                # %.preheader
   movl   4(%rsp), %esi
   leal   -1(%rsi), %eax
   movl   %eax, 4(%rsp)
   movl   $.L.str, %edi
   xorl   %eax, %eax
   callq   printf
   incl   %ebx
   jne   .LBB0_2
   xorl   %eax, %eax
   addq   $8, %rsp
   popq   %rbx
   popq   %rbp
   retq

.L.str:
   .asciz   "%i\n"

Takze si myslim, ze ten argument o horsim cilovem kodu uz neplati. Zbyvaji uz jen nevyhody prvniho prikladu. Nejsem zadna autorita takze se opru o http://d3s.mff.cuni.cz/teaching/programming_practices/lectures/index-l02.html kde tvrdi, ze je dobre inizializovat promenne tesne pred pouzitim, aby se minimalizovalo riziko, ze to nekde omylem jeste zmenime nebo pouzijeme. V podstate je dobre tak nerecyklovat zbytecne nejakou pomocnou promenou a snazit se co nejvic omezit jeji zivotnost.

Osobne to vidim tak, ze to ma 3 vrstvy, ktere jsou na sebe nezavisle. Nulta ;) je samotny algoritmus, vec co chceme naprogramovat. Prvni je ten kod v cecku. A druha je co vyleze z prekladace. Ten prevod mezi prvni a druhou vrstvou nemame v podstate pod kontrolou. Je to dan za to, ze muzeme zvolit pouhym parametrem na jakem hardwaru to pak pobezi a prekladac vygeneruje uplne odlisny kod.

Ta druha vrstva je celkem abstraktni a krome par veci (jako ze neni nejake break(x) nebo continue(x) co umi vyskocit nebo pokracovat o x vrstev/smycek vysse a pak jeste nekdo tvrdi ze goto je VZDY spatne) nas moc neomezuje jak zapsat tu nultou vrstvu. Je to neco jako vlnova fyzika.

Treti vrstva je neco jako casticova fyzika. Jsme na urovni instrukci a ten nas algoritmus muze byt efektivneji zapsan klidne nejakym vedlejsim efektem nejake instrukce co vykonava primarne vlastne neco jineho.* Ale to bysme museli preskocit tu prvni vrstvu, protoze se ta informace muze ztratit v te prvni vrstve a prekladac nema sanci poznat o co se snazime. Nezbyva jen doufat ze to nejak optimalizuje. Napr. mame nejaky test ktery provedeme jednou a kdyz je vysledek nulovy tak pokracujeme takhle, kdyz zaporny tak takhle a zbytek zase jinak. V cecku slozite vysledek testu ulozime do nejake pomocne promenne a musime jeste jednou porovnat.
Kód:
if ( ( x = vyraz ) ) {
   if ( x < 0 ) zaporny;
  else
  kladny;
}
else nulovy;

Nebo kdyz chceme vysledek celociselneho deleni i zbytek.


*Nebo na neco existuje instrukce a ta byva vetsinou rychlejsi jak podprogram.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 25.10.2015, 13:14 
Offline
Pan Generální
Uživatelský avatar

Registrován: 23.03.2014, 20:13
Příspěvky: 2773
Has thanked: 224 times
Been thanked: 601 times
_dworkin píše:
Kód:
if ( ( x = vyraz ) )
   if ( x < 0 )
      zaporny;
   else
      kladny;
else
   nulovy;


No, co se šušká, tak stejný výpočet přeložený v G77 jede citelně rychleji než ten přeložený v GCC, bez ohledu na optimalizaci. Že prý zrovna Céčko není na počítání úplně ideální jazyk, o příčinách se nebudu dohadovat ;-)
Kód:
      x = vyraz
      if (x) 100, 200, 300
100   zaporny
      ...
300   kladny
      ...
200   nulovy
      ...

Viděl jsem že některé věci s -O3 fungovaly jinak nebo nefungovaly vůbec, protože ten optimalizátor s tím provádí hodně šílené věci. Přitom s -O0 až -O2 to pracovalo přesně podle předpokladů a podle normy. Proto se -O3 nedoporučuje používat. Příklad už si nevzpomenu, ale asi dva nebo tři roky zpátky se to dost bouřlivě řešilo na abclinuxu.cz.

_________________
Plesnivý sýr z Tesca, zatuchlé kuřecí řízky z Albertu, oslizlé hovězí a myší trus z Lidlu.
Nákup potravinářské inspekce v ČR, říjen 2023.


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 25.10.2015, 13:24 
Offline
Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1100
Has thanked: 100 times
Been thanked: 157 times
V tomhle pripade generuje i -O2 shodny kod takze zadny strach. :)

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 25.10.2015, 13:44 
Offline
Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1100
Has thanked: 100 times
Been thanked: 157 times
Kdyz uz jsme tak pekne utekli od tematu a mame tu akademickou diskuzi... .) Tak bych jeste nakousl ten tvuj kod na zjisteni delky retezce zakonceneho nulovym znakem.

Tady http://stackoverflow.com/questions/32418739/fast-strlen-with-bit-operations
Kód:
int strlen_my(const char *s)
{
    int len = 0;
    for(;;)
    {
        unsigned x = *(unsigned*)s;
        if((x & 0xFF) == 0) return len;
        if((x & 0xFF00) == 0) return len + 1;
        if((x & 0xFF0000) == 0) return len + 2;
        if((x & 0xFF000000) == 0) return len + 3;
        s += 4, len += 4;
    }
}
se to nekdo pokusil otpimalizovat tim, ze to nezjistuje po 8 bitech ale po 32. Ale rezije bude vyssi nez to napsat jednoduse,
Kód:
size_t strlen(const char * str)
{
    const char *s;
    for (s = str; *s; ++s) {}
    return(s - str);
}
aby to prekladac pochopil a dal tam na to specializovanou instrukci. Takze tohle taky asi nema sancihttp://stackoverflow.com/questions/2372315/how-to-implement-strlen-as-fast-as-possible. Proste na urovni asembleru muzou byt slozitejsi veci rychlejsi.

Priklad 2. z http://ridiculousfish.com/blog/posts/will-it-optimize.html
Kód:
unsigned sum(const unsigned char *s) {
   unsigned result = 0;
   for (size_t i=0; i < strlen(s); i++) result += s[i];
   return result;
}
Kód:
unsigned sum(const unsigned char *s) {
   unsigned result = 0;
   size_t length = strlen(s);
   for (size_t i=0; i < length; i++) result += s[i];
   return result;
}
ja bych to rovnou napsal jako
Kód:
unsigned sum(const unsigned char *s) {
   unsigned result = 0;
   for (size_t i=0; s[i]; i++) result += s[i];
   return result;
}

a doufal ze prekladac neni uplne blbej a nemusim to psat takto
Kód:
unsigned sum(const unsigned char *str) {
   unsigned result = 0;
   const char *s;
   for (s=str; *s; s++) result += *s;
   return result;
}

ale kdyz x86 ma instrukce typu mov al, ds:[bp] tak nemam tuseni co s tim udela.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH


Nahoru
 Profil  
 
 Předmět příspěvku: Re: Programování v C
PříspěvekNapsal: 25.10.2015, 14:01 
Offline
Pan Generální
Uživatelský avatar

Registrován: 23.03.2014, 20:13
Příspěvky: 2773
Has thanked: 224 times
Been thanked: 601 times
Jo, -O2 dá úplně stejný výsledek, při -O1 se nepatrně liší, s -O0 je těch rozdílů víc, ale kosmetických. Asi to chce něco složitějšího.

Mám trochu starší verzi GCC, vylezlo z ní tohle:
Kód:
   .file   "c99.c"
   .section   .rodata.str1.1,"aMS",@progbits,1
.LC0:
   .string   "%i\n"
   .section   .text.startup,"ax",@progbits
   .p2align 4,,15
   .globl   main
   .type   main, @function
main:
.LFB3:
   .cfi_startproc
   pushl   %ebp
   .cfi_def_cfa_offset 8
   .cfi_offset 5, -8
   movl   %esp, %ebp
   .cfi_def_cfa_register 5
   pushl   %ebx
   andl   $-16, %esp
   subl   $32, %esp
   .cfi_offset 3, -12
   movl   $100, 28(%esp)
   movl   $32, %ebx
   .p2align 4,,15
.L2:
   movl   28(%esp), %eax
   leal   1(%eax), %edx
   movl   %edx, 28(%esp)
   movl   %eax, 4(%esp)
   movl   $.LC0, (%esp)
   call   printf
   decl   %ebx
   jne   .L2
   movl   $32, %ebx
   .p2align 4,,15
.L3:
   movl   28(%esp), %eax
   leal   -1(%eax), %edx
   movl   %edx, 28(%esp)
   movl   %eax, 4(%esp)
   movl   $.LC0, (%esp)
   call   printf
   decl   %ebx
   jne   .L3
   xorl   %eax, %eax
   movl   -4(%ebp), %ebx
   leave
   .cfi_restore 5
   .cfi_restore 3
   .cfi_def_cfa 4, 4
   ret
   .cfi_endproc
.LFE3:
   .size   main, .-main
   .ident   "GCC: (GNU) 4.7.2"
   .section   .note.GNU-stack,"",@progbits

Dá se tohle vyždímat z Borlandího TurboC? To by mě schválně zajímalo co vyprodukuje ten :D

_dworkin píše:
Nejsem zadna autorita takze se opru o http://d3s.mff.cuni.cz/teaching/programming_practices/lectures/index-l02.html kde tvrdi, ze je dobre inizializovat promenne tesne pred pouzitim, aby se minimalizovalo riziko, ze to nekde omylem jeste zmenime nebo pouzijeme.

Já jsem zase naučený že proměnnou je nejlépe deklarovat a definovat současně, protože před prvním použitím na to můžu zapomenout, nemluvě o úpravách kódu. Řekl bych že to mám už z Ritchieho.
Jenže ono se to nevylučuje, když jí deklaruješ až při použití :lol:

Měřit ten retězec po slovech by mě teda fakt ani nenapadlo, logicky jedu po bajtech, a můj systém je v UTF-8. Jo kdybych v programu použil wchar, který má dvaatřicet bitů, to by byla jiná. Jenže tím bych zase zničil přenositelnost, protože na Widlích je jenom šestnáctibitový :gunjozo:
Navíc šlo o zjištění délky a ne počtu písmen, to si to na tom stackowerflow fakt jenom zkomplikoval. Asi takhle: http://9gag.com/gag/apqNxqD

_________________
Plesnivý sýr z Tesca, zatuchlé kuřecí řízky z Albertu, oslizlé hovězí a myší trus z Lidlu.
Nákup potravinářské inspekce v ČR, říjen 2023.


Nahoru
 Profil  
 
Zobrazit příspěvky za předchozí:  Seřadit podle  
Odeslat nové téma Odpovědět na téma  [ Příspěvků: 159 ]  Přejít na stránku Předchozí  1, 2, 3, 4, 5 ... 11  Další

Všechny časy jsou v UTC + 1 hodina [ Letní čas ]


Kdo je online

Uživatelé procházející toto fórum: Žádní registrovaní uživatelé a 3 návštevníků


Nemůžete zakládat nová témata v tomto fóru
Nemůžete odpovídat v tomto fóru
Nemůžete upravovat své příspěvky v tomto fóru
Nemůžete mazat své příspěvky v tomto fóru
Nemůžete přikládat soubory v tomto fóru

Hledat:
Přejít na:  
Založeno na phpBB® Forum Software © phpBB Group
Český překlad – phpBB.cz