XCHAOS: aby ta metafora byla fakt presna, znela by "vzdej to, k cemu bude ostatnim lidem pro ktere to pry delas v zahradni sekacce letecky motor?" ;)

A dalsi bizarnost:

for(int i = 0; i<10; i++) {
  forget {
    if (condition) {
      break;
    }
  }
}

Clovek je zvyklej ze break ukoncuje smycku, ze jo? Smula, v tomhle pripade vyskoci z forget, leakne pamet a pusti dalsi iteraci. continue se chova stejne idiotsky, u nej si ale XChaos muze namlouvat jakz-takz pricetne vysvetleni ze to je feature pro predcasny odchot z kontextu. Pro break to ale neplati, ten proste ten kontext rozbije a leakne.

_BENNY: sorry, ale tahle metafora je prostě špatná. C je spíš letecký motor - je složitý na seřízení a opravení apod. - jenže všichni kolem říkají "vzdej to, na co potřebuješ letecký motor - proč ti nestačí sekačka na trávu, jako všem okolo".

ISTEVE: no pochopitelně, pokud před returnem není bambilon řádek nějakého "uklízecího kódu" (ruční dealokace paměti, např. ?), který by musel být před každým returnem, tak pochopitelně není důvod to takhle dělat.

fakt je to tak těžké pochopit, jak to myslím ? id REDGUY má úplně pravdu - až na to, že nenavrhuje žádné alternativní řešení: můj nápad s polo-automatickou správou paměti není geniální, je jenom "hezký" - má spíše estetickou hodnotu, než že by byl nějak objektivně "správný" či "výkonný" nebo tak něco. má samozřejmě svoje vady, ano - jenže se tu zamlčuje ta podstatná část problému: a sice, že alternativní postupy jsou na tom úplně stejně !

je jistě nehezké když nemůžeš kdykoliv "čistě" vyskočit z funkce - jenže ejhle, když máš v té funkci paměť alokovanou klasicky pomocí malloc(), tak jsi na tom úplně stejně - není správné utéct, dokud ji nevrátíš ! takže pointa je, že mnou navrhované řešení není v žádném ohledu horší, než to kanonické. jediná výhoda je prostě ta, že pokud máš 2 a více pointerů, tak je to v mé verzi méně řádek kódu.

Komparativni analyza:

Kod #1:

void foo() {
  if (failing condition #1) {
    return false;
  }

  if (failing condition #2) {
    return false;
  }

  if (failing condition #3) {
    return false;
  }

  do_magic();

  return true;
}

...
Kod #2:

void foo() {
  bool failed_yet = false;

  if (failing condition #1) {
    failed_yet = true;
  }

  // podminka na failed_yet != true je pro preskoceni zbytecny evaluace
  // failing condition, ktera muze bejt pripadne draha
  if (!failed_yet && failing condition #2) {
    failed_yet = true;
  }

  if (!failed_yet && failing condition #3) {
    failed_yet = true;
  }

  do_magic();
  return failed_yet;
}

srsly?

a to cele jen kvuli tomu, ze nekoho napadlo udelat ze zahradni sekacky formuli 1.

XCHAOS, proc se proste nesmiris s tim, ze na tyhle blbiny tu jsou jazyky, ktere to maji cele poresene uz uvnitr, a to efektivne a elegantne? pokud ti vadi pomale servery, optimalizuj tam kde to skutecne brzdi, ne tam kde si myslis ze to brzdi.

XCHAOS: máš tam místo toho třeba pět nějakých pointerů na nějaké struktury, pole stringy - prostě objekty vytváření "za pochodu", které tak či onak musíš alokovat a na které musíš na konci ručně volat free() Hele, je to sice tezky mezi slzama smichu, ale zkusim chvilku trochu vazne: myslel jsem ze celej smysl tohohle tvyho predstaveni je udelat system, kterej te zbavi nutnosti explicitne uvolnovat pamet. Aby sis proste mohl rict o pamet kdy ji potrebujes a ona se "sama", bez nejake tvoji akce, ve vhodnou chvili vratila systemu. Postupne jsem ti do toho nasekal diry, takze nakonec jsme se dostali do situace, kdy to sice funguje (udajne, protoze samozrejme implementace je hudbou budoucnosti), ALE:

- nesmis pouzivat goto z jednoho kontextu do druheho
- nesmis pouzivat setjmp/longjmp z jednoho kontextu do druheho
- nesmis pouzivat return a _musis_ strukturovat kod odpovidajicim zpusobem.

Oukej, jeste jakz-takz chapu ty prvni dva body, pro sudlani nejakejch blbinek to asi nevadi. Ale ta posledni v podstate eliminuje veskery vyhody ktery jsi ziska. Copak ti neni jasny, ze pokud musis strukturovat kod tak, aby vzdycky dosel na konec bloku funkce, tak sice usetris psani free, ale to ti bohate vynahradi slozitejsi kod?

ISTEVE: no prý je na tohle několik názorů, kolik returnů by měla mít "hezká" funkce :-) je tam ale asi menší konsensus, než třeba ohledně používání/nepoužívání goto.

+ [ XCHAOS @ ANSI C/C99 (specifikace), GNU C (gcc, glibc), Tiny C (tcc) a POSIX - ne nutně C++,g++,libstdc++ nebo Win32 API ] .. je velká otázka, zda se v systému odchytávání vyjímek počítá třeba s tím, že funkce ještě budou vracet NULL nebo -1 při chybě ... pořád chápu potřebu nějakého větvení funkce a užitečnost více returnů, sám jsem takhle programoval léta - ale popravdě, pokud funkce na konci dealokuje třeba 10 dočasných objektů, které alokovala na začátku, tak si piš, že u ní každý příčetný coder použije jediný return (po všech těch ručních deinicializacích) - a nebude ty deinicializace copy+pastovat před každý return.

jestli to tak dělá id REDGUY, to je jiná věc... a když jsme u toho... on se sice zatím nepřeklepl na numerické klávesnici, ale počtem správných odpovědí v tom testu se taky zatím nepochlubil :-)

(nemluvě o tom, že při použití s try { } a odchytáváním vyjímek, což je pro mě hrozný nezvyk, ale dnes je to pokládané za hodně moderní přístup k návrhu aplikací, by asi v té funkci bylo několik úniků pomocí fail() (tedy v C++ throw, v Pythonu raise, apod.) - a jen jeden return - platné hodnoty, žádné "-1 = chyba" ... není to sice pravidlo, ale je to dnes opravdu častý přístup, jak mi tady jistě potvrdí fanoušci C++ ...)

REDGUY: return se doporučuje používat na konci :)

mě to tak směšné nepřijde: máš tam místo toho třeba pět nějakých pointerů na nějaké struktury, pole stringy - prostě objekty vytváření "za pochodu", které tak či onak musíš alokovat a na které musíš na konci ručně volat free()

fakticky nakopíruješ těch pět volání free() před každý return v té funkci ?

mimochodem - z mého kontextu půjde předčasně escapnout pomocí instrukce continue; - a dealokace se pochopitelně provede - tedy design pattern je následující:

rv=0;
forget
{

if(redguy)
{
rv=-1;
continue;
}


}
return rv;

toto opravdu není nic, co by bylo nějak nepoužívané, nesrozumitelné, a nedělalo se to hlavně i v případě, že potřebuješ uvolnit paměť JAKKOLIV JINAK, ukončit spojení, uzavřít soubory apod. - prostě funkce, které mají jediný return a ne padesát, jsou mezi programátory dlouhodobě pokládané za vcelku dobrý nápad, není to z mé hlavy.

XCHAOS: takže si dobře rozmysli, který design pattern nese větší rizika čeho, než některý zatratíš... - takze memory leaky jsou pro tebe "design pattern"? HAHAHAHAHAHAHAHA. Takze je v poradku ze tvuj "alokator" zacne leakovat pamet na vsechny strany, jen co se do nej opre lehky vanek (treba return uprostred funkce), protoze je prece "design pattern" ze se program pro jistotu kazdejch pet minut restartuje a je to prece lepsi nez segfault? HAHAHAHAHAHA.

XCHAOS: v dokumentaci bude tedy [...] zmíněná i nevhodnost použití returnu z funkce. - HAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHA. Proboha. Tebe bych si fakt nedokazal ani vymyslet.

Hele, co na tohle rict. Snad jen ze opravdu urpimne obdivuju zarputilost, s jakou dokazes navzdory vsem argumentum proti hajit i tu nejvetsi pitomost, jen proto ze to je tvuj oblibeny projekt a nedovolis aby ti ho nekdo rozbil, obzvlast ten zlej redguy. Ale tohle uz je fakt hodne, hodne, hodne zly. "return se nedoporucuje pouzivat"... to ze "nedoporucuje" je eufemismus pro "kdyz to udelate, pravedpodobne vam to bude brutalne leakovat" je ten nejmensim problem 8)

Ale mam pro tebe dobrou zpravu: existuje cesta z tohohle pruseru, nezarhnujici podobny idiotsky omezeni v dokumentaci. Sice neni moc elegantni, ale fungovalo by to (resp. resilo by to tenhle problem, mozna (skoro urcite) by to melo jiny potize plynouci z designu tveho bastlu). Schvalne jestli na to prijdes 8)

Why Johnny Can't Code and How That Can Change - Slashdot
http://developers.slashdot.org/story/11/06/23/1422224/Why-Johnny-Cant-Code-and-How-That-Can-Change

REDGUY: v C se dostaneš do nekonzistentního stavu i spoustou jiných způsobů. chápu, že tě baví upozorňovat, že do lodi teče - ale to co vyvíjím já, je spíš takový vor: vor může mít díry a stejně do něj neteče.

pro začátek si ujasni, co reálně vadí víc:
- memory leaking (v C opravdu ČASTÁ chyba, přiznejme si to - i bez mých nápadů) nebo
- přístup k již dealokované paměti ?

memory leaks jsou tak častá chyba, že třeba i server Apache se pro jistotu po (konfigurovatelném) množství přístupů zrestartuje, aby uvolnil paměť. je to jeho normální činnost: neohrožuje to stabilitu, nic. jen to šetří resourcy systému.

naproti tomu přístup k dealokované paměti znamená segfault.

takže si dobře rozmysli, který design pattern nese větší rizika čeho, než některý zatratíš...

REDGUY: mno. hmm. teď si fakt našel výrazně lepší protipříklad, než ty předchozí :-) tedy ne, že by return z funkcí z míst, kde si na konvenčně alokovanou paměť nezavolal free(), způsobil cokoliv jiného - ale budiž.

gratuluju - v dokumentaci bude tedy kromě nekompatibility z goto a setjmp/longjmp tedy zmíněná i nevhodnost použití returnu z funkce.

(víš, oni někteří hnidopichové se dokonce domnívají, že by funkce měly pokud možno mít jen jediný return na konci - a uvnitř by měly být normálně strukturované na cykly a podmínky a max. nastavovat návratovou hodnotu... ale já se přiznám, že to hodil za hlavu a neřešil, proč by to tak mělo být... zajímavé)

XCHAOS: oznamenat, že pokud všechny pointery alokované uvnitř forget { } také DEKLARUJEŠ uvnitř toho scope (což je hezká vlastnost C - že v jakémkoliv scope můžeš deklarovat další lokální proměnné), tak že se nemůže stát, že bys na tu dealokovanou paměť přistupoval za koncem scope? - coze? Nerozumim. Tohle je podle tebe reseni toho problemu se setjmp/longjmp? Tam nejde o _pristup_ k te pameti, tam jde o to, ze longjmp te dostane z jednoho kontextoveho bloku do druheho aniz by si toho tvuj bastl vsiml a tim se dostanes do nekonzistetniho stavu.

Hele, xchaosi, sice mam jen velmi mlhavou predstavu o tom, jak to budes implementovat (a neco mi rika ze ty taky), ale jen tak cvicne, predstav si tohle:

char * foo(void) {
  forget {
    GET_MEMORY;
    remember {
      GET_MEMORY;
      forget {
        GET_MEMORY;
        remember {
          GET_MEMORY;
          return stuff;
        }
      }
    }
  }
}

Jakym zpusobem se uvolni pamet v tech dvou forget blocich? Jestli forget/remember jsou jen nejaky wrappery kolem for, tak ten return je zcela odignoruje a proste se vrati, bez nejakyho uklidu. Nebo mi neco unika?