C++

 ( and1 | 2005. január 11., kedd - 21:22 )

Hozzászólás megjelenítési lehetőségek

A választott hozzászólás megjelenítési mód a „Beállítás” gombbal rögzíthető.

[quote:21057fe8e9="rigidus"]
Ilyenkor hogyan lehet megallapitani, hogy az Object1::owner-be tarolt ertek eredetileg Object2 vagy Object3 tipusu volt? Nyilvan lehet deklaralni egy sorszamot vagy szoveges valtozot amibe egy szoveget beleteszek osztalyonkent, pl: azonosito = "Object2", de engem olyasmi erdekelne, ami kepes erzekelni az atvett valtozo tipuskenyszerites elotti tipusat. Lehet ilyent csinalni?[/quote:21057fe8e9]

dynamic_cast-al nem próbálkoztál?

Ez első kérdésedhez: tudsz mutatni (első körben) .h forráskódot?

Hali mindenki!

Kis segítség kéne, nem találtam sehol a neten Free visual c/c++-t ami letölthető lene. Ha valaki tud ilyen címet vagy bármi segítséget tud adni azt szivesen várom e-mailben (bill@gamma.ttk.pte.hu).

Előre is kössz mindent! :) Bill

[quote:813fd54b9d="ssikiss"]dynamic_cast-al nem próbálkoztál?[/quote:813fd54b9d]
Jól mondja, ez az egyik megoldás, a másik a typeid:
[code:1:813fd54b9d]
#include <stdio.h>
#include <string.h>
#include <typeinfo>

class Ember
{
virtual void asdf() {}; // kell egy virtualis fgv, hogy polimorf legyen a tipus
public:
char *nev;
};

class Dolgozo : public Ember
{
public:
int fizu;
};

void chk(Ember *e)
{
Dolgozo *d;

printf("Neve: '%s'\n", e->nev);
printf("Tipus: '%s'\n", typeid(*e).name());
d = dynamic_cast<Dolgozo*>(e);
//if (typeid(*e) == typeid(Dolgozo)) /* az alabbi 'if (d)'-vel egyenerteku */
if (d)
{
printf("Fizu: '%d'\n", d->fizu);
}
}

int main(void)
{
Ember *e;
Dolgozo *d;

e = new Ember();
e->nev = strdup("Lusta Gejza");

d = new Dolgozo();
d->nev = strdup("Dolgos Pista");
d->fizu = 123456;

chk(e);
chk(d);
return 0;
}

[/code:1:813fd54b9d]

Hi!

Tudja vki, hogy lehet istreamekből normálisan blokkosan olvasni? Két fv-t találtam: get, read. Ezek viszont nem mondják meg, h tulajdonképpen mennyit is olvastak be :x.

/megj
A get-nek \0-t adva delim-nek legalább van egy módszer amivel garantáltan azt olvasom be ami fileban van. De ez eléggé bénázás, meg ha sok 0 van a fileban akkor nem különösebben hatékony.

Meg persze a byte-onkénti get().
/megj off

[quote:a561d47ee3="antiemes"]Hi!

Egy fontos dolgot nem art leszogezni. A C meg a C++ nem ugyanaz, sot teljesen mas nyelvek. Ha olyan konyv kell, ami az alapoktol kezdve magyaraz, akkor te valoszinuleg C-ben akarsz megtanulni, nem pedig C++-ban; ha esetleg megis C++-t akarsz, akkor se rossz elotte egy kis C. C-re az eddigi legjobb konyv a Kernighan & Ritchie: A C programozasi nyelv. A szerzoket lehet, hogy nem igy kell irni...

By(t)e
TBS::Antiemes[/quote:a561d47ee3]

Ehez meg hozzatennem, hogy az egyik legjobb magyar C konyv a Pere Laci fele C programozasi nyelv. Nagyon jol ir, es habar elvileg kezdoknek van a konyv van par olyan teme benne amiket mas C konyvekben nem is lattam (pl halozatkezeles). Mindenkeppen erdemes megvenni aki meg kezdo C-bol. Kiskapus, es asszem olyan 2-3E korul van az ara, szal annyira nem is huzos.

[quote:611180984b]Tudja vki, hogy lehet istreamekből normálisan blokkosan olvasni? Két fv-t találtam: get, read. Ezek viszont nem mondják meg, h tulajdonképpen mennyit is olvastak be.[/quote:611180984b]

istreameknél használható a gcount(), ami pont erre való.

[quote:d02b2f67c7="ssikiss"]dynamic_cast-al nem próbálkoztál?

Ez első kérdésedhez: tudsz mutatni (első körben) .h forráskódot?[/quote:d02b2f67c7]
Az elso megoldodott idokozbe, betettem abstract-nak 3 metodust callback esemenykezeleshez es lefelejtettem a {} az abstract metodusok utan. Igazabol bepostoltam a forraskodot is eredetileg, de kiszerkesztettem, mert baromi hosszu volt, nem akartam megkockaztatni, hogy le leszek erte baszarentva. :oops:

A dynamic_cast -ot es a typeid -t kiprobalom, koszonet erte Neked es gsimonnak is. :wink:

Visual C++ a Microsofté, a Visual Studio része (most: Visual Studio.NET 2003), így ebből csak fizetős van.
Amennyiben a C++ a lényeg, akkor windowsra pl Dev-C++, mingw32, stb. ill linuxon természetesen g++ :D

[b:3d2209e00f]
Ha mar itt tartunk tud vmi jo doksit arra vonatkozoan, hogy c++-ban hogyan kell tisztessegesen megoldani a memoriakezelest? Mert ahogy no a kod, ugy bonyolodik.... Ezert szimpatikusak az automatikus szemetgyujtovel rendelkezo nyelvek (C#, Java),
[/b:3d2209e00f]

Egyszerű a megoldás. Kerülni kell a new kulcsszó használatát C++ ban. Csak akkor kell new-val létrehozni objektumokat, ha arra tényleg nincs más lehetőség. A statikus változók meg maguktól felszabadulnak, azokra nem kell figyelni.

hatékony memóriakezelés:
a téma a Boost ingyenes programkönyvtárral szépen körbe van járva. lényeg: a c++ memóriakezelése ugyanannyira "hatékony", mint a c nyelvé, ez így értelmetlen kifejezés.
Amire valószínűleg Te gondolsz, az az, hogy Garbage collection legyen a c++-ban.
Semmi probléma, meglehetősen egyszerű, csak egy picit el kell rajta gondolkozni, hogy miért is kell garbage collection? Ha azért, hogy soha ne is kelljen foglalkozni a felszabadítással, akkor rossz programozási nyelvet választottál. A c++ ugyanis olyan közel van a vashoz, amennyire csak OO nyelv lehet, hogy ne legyen teljesítmény vesztesége.
Ha mindenhol GC-t használsz, olyan szörnyűséges memóriazabáló, swappelő programokat kapsz, mint Java-ban, c#-ban írnak a naivak.
Valójában ugyanis erre csak olyan objektumok esetében van szükség, amelyeknél a tulajdonlás /ki felelős az objektumért/ nem tudható előre, és ez már elég bonyolult rendszerben fordul elő, ott sem általánosan.

Megoldás: használd a boost könyvtárat, az abban levő többfajta SharedPointer implementáció közül válaszd azt, ami céljaidnak leginkább megfelel. Tanulához legegyszerűbb talán az intrusive_ptr, ami egy integer RefCount bevezetését igényli a GC-zendő osztályba és innentől automatikusan pusztul az objektum.

szerintem.

visszaolvasva lehet hogy nem voltam elég világos:
a boost-os SharedPointer-ek sokkal hatékonyabbak, mint egy Javas GC. Itt ugyanis abban a pillanatban, hogy az utolsó felhasználó "lekapcsolja a villanyt" vagyis nincs szüksége az objektumra, az azonnal pusztul, nem kell hozzá egy külön algoritmus ami időnkét végigsöpör az elárvul objektumok között és rendet tesz. Vagyis nem lesz memóriazabálás.

[és még panaszkodnak a c++ -ra... itt te választasz, hogy szép leszel vagy ultrahatékony, esetleg mindkettő egyszerre]

hali. honnan tudnám netről leszedni a C++ magyar fordítást amiben az alapokról írnak ( tutorial )????

köszi!! :D

[quote:3f3b7db7b0="Bill"]Kis segítség kéne, nem találtam sehol a neten Free visual c/c++-t ami letölthető lene.[/quote:3f3b7db7b0]

Szerintem erre gondoltal:
http://msdn.microsoft.com/visualc/vctoolkit2003/

Ha nem tudsz angolul, legjobb ha veszel egy jó könyvet, megéri a befektetést. C-ben itt eltudsz indulni:
http://www.prog.hu/cikkek/?ndid=4540&pg=3

(tudom Te C++ keresel, de ha kezdő vagy ez is sokat fog segíteni)

1. Ha szamitogepekkel akarsz foglalkozni, kulonosen programozni tanulj meg angolul! _SOSE_ leszel jo programozo ha nem tudsz angolul.
2. Tanuld meg a keresok (pl. google) a hasznalatat.
3. Ne nyiss minden egyes kerdesednek egy kulon topikot. Inkabb keress egy ismerost aki mar ert hozza, hivd meg egy par sorre es kerdezgesd ki.

Amiket irtam ne beszolasnak vedd. (Hidd el amugy hogy a legtobb embert idegesitenek az ilyen kerdesek.)

neeeeeeeeeeeeeee hivja meg sorre!:) az a halalom amikor meghiv valaki egy sorre, h megtanuljon hackelni fel ora alatt!:)

Sziasztok!

Ha már a C++ ban történő memóriakezelésről van szó lenne egy kérdésem ezzel kapcsolatban.
Olyan fuggvényekről van szó, amelyek visszatérési értékként objektumot adnak vissza (vagy barmi mast, lenyeg, hogy nem egy egyszeru skalar tipust a mit a fordito megold egy regiszterben torteno visszadassal, hanem olyat ami tobb helyet foglal)
A visszadott erteket fel szeretnem hasznalni a hivo oldalon (nyilván :lol:)
Ha a fuggvenyemben nem foglalom ne expliciten a memóriát new al vagy malloc, stb. vel csak egy lokalis valtozot atok vissza pl:
Obj* foo(void)
{
Obj o(1);
...
return &obj;
}
Ekkor baj van, mivel az o objektum csak a foo fuggvenyen belül él, es a hivo fuggvenyben mar nem biztos, hogy megvannak az adatok. Es ez igy eleg csunya,meg rossz is, ettol mindenkepp tartozkodnek...
Néha müködhet ugyan de ilyennel lehet jo kis insdtabil progit irni...
Masik /1. igazi/megoldas, ha lefoglalom:
Obj *foo(void)
{
Obj *o=newObj(1);
...
return o;
}
NA de ekkor hivo oldalon fel kell szabaditanom a memoriat, es ha ez a fuggveny netan be lenne agyazva valahova / function(1,foo()); /
akkor a felszabaditas vegett kulon kodokat kell beepiteni arra, hogy megjegyezzuk a cimet, aztan felszabaditsuk

Obj *tmp;
function(1,tmp=foo());
delete tmp;

Ez mar talan jobb megoldas, de ez meg azert nem nagyon tetszik, mert igy a felszabaditas nagyon "messze" kerulhet a kodban a foglalastol, es ez plusz hibakat eredmenyezhet, nem beszelve arrol, ha a foo esetleg nem csak egyféle tipust adhatna vissza/szarmaztatott osztalyok pointerei pl./, nem is beszelve a NULL rol speci esetekben.

Akkar marad a referencia alapjan? De ekkor a referencia altal "referalt" osztaly hol hal meg?
Nem is beszelve arrol, hogy mi van ha nem osztalyt akarok visszadni, hanem egy tomb pointert? /mondjuk char * ot /
Ekkor ugye a referenciat el lehet felejteni.
Ha nem szabaditjuk fel az meg eleg nagy gond lehet, ha a kodott 1000 szer vagy meg tobbszor meghivjuk.

Ki hogy szokta az iylen ügyeit bonyolitani?

Hi!

Bocs, nem említettem, hogy en is tudok ilyen memóriakezelő könyvtarakrol, de engem itt most a C++ saját házon belüli megoldásai érdekelnének.
Persze a javaslatokra azért kíváncsi vagyok ezenfelül...

Udv!

Sziasztok,

1. A nagyobbik problemam a kovetkezo lenne: adott egy C++ -os progi ahol forditasi hibakent egyfolytaba bombaz a szokasos "undefined reference to `vtable for SGui'" dologgal:
[code:1:bd5ea75028]/home/tony/projects/opengl/sds/src/sgui.h:50: undefined reference to `vtable for SGui'
/home/tony/projects/opengl/sds/src/sgui.h:50: undefined reference to `vtable for SGui'
/home/tony/projects/opengl/sds/src/sgui.h:50: undefined reference to `vtable for SGui'
/home/tony/projects/opengl/sds/src/sgui.cpp:24: undefined reference to `vtable for SGui'
/home/tony/projects/opengl/sds/src/sgui.cpp:24: undefined reference to `vtable for SGui'
*** Exited with status: 2 ***
[/code:1:bd5ea75028]

Termeszetesen a constructor-ok, destructor-ok meg vannak mindenhol es meg is vannak irva. (nemelyik csak uresen)

Azt ertem, hogy a virtualis metodus tablan visszafele akar keresni, de az osobjektumokhoz hozza sem nyultam es elotte mukodott. Amit valtoztattam, az egy constructor-ba megadott valtozo inicializalasa:

[code:1:bd5ea75028]SGui::SGui()
{
quit = false;
}
[/code:1:bd5ea75028]

Valamint deklaraltam meg ket valtozot. A vicc az, hogy kikommenteztem ugy, hogy az eredeti formaba nezzen ki, de nem valtozott semmi, ugyanugy jonnek az "unresolved" marhasagok, pedig elotte ment.
(na jo azert a hiba nem a forditoba van hanem a programozoba :mrgreen: )

Volna azonban egy kisebb problemam is:

2. Van itt hozza egy peldakod eloszor:
(remelem nem irtam el)
[code:1:bd5ea75028]
class Object1;
class Object2;
class Object3;

class Object1
{
public:
Object1 *owner;
Object1(Object1 *aOwner) { owner = aOwner; }
};

class Object2: public Object1
{
public:
Object2();
};

class Object3: public Object1
{
public:
Object3();
};

Object2::Object2
{
Object2 *localOwner = (Object2*) owner;
}

Object3::Object3
{
Object3 *localOwner = (Object3*) owner;
}

...

main( int argc, int **argv )
{
Object2 obj2;
Object3 obj3;
Object1 obj1a = Object1( (Object1*) obj2);
Object1 obj1b = Object1( (Object1*) obj3);
}

[/code:1:bd5ea75028]

Ilyenkor hogyan lehet megallapitani, hogy az Object1::owner-be tarolt ertek eredetileg Object2 vagy Object3 tipusu volt? Nyilvan lehet deklaralni egy sorszamot vagy szoveges valtozot amibe egy szoveget beleteszek osztalyonkent, pl: azonosito = "Object2", de engem olyasmi erdekelne, ami kepes erzekelni az atvett valtozo tipuskenyszerites elotti tipusat. Lehet ilyent csinalni?

Koszi elore is :)

Rigidus

Az stl-ben van egy auto_ptr nevu template.
Hasznalata: http://www.gotw.ca/gotw/042.htm
(MSVC-t hasznalok ne nagyon oruljenek neki, ott eleg hianyos az implementacio)

Egyebkent a temaval eleg kimeritoen foglalkozik "Andrei Alexandrescu: Modern C++ Design" konyve (a smart pointer resz 40 oldal, szal szeirntem eleg nehez a temat elintezni par szolassal). Aki tud angolul olvasni, s szeretne hosszu tavon C++-al foglalkozni, annak nagyon ajanlott ezen konyv beszerzese. En az swsbooks-nal vettem meg. A konyv weblapja: [url]http://www.moderncppdesign.com/[/url]

Egyebkent ajanlott a magyarul is megjelent "Scott Meyers: Hatekony C++" konzve is, az is foglalkozik az objektumok eletevel.

[quote:04da5ce8f0="hyper80"]Hi!

Bocs, nem említettem, hogy en is tudok ilyen memóriakezelő könyvtarakrol, de engem itt most a C++ saját házon belüli megoldásai érdekelnének.
Persze a javaslatokra azért kíváncsi vagyok ezenfelül...

Udv![/quote:04da5ce8f0]

amit írtam, a SharedPointer család pontosan ilyen esetekre van kitalálva.
A lényeg, hogy beburkolod a new-val létrehozott objektumodat egy SharedPointer-be, ami gondoskodik a nyilvántartásról és az elpusztításról.

tehát legegyszerűbb esetben:
[code:1:04da5ce8f0]
===Obj.h===

#include <SharedPointer.h>

class Obj
{
public:
int RefCount; //hányan használják éppen
//----------

Obj() {RefCount=0;}

void DoThis();
void DoThat();
};

inline SharedPointer<Obj> CreateNewObj()
{
return SharedPointer<Obj>(new Obj());
}

===ObjUser.cpp===

int main()
{
{ //Obj test
//letrehozas
SharedPointer<Obj> AnObj = CreateNewObj();

//hasznalat
AnObj->DoThis();
AnObj->DoThat();

//masolas ide-oda, vektorba rakas
vector< SharedPointer<Obj> > Objects;
Objects.push_back(AnObj); //RefCount = 2

vector< SharedPointer<Obj> > Objects2;
Objects2 = Objects; //RefCount = 3

Objects.clear(); //RefCount = 2
Objects2.clear(); //RefCount = 1
}//AnObj elpusztul, RefCount = 0 lesz, a benne levo Obj is pusztul
}
[/code:1:04da5ce8f0]

[quote:79024997de="tejfel"]Az stl-ben van egy auto_ptr nevu template.
[/quote:79024997de]

ezt inkább [b:79024997de]nem javasolnám[/b:79024997de]. rosszul tervezett osztály.

csak a probléma van vele, hiszen nem képes az értékadást és a shared eseteket kezelni. Azt feltételezi, hogy pontosan 1 gazdája van az objektumnak, ezért csakis akkor jó, ha A osztály tartalmaz egy B osztályra mutató pointert, amit A osztály pusztulásakor pusztítani kell.

Igen csúnya programhibákat okozhat.

[quote:0f7d8d3dc0="hyper80"]
Obj* foo(void)
{
Obj o(1);
...
return &obj;
}
[/quote:0f7d8d3dc0]
Ez nem csunya, hanem nem mukodik. A valtozod felszabadul mikor a scope-on kivulre kerulsz (jelen esetben mikor visszatersz a fuggvenybol).

[quote:0f7d8d3dc0]
Obj *foo(void)
{
Obj *o=newObj(1);
...
return o;
}
NA de ekkor hivo oldalon fel kell szabaditanom a memoriat, es ha ez a fuggveny netan be lenne agyazva valahova / function(1,foo()); /
akkor a felszabaditas vegett kulon kodokat kell beepiteni arra, hogy megjegyezzuk a cimet, aztan felszabaditsuk
[/quote:0f7d8d3dc0]
Erre adnak egyfajta megoldast a kulonfele smart pointerek.

Igazabol a konkret design adja meg mit es hogyan erdemes hasznalni. A lehetosegek szama annyira nagy, hogy altalanos megoldast nem nagyon lehet adni.
A design soran dolnek el a felelossegek. Az objektumot annak kell felszabaditania akire bizod ezt a felelosseget.

A smart pointer rendelkezhet ilyen felelosseggel, de nem szunteti meg a problemakat, hanem attestalja egy szimpla pointerrol egy objektumra.
(a modern c++-ban a birtoklasra 5 fele strategiat irnak le, s ezen felul
foglalkoznak meg a thread kezelessel stb.)

[quote:0f7d8d3dc0]Akkar marad a referencia alapjan? De ekkor a referencia altal "referalt" osztaly hol hal meg? [/quote:0f7d8d3dc0]
Ahol a referalo valtozo :).

[quote:0f7d8d3dc0]Nem is beszelve arrol, hogy mi van ha nem osztalyt akarok visszadni, hanem egy tomb pointert? /mondjuk char * ot /[/quote:0f7d8d3dc0]
Adj vissza stl::vektor-t. A jol hasznalt vector tud hatekony lenni.
A boost-ban van olyan smart pointer amit be tudsz tenni tombbe.
http://boost.org/libs/smart_ptr/smart_ptr.htm
(es van olyan smart pointer is, amibe array-t tudsz tenni)

[quote:0f7d8d3dc0]Ki hogy szokta az iylen ügyeit bonyolitani?[/quote:0f7d8d3dc0]
A C++ egy alacsony magas szintu nyelv. A memoriakezeles
a te kezdben van.

Nem veletlenul terjednek a sciptnyelvek, s a java es .Net alapu
dolgok. Ahol nem kell a C/C++ sebessege,
ott erdemes szetnezni az eszkozott kozt.

Hello

Kösz én elég jól megvagyok a C++ al. Teszik a filozófia, a nyelv a sebesség, stb. :lol:
Persze a szkriptnyelvek is jók, de csak korlátozott feladatokra, részterületekre.
Ahol igazán komoly programot kell irni ott szerintem a C++ a nyerő. (szubjektív :D )

A memórias kérdésem arra vonatkozott, hogy hogy a legszebb a dolog szerintetek. Amint látom két fő irányvonal van, az egyik hogy zárjuk osztályba a dolgokat barmi is lenne, oldjuk meg referenciákkal és akkor hatékony kódot kapunk mert a referenciakal nem történik teljes objektummásolás viszont a meghalás/felszabadulás is meg van oldva.
A char * os péda esetén meg osztálybazárás, konstuktorban new [] destruktorban delete [] rulez.... :wink:

Márik megoldás meg akülső segítség hívása, ami szép meg jó, csak a fene se tudja, hogy mennyire hatékony....
Persze minden bizonnyal még mindig joval gyorsabb mint egy Java.

[quote:f5225523db="dominis"]neeeeeeeeeeeeeee hivja meg sorre!:) az a halalom amikor meghiv valaki egy sorre, h megtanuljon hackelni fel ora alatt!:)[/quote:f5225523db]
de nagy arcz!! :) eza bujtatott szerenyseg esete :lol:

btw, angol kell, kesz, es jah, enis konyvet javaslok kezdesnek. szentem egy konyv (akar vmi jokis pdf, vagy papir :D ) kell mindenkepp, ide nekem az oroszlant hozzaalassal megreked az ember egy ponton, mert vmi alap hianyzik, es imho ez csak hatvanyozodik, ha elso nyelv, vagy c utan.

>Ahol igazán komoly programot kell irni ott szerintem a C++ a nyerő. (szubjektív :D )
Mivel nem definalt az igazan komoly, ezert ebbe bele lehet kotni :o).
Azert java-ban, .net-ben, es C-ben is igen komoly dolgok keszulnek.

>A memórias kérdésem arra vonatkozott, hogy hogy a legszebb a dolog szerintetek.
Mindig attol fugg hogyan hasznalod fel a letrehozott objektumot.

>Amint látom két fő irányvonal van, az egyik hogy zárjuk osztályba a dolgokat barmi is
> lenne, oldjuk meg referenciákkal és akkor hatékony kódot kapunk mert a referenciakal
>nem történik teljes objektummásolás viszont a meghalás/felszabadulás is meg van oldva.
S vannak a pointerek, mert azert nem lehetetlen feladat olyan design-al elojonni,
ami pointerekkel szepen jol es hatekonyan mukodik. A pointer az csupan 4 (vagy 8) byte,
szal eleg keves helyet foglal, konnyen gyorsan lehet kezelni, sokan szeretik.

>Márik megoldás meg akülső segítség hívása, ami szép meg jó, csak a fene se tudja,
>hogy mennyire hatékony....
Ha a forras rendelkezesre all meg tudod nezni mennyire hatekony.
A C++-ban jol programozas hatalmas falat. Ha az ilyen kulso segitsegeket
eldobod, nagy segitseget dobsz el. Nem is azt mondom, hogy linkeld mindenedhez
a boost-ot, hanem hogy ott a boost forrasa, nezd meg mit miert es hogyan.
Nagyon jo a doksija.

>Persze minden bizonnyal még mindig joval gyorsabb mint egy Java.
Rosszul felhasznalva nem. Nemreg volt valahol cikk, melyben kihoztak a java-t
gyorsabbnak a C++-al szemben. Az implementaciokat megnezve teljesen
ertheto volt miert volt gyorsabb a java mint a C++.

Majd kitanulmányozom 8O

Azzal viszont nem nem leptel meg, hogy egy ket implementáció lassab tudott lenni mint a Java. Sz** programot minden nyelven lehet írni. :lol:

Angolul pedig tudnam ajanlani a Bruce Eckel fele Thinking in C++-t. Elerheto a szerzo honlapjarol pdf-ben: www.bruceeckel.com

and1 megnezted valaha hogy mit valaszoltak a kerdeseidre vagy csak bot vagyol ?

ha bot, akkor valaki kifejtené mely lehetséges céllal nyit topikokat? vagy már a topic nyitás is 0wn3d-nak számít? :)
"i for one welcome our topic-0wning overlords..."

Könyv:
[url=http://www.kiskapu.hu/main.php?SHOW_BODY=termekinfo&TERMEKINFO_ID=120233201]Bjarne Stroustrup: A C++ programozási nyelv.[/url]
[url=http://www.kiskapu.hu/main.php?SHOW_BODY=termekinfo&TERMEKINFO_ID=121980901]Scott Meyers: Hatékony C++[/url]

Magyarul is van jó könyv :)

[quote:09a9ab763a="_Joel"]Angolul pedig tudnam ajanlani a Bruce Eckel fele Thinking in C++-t. Elerheto a szerzo honlapjarol pdf-ben: www.bruceeckel.com[/quote:09a9ab763a]

Én is javaslom a Thinking in C++ -t. Letölthető HTML-ben is.
Amúgy van Thinking in Java ill. Thinking in patterns is, hogy csak néhányat említsek.
Ha valakit érdekel, mindenképpen érdemes megnézni a www.bruceeckel.com -ot.

Üdv.: Tomyellow

Hi!

Egy fontos dolgot nem art leszogezni. A C meg a C++ nem ugyanaz, sot teljesen mas nyelvek. Ha olyan konyv kell, ami az alapoktol kezdve magyaraz, akkor te valoszinuleg C-ben akarsz megtanulni, nem pedig C++-ban; ha esetleg megis C++-t akarsz, akkor se rossz elotte egy kis C. C-re az eddigi legjobb konyv a Kernighan & Ritchie: A C programozasi nyelv. A szerzoket lehet, hogy nem igy kell irni...

By(t)e
TBS::Antiemes

[quote:6231d483f4="antiemes"]Hi!
C-re az eddigi legjobb konyv a Kernighan & Ritchie: A C programozasi nyelv. A szerzoket lehet, hogy nem igy kell irni...

By(t)e
TBS::Antiemes[/quote:6231d483f4]

Ezzel maximalisan egyetertek!

Ha mar itt tartunk tud vmi jo doksit arra vonatkozoan, hogy c++-ban hogyan kell tisztessegesen megoldani a memoriakezelest? Mert ahogy no a kod, ugy bonyolodik.... Ezert szimpatikusak az automatikus szemetgyujtovel rendelkezo nyelvek (C#, Java), mert mindig sokat kellett veszodnom ezzel a terulettel. (meg jo hogy eles projektet meg sosem kellett csinalnom c/c++-ban)

[quote:3cbc2d9ad2="nug"][quote:3cbc2d9ad2="antiemes"]Hi!
C-re az eddigi legjobb konyv a Kernighan & Ritchie: A C programozasi nyelv. A szerzoket lehet, hogy nem igy kell irni...

By(t)e
TBS::Antiemes[/quote:3cbc2d9ad2]

Ezzel maximalisan egyetertek!

Ha mar itt tartunk tud vmi jo doksit arra vonatkozoan, hogy c++-ban hogyan kell tisztessegesen megoldani a memoriakezelest? Mert ahogy no a kod, ugy bonyolodik.... Ezert szimpatikusak az automatikus szemetgyujtovel rendelkezo nyelvek (C#, Java), mert mindig sokat kellett veszodnom ezzel a terulettel. (meg jo hogy eles projektet meg sosem kellett csinalnom c/c++-ban)[/quote:3cbc2d9ad2]

Szia!

Ha jól emlékeszem léteznek szemétgyűjtő könyvtárak C++ alá is. Hogy milyenek, free -k, stb., azt nem tudom. Keress rá google-ban!

Üdv.: Tomyellow

[quote:e5fb171c93="imp"][quote:e5fb171c93]Tudja vki, hogy lehet istreamekből normálisan blokkosan olvasni? Két fv-t találtam: get, read. Ezek viszont nem mondják meg, h tulajdonképpen mennyit is olvastak be.[/quote:e5fb171c93]

istreameknél használható a gcount(), ami pont erre való.[/quote:e5fb171c93]

THX! :oops: