Hmmm... Oracle Pro*C tanfolyamon ajanlottak hogy a valtozo neve ne utaljon a tipusra, mert az megvaltozhat fejlesztes kozben: pl NUMBER(n) az adatbazisban esetleg nem fer bele egy 'int'-be, lesz belole 'long' vagy 'long long', de ha az sem eleg, akkor stringkent kell kezelni... maskor viszont a jutalek lesz 'float'-bol 'double' stb
ne csináld: értelmes ember az else if-et nem tabulálja beljebb, mint az eredeti if-et, azaz 42 db else if is egy szintet jelent. Ugy latszik rosszul adtam elo magam... a gyakorlatban a kovetkezo szokott lenni a helyzet:
if (hibavizsgalat) {
hibakezeles
} else {
csinalok valamit;
if (hibavizsgalat) {
hibakezeles;
} else {
megvalamit csinalok;
if (hibavizsgalat) {
hibakezeles;
} else {
NEM VOLT SEMMI HIBA;
}
}
}
magyalul az else if kozott meg valamit kell csinalni, ami miatt mar egesz maskepp nez ki a dolog...
>NevemTeve, ha már a goto szó szerepel a szótáradban, akkor nincs miről vitatkoznunk :-(
Hat, azzal egyetertek, hogy nincs mirol vitatkozni azzal, aki egy nyelv kiszemelt kulcsszavait konkret esetek nelkul uldozi. :-))
>Egyébként nem az én elveim, így oktatják programozóknak (csak legfeljebb elfelejtik).
Ja, az elhet hogy igy oktatjak. Gondolom olyanok, akik eletukben nem irtak 20 sornal tobb kodot.
(Amugy megkockaztatom, hogy nem ezt tanitjak, es nem igy, hanem tartozik hozza egy csomo iranymutatas, mikor celszeru, mikor nem, miertekkel, stb, amibol nem vezet mindig/soha leegyszerusiteshez).
En a gyakorlatban joval tobb szornyuseget (es bugot) lattam, ahol a delikvens egyetlen celja az volt, hogy elkerulje a goto leirasat. Es a semmi hasonert cserebe vezetett be nyakatekert, erthetetlen szerkezeteket, vagy ami meg rosszabb, duplikalt kodot.
Van egy olyan erzesem, hogy aki tisztaban van azzal, hogy miert kell uldozni a goto-t valojaban, az egybol nem is uldozi. Csak egyszeruen ritkan hasznalja, mert pl. egy jol fesult C++ programban nagyon ritkan jon ki az, hogy a goto lenne a tobbinel jobb szerkezet.
>A 3 soros függvényben azért nem írunk 2 returnt, mert akkor a 5, 10, 50 soros függvényekben is írunk 2 (3, ...) returnt.
De meg mennyire hogy irunk. Nagyon elismert C++ tutorok (Scott Meyers, Herb Sutter; altalanosabb vonalon Fowler) ajanlasaval is egyezoen, pl. amikor guard clausulakat irunk a fugveny elejere egy vegtelenitett es attekinthetetlen if helyett.
>" Általában egy változónak van egy típusa és egy felhasználása. Jó esetben mindkettő benne van a nevében. Nálad legfeljebb az egyik. Ez tényleg csak szokás kérdése, de ah belegondolsz, hogy néhány év múlva valaki belenéz/módosít a kódban, akkor rájösz, hogy jó szokás.
Mar bocsanat de ez egy kifejezetten rossz, karos, szokas. A valtozo neve ne tartalmazza a tipust. Kulonosen olyan nyelv eseten ahol lehet tipusokat csinalni tetszes szerint.
A "Hungarian notation" (eleg baj, hogy erre a foleg microsoft altal terjesztett szornyusegre sikerult szegeny orszagunk nevet raragasztani) felesleges redundanciat visz a rendszerbe. Es a mai proramozo kornyezetekben meg csak haszna sincs, hisz egerrel foleallsz a valtozonak, es megmutatja a tipust, ha ez veletlenul erdekel valakit.
NevemTeve,
ne csináld: értelmes ember az else if-et nem tabulálja beljebb, mint az eredeti if-et, azaz 42 db else if is egy szintet jelent.
"cb= ControlBlock, m=memory, o=object, rc= return code" Általában egy változónak van egy típusa és egy felhasználása. Jó esetben mindkettő benne van a nevében. Nálad legfeljebb az egyik. Ez tényleg csak szokás kérdése, de ah belegondolsz, hogy néhány év múlva valaki belenéz/módosít a kódban, akkor rájösz, hogy jó szokás. (Ahogy az emberek többsége nem f1, f2, ... néven nevezi a nem publikus függvényeit, hanem igyekszik értelmes, beszélő nevet adni.)
Nekem 2-re van állítva a tabulátorpozíció. Nem azért, hogy elférjen a sok if, egyszerűen csak így szeretem. :))
Egyébként még soha nem süllyedtem el az if-ekben. Ha mégis az a veszély fenyegetne, hogy elsüllyedek, akkor szétdarabolom a függvényt, és megcsinálom 1 helyett 2 vagy 3 függvényben. Muszáj, hogy a kód átlátható maradjon, és erre a goto szerintem nem alkalmas eszköz. (Mellesleg c64-es korszakom óta nem is használtam goto-t. :))
Hat eppen ezt mondom en is: nem akarok "elsullyedni "az if-ekben, mivel az szerintem sokkal kevesbe atlathato mint egy joliranyzott goto VEGE... (lattam mar olyan fejlesztot, aki a tabulator-poziciot 3-ra csokkentette, hogy az n-melysegu if raferjen a kepernyore)
Azt csak halkan jegyzem meg (de megteszem, mert általános pongyolaság), hogy az 'if (minfo)' bár ekvivalens 'if (minfo != NULL)'-lal, de (különösen, ha nem prefixálod a változóneveidet a típussal) nehezebben értehető. Szokas kerdese...
A rendkívül beszélő o és m memberekről és a változónevekről nem is szólok... azert nem olyan rossz a helyzet: cb= ControlBlock, m=memory, o=object, rc= return code ...
NevemTeve,
ne haragudj, de ez abszolút öngól: mindkét goto VEGE; egy-egy else szóval helyettesíthető! Akkor viszont minek? Tessék megtanulni az if-then-else szerkezetet és használni, ha pontosan arra van szükség, mint ebben példában is. (Ráadásul az if rendesen tabulál, míg a goto nem.)
Azt csak halkan jegyzem meg (de megteszem, mert általános pongyolaság), hogy az 'if (minfo)' bár ekvivalens 'if (minfo != NULL)'-lal, de (különösen, ha nem prefixálod a változóneveidet a típussal) nehezebben értehető.
A rendkívül beszélő o és m memberekről és a változónevekről nem is szólok...
Nezd, en mar nagyon sok goto elleni kereszteshaboruban vettem reszt, de nem zarkozom el ujabbak elol... nem valamifele elmelet alapjan hasznalok goto-t, hanem egyszeruen az elet ugy hozza hogy ha el akarom kerulni a sokszorosan egymasba agyazott if-eket, a kodok megismetleset, a tobbszoros kilepest (return), akkor egyszeruen nincs mas eszkoz mint az ugras.
Ime egy fuggvenyem, amelyet teljesen valos programbol vagtam ki peldanak:
int S3_ReAllocMem (S3_MEMKEY memkey, unsigned new_size,
S3_MEMINFO *minfo)
{
CORE_CB *cb;
MEMO_CB *m, *mnew;
int rc;
S3_MEMKEY k;
if (memkey<0 || memkey>S3_MAX_MEMKEY ||
(cb = mcb.currmem[memkey].o) == NULL ||
(m = mcb.currmem[memkey].m) == NULL) {
rc = -1;
goto VEGE;
}
if (new_size == m->size) { /* same size - keep the old */
rc = 0;
mnew = m; /* LZS. 2002.06.18. */
goto VEGE;
}
FrMem ((CORE_CB *)cb, m);
mnew = (MEMO_CB *) realloc (m, sizeof (MEMO_CB)+new_size);
if (mnew == NULL) { /* Could not realloc - keep the old */
mnew = m;
ToMemB ((CORE_CB *)cb, m);
rc = 1;
} else { /* Realloced */
mnew->size = new_size;
mnew->addr = (char *)mnew + sizeof (MEMO_CB);
ToMemB ((CORE_CB *)cb, mnew);
rc = 0;
if (m != mnew) { /* and moved too */
for (k = 0; k<=S3_MAX_MEMKEY; ++k) {
if (mcb.currmem[k].o != NULL &&
mcb.currmem[k].m == m)
mcb.currmem[k].m = mnew;
}
}
}
VEGE:
if (minfo) {
if (rc<0) memset (minfo, 0, sizeof (*minfo));
else memcpy (minfo, mnew, sizeof (*minfo));
}
return rc;
}
NevemTeve, ha már a goto szó szerepel a szótáradban, akkor nincs miről vitatkoznunk :-(
Egyébként nem az én elveim, így oktatják programozóknak (csak legfeljebb elfelejtik).
A 3 soros függvényben azért nem írunk 2 returnt, mert akkor a 5, 10, 50 soros függvényekben is írunk 2 (3, ...) returnt. Nyilván mindenki átlátja Han Pritcher függvényeit, de szerintem mindketten láttunk már olyan kódot, ahol 2 ciklus és egy switch közepéből lép ki egy elegáns return. Az ilyen kód lehet, hogy megoldja a feladatot, sőt lehet, hogy hatákonyabban oldja meg, mint egy strukturáltabb kód, de ennek ellenére használhatatlan. (Pl. mert nem bővíthető. Jobb helyen megtartják az optimalizálás előtti kódot is, és abban végzik el először a módosítást.)
Ráadásul az esetek többségében egy else helyett (!) használják a returnt (néha érték nélkül). Javaban ahol van finally, ez nem fájó pont, de nagyon C++-ban az.
FLAME (Honnan kene a Te elveidet masoknak is ismerniuk?
Egyebkent azzal en is egyetertek hogy nemtrivialis esetekben szukseg lehet arra hogy a fuggveny kilepeskor valamilyen tevekenyseget vegezzen (pl naplozas), vagy hibakeresesre lehet szukseg, akkor jobb ha csak egy return van a fuggveny vegen es inkabb oda goto-zunk)
FLAME (Honnan kene a Te elveidet masoknak is ismerniuk?
Egyebkent azzal en is egyetertek hogy nemtrivialis esetekben szukseg lehet arra hogy a fuggveny kilepeskor valamilyen tevekenyseget vegezzen (pl naplozas), vagy hibakeresesre lehet szukseg, akkor jobb ha csak egy return van a fuggveny vegen es inkabb oda goto-zunk)
int main() {
int lst[10];
int i;
printf("\nAdja meg a szamokat:\n");
for (i=0; i<10; i++) {
scanf("%d", &lst[i]);
}
qsort((void *)lst, 10, sizeof(lst[0]), srt);
printf("\nA rendezett lista:\n");
for (i=0; i<10; i++) {
printf("%i ",lst[i]);
}
return 0;
}
compton_,
mivel a visszatérés figyelése nagyon sok helyet és időt követel, nem jó. Mondok egy jobbat: írdd meg a nagyon buta backtracket egy mélységkorláttal, majd futtasd le egyre nagyobb korláttal: gyorsabban (amennyiben egyáltalán szabad a gyors szót használni backtrack esetén) végetér és nem mellékesen a legrövidebb utat adja meg. (Mi több ez még súlyozott úthosszakra is működik.)
A klasszikus útkereső megoldás (mátrix a útvonalpontokra és szomszédkeresés) nem működik, a lehetséges állapotok nagy(faktoriális rendű) száma miatt.
Helló!
Az alábbiakban szeretném kérni a segítségeteket!
Valaki akinek a kisújjában van a C++ programozási nyelv segítsen egy szerencsétlen, vizsga
előtt álló emberkének! Az alábbi feladatokatra kellene megoldást fabrikálnom, de a megfelelő
ismeretek hiányában ez nekem egyedül nem megy. A feladatok nem túl bonyolultak egy profinak:)
Kérlek segítsetek nekem mielőbbi megoldásaitokkal!
Előre is köszönöm!
Sight
a helyes megfejtéseket az alábbi mail-ra küldhetitek>
ccsmith@hu.inter.net
1., C program, amely a standard inputról beolvasással feltölt egy 10 elemű egész tömböt,
majd csökkenő sorrendbe rendezi az elemeket.
Rendezés után ki kell íratni az elemeket!
2., Egy egész értékű fgv.-t kell írni, amely egy adott kezdőcímű stringről eldönti, hogy
számjegykarakterek vannak-e benne! Az eredményt megfelelő érték visszaadásával jelezze!
A teszteléshez kell egy főprogram, amelyben egy legfeljebb 80 karakteres sort beolvas a
standard inputról - új sor karakter végjelig - majd a fgv. által visszaadott értéknek
megfelelő szöveges üzenetet kiirja a standard outputra - képernyő.
Egy ötlet a PI szamitasara.
Tegyük fel, hogy van egy n oldalú szabályos sokszögem, mely ugye feldarabolhato n darab háromszögre. Ha tart végtelenhez az oldalak száma, akkor szinte már kör lesz. A központi szöget n részre bontják a háromszögek. Na most innentol egyszeru szogfugvennyel megvan. Tegyuk fel hogy a korulirhato kor sugara 1 egysegnyi.
[sin(360°/2n)]n
n helyere pakoljatok be egy bazinagy számot, és jön a pi
Attoparsec:
Nem egészen értem ezt a se nem teli, se nem üres problémát. Viszont a bor és víz megkülönböztetésének nagy jelentősége van. - No mindegy.
Közben sikerült a betűszámtanos feladatnak [5. hozzászólás] egy megoldását megcsinálni - brute force, és csak két taggal... három-négy jegyig elég gyors, viszont öt esetén már szörnyű lassú.
Viszont gondolkodni nem tud... :-(
hello Niggle !
grat a megoldasodhoz ! mit szol a programod, ha olyan megoldast keresel a kancsosra mint eddig + azzal a kikotessel, hogy a 3 literes kancso ne legyen se ures, se teli ? :)
az edenyesnek van vizes és boros megoldása is :-) a feladatban ion-boros kancsokrol van szo. ismeros valahonnan ? :)
ap.
[ 1. FELADAT ]
Azt hiszem nekem pascalban sikerült a feladatot megoldanom... (kancsok - 5, 3 literes stb...)
Szal működik - így utólag roppant egyszerű - de egy kis időbe beletellett...
Illetve a mastermind megoldasat is ismerem - az egyszerű - benne van a "Játékok számítógéppel" című könyvben...
Csak ennyit akartam...
u.i.
Ja az edenyesnek van vizes és boros megoldása is :-)
Mindkettő ok.
jó a feladatanalizised. gondolom mostanra már meg is van a megoldás :) milyen nyelven írtad meg ? én prologban szoktam az ilyesmit megoldani, ott már eleve adott a backtracking.
"a megoldas helyes es azt hiszem, hogy hasonlo programot, mint amilyen megoldotta a feladatot, meg egy darabig nem tudunk irni :) "
ezt a megjegyzést facsega megoldására tettem, aki fejben oldotta meg a feladatot :) olyan programot pedig, mint amilyen facsega fejében van, egy darabig még tényleg nem fogunk tudni irni :))
"a megoldas helyes es azt hiszem, hogy hasonlo programot, mint amilyen megoldotta a feladatot, meg egy darabig nem tudunk irni :) "
Ezt nem mondod komolyan!
Annyira felkeltette az erdeklodesemet ez a feladat, hogy megyek haza es belevagok! En ugy gondolkozom, hogy - a peldanal maradva - van n=3 kancso, egy lepesben n(n-1) = 6 lehetseges toltogetes van. Persze ki kell zarni azokat az eseteket, amikor ures kancsobol probalunk tolteni. Az allapotokat le lehet irni pl. egy 3 jegyu szammal. Induloallapot 500, cel: xy1. Siman elindulok egy back-track algoritmussal, azt is figyelve, hogy olyan allapotbol ne menjek tovabb, amilyen mar egyszer elofordult mas uton (nehogy vegtelen ciklusba fussak).
Igy meglesz a megoldas, bar igy elso nekifutasra nem biztos, hogy a legoptimalisabb uton, szoval valahogy majd ki kell optimalizalni.
Ezt elvileg tobb/mas meretu kancsora es mas kiindulo es celallapotra is lehetne alkalmazni...
lehet, hogy hulyeseg, de rekurzio helyett sokszor bejon:
veszel tombot 1 tol n ig, es lepesenkent foltoltod. igy nem kell visszalepni, mert a kert ertek mar keszen van, es nem telik a verem se (kedvelt rekurzios uzenet a "Stack Overflow" ...
[Feladat 7] Adott mondjuk 193 különböző méretű téglatest (szélesség, hosszúság, magasság). Írjunk programot, ami megadja, hogy hogyan lehet a téglatesteket a legoptimálisabb módon elhelyezni. Optimális elhelyezés, ha:
[A változat] A téglatesetek az tárolásukhoz szükséges teret a lehető legjobban kitöltik. (A hézagok térfogata a legkisebb.)
[B változat] A téglatestek tárolásához szükséget tér legnagyobb oldalmérete a legkisebb legyen. (Tehát törekedjünk, hogy kocka legyen.)
