Új hozzászólás Aktív témák
-
labuwx
tag
válasz Jhonny06 #614 üzenetére
Az csak egészek maradékát tudja megadni, a gond ott volt, hogy az sqrt() lebegőpontossal tér vissza és azzal kellett volna számolni, de most már megtanultam típust konvertálni.
Most viszont egy verem túlcsordulással küzdök, amit egy rekurzitív algoritmus okoz:bool prime(unsigned long szam, unsigned long oszto=0)
{
if (!oszto) oszto=(unsigned long)sqrt((float)szam);
if ((oszto==1) & (szam>1)) return true;
else if (szam%oszto==0) return false;
else return prime(szam, oszto-1);
}szam=18292777 -nél verem túlcsordulás.
Meg tudnátok mondani, hogy hogyan tudom megnővelni a vermet és mennyire, hogy ha szam€ us long biztos működjön?
A segítséget előre is köszönöm. -
WonderCSabo
félisten
válasz Jhonny06 #678 üzenetére
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int a;
int b;
int c;
string vez;
string ker;
string nev;
fstream f;
f.open("valami.txt");
f>>a>>b>>c>>vez>>ker;
nev=vez+" "+ker;
cout << a << endl << b << endl << c << endl << vez << endl << ker << endl <<nev;
f.close();
return 0;
}[ Szerkesztve ]
-
mgoogyi
senior tag
válasz Jhonny06 #692 üzenetére
Szia,
Első körben két problémát látok:
1, Write() meg Load() függvényeknek fordított sorrendben kéne lennie, mert egy inicializálatlan arrayből nem tudom mit akarsz kiíratni.
2, A Load()-ban a második paramétert tök felesleges referenciaként átadni, nem a tömb címét írod át, hanem a memóriacímen lévő adatokat piszkálod. Ha ez nem világos, amit írtam, akkor bővebben kifejtem. (Referencia helyett inkább const lenne a logikus szvsz.)Még most talán lényegtelen, amíg az alapok nem mennek, de dinamikusan kéne a tömböt lefoglalni menet közben, mert nem tudni, hány sor lesz a fájlban. Ezt így tudod megtenni, hogy: example * tomb = new example[n]; ahol n-et a fájl első sorából olvasod be. Bár ha dinamikusan foglalod le, akkor értelmet nyer a referencia, mert akkor a függvényen belül derül ki a címe. Felszabadítás pedig: delete [] tomb;
Ha pl. azokat a neveket akarod kinyerni, amelyeknél 2 van a név előtt, akkor egy for ciklus a tömbbön és ha if (something.day == 2) cout << something(i).name << endl;
Még valami:
Azzal a continue-val mit akartál elérni a végefelé??[ Szerkesztve ]
-
mgoogyi
senior tag
válasz Jhonny06 #694 üzenetére
Egyrészt ezt így próbáld ki, nekem így simán működik:
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>using namespace std;
struct example
{
int day;
string name;
};typedef example array[5];
int load(int& counter, array something);
int write(array something);int main()
{
int counter;
array something;
load(counter, something);
write(something);getc(stdin);
return 0;
}int load(int& counter, array something)
{
ifstream file;
file.open("file.txt");
file >> counter; //<- #2 PROBLEM
for(int i=0; i<counter; i++)
{
file >> something.day;
file >> something(i).name;
cout << something(i).day << " " << something(i).name << endl;
}
file.close();
return 0;
}int write(array something)
{
int one=1;
if(something[one].day)
cout << something[one].name; //<- #1 PROBLEM
/*else
continue;*/
return 0;
}Referencia, cím, stb:
ha van egy tömböd, pl. int tomb[5];
akkor ha csak simán ezt írod le, hogy pl(sorry a c-s kiíratásért, én azt szeretem):
printf("%d",tomb); -> a tömb memóriacíme
tomb[0] -> a tomb memóriacíménél lévő int elem
tomb[1] -> a tomb címéhez képest egy inttel arrébb lévő elem
tomb[2] -> a tomb címéhez képest két inttel arrébb lévő elemtomb + 0 -> a tomb első elemének, avagy a tömbnek a memóriacíme
tomb + 1 -> a tomb második elemének a címe*(tomb + 0) -> a * rámutat a zárójelben lévő címre, azaz az ottani int értéket jelenti
az és(&) jel több dologra jó, most kettőre térek ki:
1. Cím lekérése
van egy ilyen változód, hogy:
int i = 5;
&i ennek az i változónak a címét jelenti a memóriában.
Ha pointerezel: *(&i) az i címére mutató pointer, tehát maga az i.2. Referencia (nem tudom milyen nyelvekben vagy jártas, pascalban pl. ez a var kulcsszó, ill. sok nyelvben meg mindig referencia szerinti átadás van, mint pl. java - persze vannak kivételek
int i = 5;
int & j = i; // az i "álneve" vagy "aliasa" j leszitt a j egy és ugyanaz a változó, mint az i, tehát ha ezt csinálod, hogy
j = 6;
akkor az i is 6 lesz, mivel a két változó ugyanaz, csak két különböző néven tudod őket elérni.ha van egy függvény, ami referenciát vár, pl:
void inc (int & j) {
j++;
}int i = 5;
inc (i);akkor ennek a függvénynek a paramétere egy alias lesz i-re, tehát ha a függvényben megváltoztatod j-t, azzal i-t változtatod. Szal a referencia arra van általában, hogy a bemeneti paraméter kimeneti is lehessen ill. még azért használják, mert ez egy dereferált pointer a beadott paraméterre és ha az a paraméter nagyobb helyet foglal, mint egy pointer, akkor nem kell lemásolni a beadott értéket az újonnan létrehozott ugyanolyan nagy paraméterváltozóba. Ha az utóbbi félmondatot még nem érted, nem nagy gond.
Szóval te egy függvénynek átadtad referenciaként egy tömb címét. Ezt a címet te nyilván nem akarod megváltoztatni, mert akkor a memóriában ki tudja honnan olvasnál be dolgokat.
Kíváncsi vagyok, hogy ebből mit értettél meg... -
mgoogyi
senior tag
válasz Jhonny06 #698 üzenetére
Nálam semmi hibaüzi nincs, visual studio + winXP.
Annak, hogy something.nev semmi értelme, mert a something az egy tömb, neki nincs olyan mezője, hogy nev. A something struktúrák tömbbje, a tömbnek van [i.] eleme, ennek az i. elemnek vannak mezői, mert ez a struktúra. Valahol nagyon kavarhatsz vmit.
Miért nem jó neked, ha azt írod, hogy something[változó].nev???[ Szerkesztve ]
-
doc
nagyúr
válasz Jhonny06 #922 üzenetére
ilyen, amit leirtal nincs
a tomb az X db valtozo egymas utan, attol hogy valamelyiknek nem adsz erteket, az letezik
vagy nyilvantartod hogy melyik kell es melyik nem, vagy kinullazod a tombot es kiiratod a 0-kat isvagy hasznalsz valamilyen mas adatszerkezetet (list, map, stb)
-
lamajoe
tag
válasz Jhonny06 #1109 üzenetére
Ez igaz, nem lehet csak ebből tanulni. A C++ tanulásához ugyanúgy kell hozzáállni mint pl a PS tanulásához, interneten fórumokba írogatni, tutorialokat nézni, megoldási példákat. Ez a könyv nekem arra volt jó, hogy tudtam anno suliban olvasgatni, így legalább ott is tanultam vlmi értelmeset
-
Gyuri16
senior tag
válasz Jhonny06 #1115 üzenetére
ha nativ kodot generalsz akkor a legjobb egy disassembler (pl ida pro - ennek van ingyenes valtozata is, ami megfelelo), vagy debugger (pl ollydbg). ezekben meg tudod nezni hogy milyen kodot gyartott a fordito.
szerintem alap szinten erdemes elfogadni, hogy a fordito bekapcsolt optimalizacio mellett jo kodot general, es kar itt keresni a bottlenecket. ha mar tenyleg minden tokeletesen van a kodban, akkor lehet nekialni ezzel foglalkozni, viszont nem art hozza az asm es a konkret processzor ismerete, enelkul ugyanis nem egyertelmu, mit miert csinal egy fordito (pl attol hogy valamit kevesebb asm paranccsal oldasz meg, nem feltetlen lesz gyorsabb).
szerintem fontosabb az, hogy a program olvashato legyen emberek szamara, a tobbi meg a fordito dolga.
egy osszehasonlito teszt engem is erdekelne, sok ilyen tema van, amin szeretnek vitatkozni az emberek, kivancsi vagyok van e ertelme.
Nem vagyok egoista, csak uborkagyalu!
-
válasz Jhonny06 #1266 üzenetére
elvileg fel kéne ajánlania a compilernek, hogy ha lát változást, akkor újra kell építenie.
ez az elmélet. a gyakorlat az, hogy unix környezetben (minix 3.1) már láttam olyat, hogy órákat szívtunk, mire észrevettük, hogy a C compiler nem lát egy változtatást és ezért még mindig a két órával előtti kernellel szívunk.
rebuild kell, ha azt nem csinálod, akkor nem fog fordítani. esetleg ha nagyon nem megy, akkor lehet rá nyomni egy clear+rebuildet, de azzal projekt méretének függvényében nagyon óvatosnak kell lenni.
én debug módban szoktam (jelenlegi beadásnál csináltam automatizált tesztet assert is, azt meg release módban elvileg nem is futtatja), rebuildelni meg akkor, ha outdatednek írja. ill néha clear+rebuild, ha valami nagyon nem stimmel.
[ Szerkesztve ]
Don't dream it, be it. // Lagom amount.
-
WonderCSabo
félisten
válasz Jhonny06 #1266 üzenetére
Én Code::Blocks-ot használok. Ha a Run-ra kattintok, nem érdekli volt-e változás, az utolsó fordított binárist futtatja (már ha van, ha még nincs, akkor fordíttat veled). Ezért mindig Build and Run parancsot adok ki. Persze ez a Build parancs csak a megváltozott fordítási egységeket fordítja újra, és linkeli a programot. A teljes újrafordítás a Rebuild. Olyan még nem fordult elő, hogy a Build nem vette észre, hogy volt változás.
Más:
Ha meg kell akadályoznom a programom automatikus bezárását, mindig cin.get()-et, vagy getchar()-t használok. Legalábbis Windowson. Most valgrind miatt Linuxon forgattam, és meglepően tapasztaltam, hogy legújabb GCC-vel Ubuntuval az előbbi hívásokat simán ignorálja és terminál a program. Tapasztalt ilyet vki? Ha igen, milyen alternatívák vannak, amik Linuxon is műxenek?
-
doc
nagyúr
válasz Jhonny06 #1277 üzenetére
nem egeszen ertem a kerdest...
kezdoerteket meg tudsz adni neki siman, ha erre gondoltal
pl. osztaly.h:
class osztaly
{
int x;
};osztaly.cpp:
#include "osztaly.h"
int osztaly::x = 100;illetve ha arra gondoltal, hogy egy kozos valtozot az osztaly osszes peldanyanak, akkor a deklaracional ele kell irni egy static modositot
[ Szerkesztve ]
-
válasz Jhonny06 #1277 üzenetére
szerk, módosítás utánra: konstruktor megkaphajta pluszban inputnak a számot. azt viszont valamilyen módon követned kell, hogy hány darab cucc lett már létrehozva (létrehozó osztályba esetleg egy variáns amit megkap a konstruktor?), nem lenne egyszerűbb azt a változót használni létrehozni az új objektumokat?
ha pedig az aktuális számuk az objektumoknak is fontos, akkor a destruktorban még mindig meg lehet rakni egy hívást a container class felé.
ha meg akarod az objektumokat számozni, és mindegyiknek akarsz egy sorszámot, akkor legegyszerűbb és leggyorsabb megoldás még mindig egy container class szerintem egy globális változóval. ha törölni is akarod őket akkor a dolog bonyolultabbá válik, főleg ha a korábban foglalt de már szabad számokat is újból ki akarod tudni adni.
[ Szerkesztve ]
Don't dream it, be it. // Lagom amount.
-
doc
nagyúr
válasz Jhonny06 #1283 üzenetére
a tomb merete az, amit veletlenszerunek szeretnel? tehat csak a konstruktorban dol el, hogy hany eleme lesz a tombnek? mert akkor ne tombot hasznalj, hanem az STL-es adatstrukturakat, pl. vectort, annak a merete dinamikusan valtoztathato
a sima C-s tomb meretet meg kell adnod, nincs mese. illetve ugy meg megoldhato, hogy a konstruktorban lefoglalod a tomb meretenek megfelelo tarteruletet mondjuk igy:
tomb = malloc(sizeof(Osztalynev*) * meret)
amit aztan a destruktorbol free-vel felszabaditasz
de ilyet ugyebar nem csinalunk, C++ -ban C++-szul beszelunk, tehat vector, esetleg listMOD: akkor ugy tunik, megintcsak nem ertettelek
tehat te Osztalynev tomb[10] modon deklaraltad?
mert akkor a new Osztalynev() tenyleg nem fog belemenni, tekintve hogy az egy pointer, de meg a teljes osztalyt tartalmazo tombot csinaltal (ez utobbit NE!)[ Szerkesztve ]
-
doc
nagyúr
válasz Jhonny06 #1285 üzenetére
na azert ugy latom vannak itt eleg alapveto hianyossagok
szoval
az adatszerkezet (akar tomb, akar vector, akar valami mas) puszta adatszerkezet, ha ugy tetszik, egy darab a memoriaban, ami pont akkora meretu, amiben elfer az altalad megjelolt szamu es tipusu adat (osztaly, valtozo, stb)
ha te deklaralsz egy tombot pl. int tomb[10] akkor a memoriaban egy akkora darabot, amiben 10 int tipusu ertek elfer, lefoglal a program. de arrol, hogy ott azon a memoriateruleten mi van, semmit nem tudsz (illetve annyit, hogy 'hasznalhatatlan szemet'). neked kell azzal az adattal feltoltened, amit utana ki akarsz majd olvasni belole
ebbol adodoan a vector<Adatbazis> lista valtozod annyit mond, hogy ez egy olyan vector, amiben Adatbazis tipusu objektumok vannak, semmi tobbet. nyilvan neked kell belepakolnod az abban tarolni kivant objektumokat, maga az adatszerkezet nem fogja helyetted kitalalni hogy mit akarsz belerakni...
raadasul teljes objektumpeldanyt (nalad Adatbazis) nem tarolunk sem tombben, sem mas adatszerkezetben, helyette az arra mutato pointert szokas (tehat vector<Adatbazis*> lista)
a feltoltesnel meg nyilvan neked kell minden elemet hozzaadnod, a pointer eseteben a new-val letrehozva
a vector eseteben a resize() csak annyit mond, hogy szerinted mi a maximalis darabszam, amit bele fogsz rakni, ennek megfeleloen optimalizal, ettol fuggetlenul akar kevesebb, akar tobb elem is lehet benne
tehat ha te akarsz egy vectort amiben 10 darab Adatbazis objektum van, akkor csinalsz egy ilyet:
for (int i=0; i<10; ++i)
lista [i]= new Adatbazis();es amikor mar nem kellenek, pl. a destruktorban meg is szunteted az ojjektumokat (ez nem C#, nincs garbage collector!)
for (int i=0; i<10; ++i)
delete lista[i];ez utobbi persze szebb egy olyan megoldassal, amiben nem tarolod elore az elemek darabszamat, hanem vegigmegy a teljes listan annak meretetol fuggetlenul es kitorli mindegyik elemet
kerdezni meg mindenki szokott az elejen, sot a kozepen is ezen ne aggodj, ha normalis hangnemben kerdezel (mint ahogy eddig is tetted) szivesen segitunk
MOD: ha a listat visszaado metodust csinalsz, figyelj arra hogy ne magat a listat, hanem arra mutato referenciat adj vissza, hogy ne kelljen feleslegesen egy csomo adatot a verembe pakolni/kivenni
tehat nem vector<Adatbazis*> addide() {return lista;} hanem const vector<Adatbazis*>& addide() const {return lista;}
a const ne zavarjon meg, nem feltetlenul muszaj, de erdemes raszokni a hasznalatara
[ Szerkesztve ]
-
válasz Jhonny06 #1288 üzenetére
jaja, használd a függvényeket listát manipulálni.
próbálj valami ilyet listázni
std::vector<Hallgato*>::iterator i = lista.begin();
for(; i !=lista.end(); i++){
Hallgato *hallgato = *i;
cout << lista->getAzonosito() << endl;
}(rem nem írtam el semmit)
esetleg ha tolsz egy
typedef std::vector<Hallgato*> Hallgatok;
sort, azzal későbbiekben egy csomó kódot megspórolhatsz. pl elég a
Hallgatok::iterator i
is.(azért néha örülök neki, hogy a 7.5kredites c++ programkomponenteknek lassan vége, köv negyedévben meg megint javazunk)
[ Szerkesztve ]
Don't dream it, be it. // Lagom amount.
-
válasz Jhonny06 #1293 üzenetére
tényleg írj segédfüggvényeket szvsz manipulálni a listát.
a c++ ugyan nem dobál mindenféle fura hibaüzeneteket ha az ember megsérti az encapsulationt (ellentétben pl a netbeanssel), ugyanakkor a segédfüggvények sokkal de sokkal egyszerűbbé tudják tenni az ember életét.
vector access element
vector.at(i)
vector referencevannak példák is, azokat másolva el tudsz valahova indulni. csak pl vector<int> helyett vector<Hallgato*> kell (lehetne Hallgato is, de az lassabb).
Don't dream it, be it. // Lagom amount.
-
WonderCSabo
félisten
-
Jester01
veterán
válasz Jhonny06 #1311 üzenetére
Itt ugye nem a pointer a konstans, hanem amire a legvégén mutat (dupla indirekció után), vagyis **y nem írható.
Ez például konstans mutató és teljesen szabályos, az y maga a konstans, vagyis y nem írható:
char** const y = &x;Ez is szabályos, itt az a konstans amire az y mutat, vagyis *y nem írható:
char* const *y = &x;Jester
-
Jester01
veterán
válasz Jhonny06 #1317 üzenetére
Igen, ez már közelít az igazsághoz. A fenti kód önmagában még nem lenne baj, vagyis az, hogy az x tudja írni az y viszont nem, az még nem probléma, millió olyan eset van amikor különböző pointereken keresztül különböző elérésed van, például:
char c;
char* x = &c;
const char* y = &c;Ezzel semmi baj, x-en keresztül lehet írni, y-on nem.
A gond ott kezdődik, hogy az említett struktúra módot adna olyan konverzióra aminek során a const elveszik egy pointerből. Látszólag ugye itt éppen hozzáadódik és ez biztonságosnak tűnik, de valójában egy kiskaput nyit:
char* x;
const char** y = &x;
const char* z;
*y = z;
*x = 0;Itt a z pointerről leszedtük a const-ot és az x-en keresztül olyan címre írtunk amire nincs felhatalmazásunk. Ugye *y típusa const char* és z is ez, tehát a *y = z rendben van. Viszont mivel y=&x ezért most már x is ugyanoda mutat ahová z, csak x nem const vagyis *x írható.
Mégegyszer hangsúlyoznám, nem az a baj, hogy több pointer ugyanazt a címet különböző módon éri el, hanem az, hogy egy tetszőleges const pointerből írhatót lehetne varázsolni. (Persze egy cast-tal ezt még mindig meg lehet tenni de az már más kérdés.)
Jester
-
válasz Jhonny06 #1311 üzenetére
izé, ezzel nem az a baj, hogy a második sor jobb oldala char típusú, a jobb oldalar meg char**?
egy char** meg persze hogy nem lehet egyelővé tenni egy charral. na és valszeg ezért panaszkodik a típuskonverzióra a compiler. a visual studio szokott adni errort is, abból is ezt elvileg ki lehetne bogarászni.
a const nem zavarhat be, az csak annyit jelenthet, hogy az y értéken keresztül az x nem megváltoztatható szvsz, legalábbis funkciólnál ez így van. egyébként meg ilyen kód szerintem valós esetben classon belül nem igazán fordulhat elő. ha ez nem így van, akkor is max azt jelenti, hogy a pointer értéke nem változtatható, de az se csinálhat compiler típus errort.
vagy a harmadik ötlet: ez így design szempointból szerintem minimum fura, minek constanssá tenni egy pointert, amikor class scopeon belül azért ennyire a dolgokat szerintem nem kell védeni (illetve ha kell az már bőven régen rossz, meg amúgy sem ér semmit mert úgyis kiszedhető ez a kódrész is, ha más hozzáfér), ha meg class scopeon kívülre akarja az ember használni, akkor úgyis kell egy funkció, akinél pedig egyszerűbb írni egy constantot a funkcióra. szóval értelme ennek így semmi.
[ Szerkesztve ]
Don't dream it, be it. // Lagom amount.
-
n00n
őstag
válasz Jhonny06 #1340 üzenetére
Kezdőnek azért nem nevezném magamat, inkább a haladó előtt egy kicsivel elhelyezkedő tudásúnak.
Egyébként neki estem a könyvnek. A 141. oldalon tartok, eddig nem sok újat mondott, de azok hasznosak voltak. Amit nagyon hiányolok a fejezetek végéről megírandó feladatok. Van néhány ilyen "módosítsa a kódrészletet így, meg így". De ezek elég gyenguszok.
Tudtok olyan oldalt, ahol egyszerűbbtől indulva folyamosan egyre bonyolultabb C++ programokra vannak példák?
-
ArchElf
addikt
válasz Jhonny06 #1369 üzenetére
Gyakornoki poziba elég ha alap tudásod van. Épp arról szól a gyakornoki, hogy olyan embert keresnek, aki végja a témát (szintaktika, problémamegoldás), de nincsenek még speciális ismeretei amit meg kellene fizetni.
AE
Csinálok egy adag popcornt, és leülök fórumozni --- Ízlések és pofonok - kinek miből jutott --- Az igazi beköpőlégy [http://is.gd/cJvlC2]
-
doc
nagyúr
válasz Jhonny06 #1388 üzenetére
en nem tartom jo valasztasnak a C++ -t mint elso nyelv...
nagyon szeretem, nagyon jo kis nyelv, de kapasbol ezzel kezdeni szerintem kicsit meresz
persze ha a kollega ur eltokelt, akkor idovel jol jarhat vele, csak tul sok ganyolasra ad lehetoseget, nem 'kenyszerit ra' a normalis programozasra
(egy kollegam, aki mar azert ismer par nyelvet, most tanul C++ -t, es bar igy 1 honap utan mar SOKKAL szebbek a kodjai mint az elejen produkalt irtozatos ganyolas, azert meg most is rengetegszer kell oldalbalokodni hogy 'nem arra heee' ) -
doc
nagyúr
válasz Jhonny06 #1394 üzenetére
nem tudom hogy ertetted a "regit" (gondolom nem szo szerint, ha idezojelbe tetted), mert a C++ boven oregebb mint a JS/HTML5
a C++-t nem tartom jo elso nyelvnek, tulsagosan elvonja a figyelmet a nyelv szerkezetenek megtanulasa/megertese a megfelelo gondolkodasmodrol
a JavaScript pl. azert nem rossz valasztas, mert nagyon gyorsan kap 'vizualis' eredmenyt, konnyen modosithato/tesztelheto a forras
persze a borzalmas debugolhatosag miatt meg rossz valasztasnem tudnek nyugodt szivvel ajanlani igy hirtelen egy nyelvet sem, de a C++ -t azt hatarozottan nem (plane hogy sajat bevallasa szerint a webfejlesztes erdekli, az meg azon ritka teruletek egyike, ahol a C++ nem igazan rug labdaba (most a CGI-t ne eroltessuk))
a visual studiot meg en rettentoen utalom, szerintem a hasznalhatatlansag hatarat surolja sajna melo miatt gyakran kell hasznalnom, a tobbiek mindig tudjak amikor ez tortenik, mert folyamatosan kurvaanyazok (konkretan VS2005, de ketlem hogy az ujabbaknal szamottevo elorelepes tortent volna)
-
doc
nagyúr
válasz Jhonny06 #1408 üzenetére
ha a fv-nek van visszateresi erteke (marpedig van, kulonben nem kerdezned ), akkor valamit mindenkepp adj vissza. ezt elvileg a forditonak sem lenne szabad engedni, ha megis, akkor forditofuggo hogy mit csinal pontosan gondolom
kulonben ha fel akarod hasznalni a visszateresi erteket, akkor mit fogsz kapni?
szoval sima return-t csak void fv-ekben hasznalj -
Chipi333
csendes tag
válasz Jhonny06 #1408 üzenetére
Sima return-el csak void fv-ben tudsz visszatérni, egyébként a compilernek sikitania kéne. Ott viszont nem tudsz vele hibát jelezni, mivel ez az egyetlen visszatérési értéked, szóval nem értem a dolgot.
Az jutott még eszembe, hogy pointer tipusnál talán null-t adna vissza de a g++ akkor is errort dobott rá. -
Gyuri16
senior tag
válasz Jhonny06 #1417 üzenetére
ha arra gondolsz, hogy 4x kiirja, hogy Empty tree az azert van, mert amikor a rekurziv hivasokkal a countNodes fv a levelekbe er, ott a root NULL lesz. a fa uresseget csak a gyokerenel lehet vizsgalni. a count valtozodnak nem kellene staticnak lennie. ha mas baj is van, akkor megnezem jobban, csak ezt talaltam gyorsan.
azon kivul a pre/post/in order eljarasaidban kicsit gubanc van, gondolom itt a copy paste nem lett rendesen javitva.
Nem vagyok egoista, csak uborkagyalu!
-
Gyuri16
senior tag
válasz Jhonny06 #1426 üzenetére
nem csak ket mutato lesz lefele, hanem sok. konkretumot akkor tudok mondani, ha elmondod mire kell. binaris fakbol se csak olyanok vannak ahol a bal a kisebb ertekeke a jobb meg a nagyobbake.
ha a kereso faknal maradunk akkor nezd meg pl a b-treet. ez egy hasonlo (kicsit bonyolultabb) adatszerkezet mint a bin. kereso fa, viszont nem feltetlenul binaris. ezt adatbazisoknal hasznaljak pl.
masik jo pelda a trie amit kulonbozo szoveges algoritmusnal hasznalunk.altalanosan elmondhato, hogy minden elemben lesz tobb mutato a gyerekekre, ez lehet egy tombben, lancolt listaban vagy valami bonyolultabban.
Nem vagyok egoista, csak uborkagyalu!
Új hozzászólás Aktív témák
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!