Új hozzászólás Aktív témák
-
dabadab
titán
válasz
Tomi_78
#4443
üzenetére
Disclaimer: se CodeBlocksot, se wxWidgetset nem használtam soha.
Ez azt jelenti, hogy nem találja a wxmsw31ud.lib könyvtárat (gondolom ez lehet a wxWidgets). Ennek oka lehet pl. az, hogy a 3.2.4-es verzióban ez wxmsw32ud.lib néven fut (vagyis szólni kellene a Code Blocksnak, hogy ne 3.1-et akarjon használni) ésvagy nincs jól beállítva a CodeBlocksban a wxWidgets elérési útja.
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
pocokxx
#4440
üzenetére
gondolom ezért foglalkozunk csak így vele.
Hát... hány éves vagy, királyfi?...
A kiválasztás (eldöntés + keresés) típusalgoritmusnál használhatok for ciklust simán bool nélkül?
Szerintem nem értem a kérdést.
A mellékelt kódban nem látszik, hogy az elsonegativindexe* hogyan és hol lett inicializáva (már ha egyáltalán), márpedig az az értéke nem fog változni, mert ha a bevittadatok[i]* negatív, akkor a for a ciklusfeltétel miatt pont azelőtt megszakítja a ciklust, hogy értéket adnál neki.*: kódban ne használj magyar változóneveket és kommenteket. soha. tényleg soha.
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
pocokxx
#4437
üzenetére
Azért javasoltam, hogy olvass el valamit, ami megadja az alapokat.
Ez, amit írtál, tulajdonképpen szintaktiailag helyes (a struct }-ja után mondjuk hiányzik egy pontosvessző meg a két utolsó cin után hiányzik a >>), meg lefordul, meg azt is csinálja, amit szeretnél (kivéve, ha pl. a user százegynél több nevet akar megadni (mert valamiért nem a MAX_NEVEK számára foglalsz tömböt, hanem annál eggyel többre)) - csak hát így nem írunk C++-t.
A "const" az inkább "constexpr" kellene, hogy legyen, mert az jól láthatóan fordítási idejű konstans, de nincs is rá szükség, mert a C stílusú tömbök azok pont ugyanannyira nem valók C++ kódba, mint a goto, tessék az STL-t használni, a vector<string> tökéletes ide.
Na, és ezek miatt kellene valami rendes anyag, amit használsz és kifejezetten friss, up-to-date kell (amit csinálsz az ránézésre valami magyar egyetemi jegyzetből lehet, mert a negyedévszázados C++ fejlesztői karrierem során csak ott találkoztam azzal, hogy stdin-ről olvasnak be dolgokat
), mert a C++ dinamikusan fejlődő nyelv.DRM is theft
-
dabadab
titán
válasz
pocokxx
#4435
üzenetére
Hajjaj
A struct változót
A struct az nem változó, hanem egy típus leírása, pont úgy, ahogy a class is. Az ott csak a típusleírás, abból önmagában még nem keletkezik semmiféle változó.
Nálad valószínűleg azért kell odaraknod, mert a C++ fordító a fordítási egységben fentről lefele halad és ha azelőtt használsz egy típust, mielőtt megmondtad volna, hogy mi az, akkor az fordítási hibát okoz.
A struct mellé tömböt is deklarálni kell const paranccsal, aminek kötelező másik nevet adni?
A const nem parancs, hanem kulcsszó és a const tulajdonságot adja hozzá az adott deklarációhoz/definícióhoz (hogy az konkrétan mit jelent, az attól függ, hogy konkrétan mihez adod hozzá, változóknál pl. azt, hogy a kezdeti értékadáson túl nem lehet megváltoztatni az értéküket).
Egyébként amit ott csinálsz, az az, hogy létrehozod ténylegesen egy változót (amit a struct ugye nem csinál meg). Ennek nem kell feltétlenül tömbnek lennie (sőt, C++-ben a C stílusú tömbök leginkább kerülendők, mert csak a baj van velük), lehet egy sima változó is vagy valamilyen STL-es container, akármi.
Nem kötelező másik nevet adni, mert a C++ fordító van annyira okos, hogy tudja, hogy hol számíthat változó- és hol típusnévre, de nagyon érdemes, hogy ne legyen belőle keveredés (az elég bevett konvenció, hogy a típusnevek nagybetűvel kezdődnek, a változók meg kisbetűvel).
De a kérdéseid alapján az látszik, hogy az alapok nagyon hiányoznak nálad, érdemes lenne legalább az elején elolvasni valami bevezető anyagot, pl. akár ezt (ez már csak azért is jó, mert ott a weboldalon a c++ fordító is, azzal nem kell külön vacakolni az elején, amikor még amúgy is minden nagyon zavaros).
DRM is theft
-
-
dabadab
titán
A válasz nagyon egyszerű: azért nem megy, mert a C++ szabvány nem engedi
A "miért nem engedi?" kérdésre talán az a válasz, hogy kinézetre nagyon hasonlít a metódusdeklarációra, nem tudom.
Szóval ami lehetőség marad, az a copy initializing (amit te is írtál) vagy, ami az adott esetben értelmesebb, a közvetlen brace-es (direct list initialization):class B{private:A m_a{"asdf"};public:std::string get(){return m_a.get();}};[ Szerkesztve ]
DRM is theft
-
#4359
dabadab
titán
DrojDtroll
#4357
dabadab
titán
válasz
DrojDtroll
#4357
üzenetére
Nem teljesen értem, hogy mit akarsz (pl. hogy miért van ott az x típus), de nekem kifejezetten gyanús, hogy azért nem akar összeállni neked ez a megoldás, mert meg akarod erőszakolni a nyelvet és valójában azt kellene csinálnod, hogy átgondold, hogy igazából mit akarsz és azt megoldani.
Szóval: igazából mit akarsz csinálni?
DRM is theft
-
dabadab
titán
válasz
daninet
#4343
üzenetére
Úgy nézem, hogy igen.
Én ennyit változtatnék rajta, ha már tulajdonképpen az if feltételei között impliciten szóba került, hogy az autofile_indexnek akár 10 feletti értéke is lehet (és akkor ez lekezelné azt is, meg rövidebb is):if (autofile_index >= 10)
autofile_index = 1;
else
autofile_index++;[ Szerkesztve ]
DRM is theft
-
dabadab
titán
Teljesen jol definialt az elso eset
A C++ standard ezt másképpen gondolja
"In a single-object delete expression, if the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined."
[link]DRM is theft
-
dabadab
titán
Delete esetén ha a statikus (az első példában Base, a másodikban void) és a dinamikus (Derived) típus különbözik, akkor a dinamikus típusnak a statikus leszármazottjának kell lennie ÉS a statikus típus destruktorának virtuálisnak kell lennie, máskülönben undefined behaviour.
Szóval mindkét példa definiáltlan működés, saccra a gyakorlatban annyi történik, hogy az első példában meghívódik a Base destruktora (így a Derived saját dolgai felszabadítatlanul maradnak), a második példában meg csak egy free() a pointerrel.
DRM is theft
-
dabadab
titán
-
dabadab
titán
válasz
Tomi_78
#4308
üzenetére
azt hittem, hogy te valami kívülről származó eljáráskönyvtárról írtál, amit állítólag használok a progimban, ez meg alapban benne van a C++-ban
Jól hitted, pont erről beszéltem és ez nincs benne alapból a C++-ban
Ez egy Windows-only könyvtár, amit gondolom a Codeblocks alapbeállításoknál behúz.A hiba, amit kidob, az azért van, mert a WM_PAINT ágban deklarálsz egy változót, amit csak ott inicializálsz, viszont mindenhol látható. A megoldás az, hogy a case WM_PAINT: utána részt kapcsos zárójelek közé rakod, mert az ott egy külön blokk.
DRM is theft
-
dabadab
titán
válasz
Tomi_78
#4299
üzenetére
Amit találtál, az egy külön megvehető library API-ja, amivel mindenféle fileformatumokat tudsz írni meg olvasni (röviden: tutira nem ez kell neked
)A standard C++-ban nincs semmi, amivel rajzolni tudnál a képernyőre, szóval biztosan már most is valami külső könyvtárat használsz erre, innen kezdve az a kérdés, hogy mit és hogy az tud-e ilyet.
DRM is theft
-
dabadab
titán
válasz
Tomi_78
#4278
üzenetére
A C++ tulajdonképpen két nyelv egyben: egyrészt ott van benne a C, amit mindenestül átvett, másrészt meg ott van benne a C++, ami az elején egy elég szerény OO-s kiegészítés volt, de már már tulajdonképpen az is szinte teljes nyelvvé nőtte ki magát, ennek eredményeképpen C++-ban egy csomó dolgot meg lehet csinálni C-ben meg C++-ban is
(és persze ha lehet, akkor inkább az utóbbit jó használni.)Ez egy ilyen: a konstansok kezelésére a #define a C-s megoldás, a const int meg a C++-os.
(#4279) Silεncε: a const int is compile time, különben nem menne vele a switch / case
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
Tomi_78
#4276
üzenetére
"UINT_PTR idozito1;"
Az a helyzet, hogy a SetTimer() signature-je teljesen el van cseszve, ennek nem UINT_PTR-nek, hanem simán uintnek kellene lennie. A SetTimer() második paraméternek egy azonosítószámot vár, adj neki azt.
A case meg azért nem működik, mert fordításkor tudnia kell a fordítónak, hogy annak a case-nek mi lesz a konkrét értéke - az meg változókkal nem megy.
Szóval kb ez kell neked (fejből, nem próbáltam ki):
const unsigned int TIMER_ID=0x12345;
idozito = SetTimer(hwnd, TIMER_ID, 100, NULL);
case WM_TIMER:
switch (wParam)
{
case TIMER_ID:
//csinál valamit
break;
}
break[ Szerkesztve ]
DRM is theft
-
dabadab
titán
-
dabadab
titán
válasz
Tomi_78
#4256
üzenetére
Amit meg kell érteni jelen esetben az, hogy egyetlen darab AlakokKepe objektumod van és beállítottad azt, hogy mind a négy helyen erre az egyetlen egyre mutató link legyen.
A kód, amit írtál, pontosan azt csinálja, mintha ebben a sorrendbe írtad volna:
.
AlakokKepe->LoadFromFile("alak\\alak_all.bmp");
AlakokKepe->LoadFromFile("alak\\alak_lep1.bmp");
AlakokKepe->LoadFromFile("alak\\alak_lep2.bmp");
kepei[0] = AlakokKepe;
kepei[2] = AlakokKepe;
kepei[1] = AlakokKepe;
kepei[3] = AlakokKepe;és ebből következően az, aminek igazából hatása van, csak annyi, hogy
.
AlakokKepe->LoadFromFile("alak\\alak_lep2.bmp");
kepei[0] = AlakokKepe;
kepei[2] = AlakokKepe;
kepei[1] = AlakokKepe;
kepei[3] = AlakokKepe;[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
leviske
#4229
üzenetére
Én egy külön objektumként hoznám létre, aminek mindhárom másik objektum megkapja a reference-ét, mivel amúgy semmi sem indokolja, hogy a három közül pont a bármelyik tulajdonolja (és akkor már lehet, hogy nem egy nyers vektor<akármiként>, hanem kapna egy wrappert classt maga köré, mert pl. a C++ std template containerek nem teljesen thread safe-ek)
[ Szerkesztve ]
DRM is theft
-
#4221
dabadab
titán
DrojDtroll
#4220
dabadab
titán
válasz
DrojDtroll
#4220
üzenetére
Nem tudom, hogy mivel vagy hogyan méred, de így ránézésre a fordítás idejét is beleméred.
Az sem teljesen világos, hogy igazán mit akarsz mérni, de elég biztos vagyok abban, hogy nem ez a megfelelő módszer hozzá.DRM is theft
-
dabadab
titán
Erre van a typeid:
if ( typeid(*b) == typeid(bolygo) ) {
// ....
}C++-ban egyébként szerintem nem jó ötlet C-s pointereket alkalmazni: a legtöbb esetben egyáltalán nem kell pointer (főleg mióta van move semantics), a maradék nagy részében referenciákat lehet használni, ami meg ezek után is megmarad, ott meg a C++-os smart pointereket.
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
dobragab
#4196
üzenetére
struct Point
{
int x;
int y;
Point()
{
x = 0;
y = 0;
}
Point(int x, int y)
{
this->x = x;
this->y = y;
}
};Sőt:
struct Point
{
int x;
int y;
Point()
{
x = 0;
y = 0;
}
Point(int x, int y):
x(x),
y(y)
{}
};Nyilván ízlés kérdése, de egyrészt nem szeretem az explicit this-ezést, mert az vagy felesleges vagy valami problémás dolgot takar, másrészt meg szerintem ez nagyon szép és intuitív (és - nem mellesleg - teljesen jól működik).
Amúgy meg van olyan kezdőknek szóló könyv, amit úgy meg bírtak írni, hogy a példák vállalhatóak?...
"az OOP-nek (objektumorientalt programozas) jo lenne, ha nem csak a szintaktikai elemeit tanitanak meg, hanem az elveket, ami menten epiteni es alkalmazni illik. Anelkul semmi ertelme az egesznek."
Így van, mert aztán az ember produkciós kódban olyat lát, hogy
pX->m_pY->m_Z = foo;(és nem egy ilyen sort, hanem több tízezer sornyi kód van ebben a stílusban írva és persze az osztályok összes tagja public (a Lock() / Unlock() is (amik mondjuk eleve azért vannak, mert a RAII sem ért el hozzájuk))
[ Szerkesztve ]
DRM is theft
-
#4168
dabadab
titán
Ron Swanson
#4165
dabadab
titán
válasz
Ron Swanson
#4165
üzenetére
"Kis mennyiségű adatnál szépen le is fut, de ha mondjuk N = több ezer, akkor nem fut le 0,2s alatt...
"Ó, hát erre egyszerű a megoldás, a lista tetejéről válassz valamit: [link]
Komolyabbra fordítva a szót, az a gondod, hogy kb. a vendégek számának négyzetével nő az elvégzendő számítások mennyisége. A megoldás az, ha találsz ennél kisebb ordójú algoritmust. Első blikkre ilyen lehet az, ha a vendégeket nem direktben hasonlítod össze egymással, hanem az időintervallummal machinálsz.
Például csinálsz egy listát, amiben olyan elemek vannak, amik állnak egy időpontból, a már ott lévő vendégek számából és az abban az időpillanatban érkezett vendégek számából és simán ezen a listán mész végig minden egyes vendégre.
Ez egyébként továbbra is algoritmikus kérdés, nem C++ - specifikus.
Hogy ontopic legyek, a C++ kódod valami egészen rettenetes és elavult, szóval fogadni mernék, hogy ezt a magyar (felső)oktatás keretében tanultad
, szerintem azt is érdemes jobb átnézni:1. TVendegek:
Minek az a T? Most komolyan? Mitől lesz bárkinek is jobb attól, hogy az összes osztály neve T-vel kezdődik, mint "type" (sőt, "típus"). Szóval legyen inkább Vendegek.
Miért Vendegek? Egyetlen vendég adatait tárolja, nem többét, szóval legyen inkább Vendeg.
És persze kódot szigorúan angolul írunk, szóval a végleges változat az a Guest.2. erkezes / tavozas
Ha már név: itt pont van értelme annak, hogy jelöljük, hogy ezek adattagok, szóval m_arrive, m_leave
Adattagokat csak kivételes esetben érdemes kirakni publikba, ez meg semmiképpen sem az, szóval legyenek csak private-ok (és a private tagokat érdemes a publicok mögé rakni, mert így jobban olvasható a kód: az elején ott van a mindenkit érdeklő rész, a class API-ja, az implementáció meg elfér hátul).3. TVendegek(const int E, const int T):
A constok itt elég feleslegesek (érték szerit átadott primitívekről van szó), a nevek meg lehetnek nyugodtan beszédesek, a C++-ban a scope-ok miatt az is tök jól működik, hogyC::C(int x) : x(x) {}
De mivel a tagok neve pont az előbb kapott egy m_ előtagot, amúgy se lenne névütközés legyen inkábbGuest(int arrive, int leave)....
és most mennem kell, majd folytatom, addig a többiek úgyis belekötnek abba, amit írtam
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
Teasüti
#4132
üzenetére
"Még sose alkalmaztam new-t. Mi szükségem volna rá, ha meg tudom oldani lokális változókkal?"
Ha meg tudod oldani, akkor semmi
Akkor van rá szükséged, ha nem tudod megoldani lokális változókkal (pl mert azt a p[] tömböt visszatérési értékként akarod használni a függvényedben).DRM is theft
-
dabadab
titán
válasz
Headless
#4121
üzenetére
"hogyan tudom kiolvasni, hogy hány paraméterrel rendelkezik?"
Sehogy. Alapvetően két dolgot tudsz csinálni:
1. valahogy átadod a pointertömb mellé azt is, hogy hány eleme van
2. (és ez a javasolt) hagyod a C-s tömbökét és C++-ban C++-ban programozol, ami jelen esetben azt jelenti, hogy az STL konténerei közül használsz valamit, pl. vectort.DRM is theft
-
-
dabadab
titán
válasz
choco01
#4057
üzenetére
"ovábbá ezt sem értem hogy miért nevezzük ezt a konstruktornak: kolcsonzo(char fnev[]); mert hát más is néz ki ehhez hasonlan.. pl.: int GetMagellan();"
Két fontos különbség van a kolcsonzo() meg a GetMagellan() között:
1. a konstruktort pontosan úgyanúgy hívják mint az osztályt
2. nincs visszatérési értéke (még void se)"mivan ha nem csinálok konstruktort hanem csak int kolcsonzo(char fnev[]);-et írok?"
Reklamálni fog a fordító, hogy konstruktornak nem adhatsz meg visszatérési értéket (az meg, hogy konstruktor, onnan jön, hogy pont úgy hívják, mint az osztályt)
DRM is theft
-
dabadab
titán
válasz
choco01
#4060
üzenetére
C++-ban a struct meg a class ugyanaz a dolog, két különböző névvel. Az egyetlen különbség a default láthatóság, vagyis ha nem írod ki, hogy public: meg private: (de úgyis kiírod), akkor classnál defaultból minden private, structnál meg minden public. Szóval gyakorlatilag az classt meg a structot lehetne egymás helyett használni (de ne csinálj ilyet, mert csak összezavarsz vele másokat (meg a jövőbeli magadat
)"meg hogyan tehetem a private tagokat elérhetővé más számára?"
A private pont azért private, hogy ne legyen elérhető más számára
Ha ezt akarod, akkor legyen public, de alapvetően adattagotkat nem jó ötlet publicra rakni, mert akkor mindenki úgy rondít bele, ahogy nem szégyell - inkább legyenek a más osztályok számára érdekes adatok tagfüggvényeken keresztül, mert így egyrészt tudod ellenőrizni az értékadásokat, hogy nem hülyeséget akar-e a másik beleírni, illetve át tudod faragni a belső adatstruktúrát anélkül, hogy emiatt át kellene írni a többi osztályt is.(A kivétel az, ha tisztán adatokat (függvényeket viszont nem) tartalmazó osztályt kell létrehozni, ott publicra érdemes rakni a tagokat és ezeknél érdemes a struct kulcsszót használni, hogy mindenki elsőre lássa, hogy miről van szó)
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
"Szeretnek elkezdeni C-vel es/vagy C++-szal foglalkozni."
Ez egy kicsit olyan, mintha azt mondanád, hogy szeretnél szakács lennie vagy szoftverarchitekt, mert mindkettő ugyanazzal a betűvel kezdődik
"Jelenleg JS-ben dolgozom, es neha JAVA-ban, de inkabb az alacsonyabb szintu vilag jon be jobban."
A modern C++ gyakorlatilag semennyivel sem alacsonyabb szintű, mint a Java, a C meg tulajdonképpen hordozható assembler - melyik érdekel igazán?
"Elsosorban a kep megjelenites erdekel, OpenGL/CL-tol kezdve a videokonvertalasig a jatekmotorokon at, igy ezt a teruletet szeretnem megcelozni, nyilvan fokozatosan."
Az OpenCL az meg egy harmadik és negyedik nyelv
"mennyire realis, hogy munkaidon kivul osszereakott referenciak alapjan talaljak melot C/C++ teruleten, ha a munkaban, tok mas nyelvekkel dolgoztam csak?"
A C++ azért (csakúgy, mint a Java) tipikusan nagyprojektes nyelv, azt meg házi környezetben nehéz reprodukálni, mert egy csomó feature-nek akkor lesz értelme, ha elég nagy a kód. Itt persze a javás tapasztalatod segíthet, mert ott is hasonló dologokkal lehet találkozni.
C-s meló meg tipikusan hardverközeli szokott lenni, ott elektronikai ismeretek meg hasonlók szoktak jól jönni.
Amúgy meg persze munkaerőhiány van, szóval ha akarsz, akkor találsz munkát azon a területen, amit kinéztél.
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
thiclyoon
#4012
üzenetére
Amit írsz, az színtiszta C kód, nem C++, szóval rossz topikban vagy
"Futtatáskor a végén (del után) a Head ide mutat: 00794D38 (miért nem nullptr? nem az kéne legyen free után?)"
Azért nem NULL, mert soha nem adsz neki NULL értéket, kellene bele egy új sor (a left meg a right nullázása amúgy is elég felesleges, de ezután duplán az lesz):
free(*Head);
*Head = NULL;(És pont ez a hiányzó sor az, ahol értelmet nyer a duplapointer, mert a meglévő kódhoz egy sima pont *Head is elég lenne.)
Így első blikkre fogalmam sincs, hogy a kiíró függvényed miért pukkan el, de az elég furcsa, hogy a jobb és a bal oldal kiírása között írod ki az adott csomópont értékeit.
[ Szerkesztve ]
DRM is theft
-
#3973
dabadab
titán
m.zmrzlina
#3971
dabadab
titán
válasz
m.zmrzlina
#3971
üzenetére
Igen, jó, sőt, ez még jobb:
int fvAkarmi(int elso, int masodik, int harmadik) {
return (elso+masodik)*harmadik;
}DRM is theft
-
-
dabadab
titán
"Már miért kéne sok ezer soros kód ahhoz, hogy objektumokat használj?! Pláne, tanulási fázisban..."
Tudsz mondani olyan, párszáz soros példát, ahol az objektumorientáltság bármi valós előnyt ad egy sima procedurális programhoz képest? Ha meg nem ad előnyt, akkor meg csak bohóckodás az egész.
Az OOP lényege az objektummodell kitalálása, nem az, hogy pont milyen szintaxissal használja az ember és háromszáz sornál nem lehet értelmes modellt csinálni.
[ Szerkesztve ]
DRM is theft
-
#3951
dabadab
titán
PandaMonium
#3950
dabadab
titán
válasz
PandaMonium
#3950
üzenetére
"Nem kell, hogy elsőre megértse miért jobb ha objektum-orientáltan írja meg, csak tudja hogyan kell."
Na jó, de mit tanulna? Hogy hogyan kell leírni azt, hogy "class {};"? Ami igazán lényeges belőle, azt úgyse értené, a nagyon alapfogalmakat meg akkor is összeszedi, ha csak simán a libraryk objektumait használja amúgy tök procedurális programokban.
DRM is theft
-
#3949
dabadab
titán
PandaMonium
#3948
dabadab
titán
válasz
PandaMonium
#3948
üzenetére
"Nagyon hasznos volna újraírnod a mostani kódot objektum-orientált stílusban, osztályokat használva, sokat tanulnák belőle"
Hajlamos vagyok úgy gondolni a programozási technikákra, mint amik megoldásokat adnak bizonyos problémákra. Az objektumorientáltsággal az a gond, hogy az olyan problémákra ad megoldást, amik ilyen kicsi projekteknél nincsenek is
Ahhoz tényleg kell a sokezersoros kód, ahol ha az ember sima C-ben írja a kódot, akkor is adódik, hogy struktúrákat adjon át a függvényeknek (amolyan kézi this-ként), hogy előjöjjön, hogy miért is jó ez az objektumorientáltság - enélkül a dolog csak bohóckodás és nem lesz világos, hogy mire is jó meg hogy hogyan lehet érdemesen kialakítani az objektummodellt.[ Szerkesztve ]
DRM is theft
-
#3945
dabadab
titán
m.zmrzlina
#3943
dabadab
titán
válasz
m.zmrzlina
#3943
üzenetére
"1, Miért használ cím szerinti paraméterátadást, ha csak kiiratja a tömböt de nem változtat egyik eleme értékén sem?"
Arra gondolsz, hogy
void printArray(const std::array<int, 5> &n)?Mert kb. egymilliószor gyorsabb átadni egy pointert, mint létrehozni egy új tömböt, abba átmásolni az adatokat, majd a függvényhívás végén felszabadítani az egészet
Egyébként const-ként adja át, az ott elég jól kifejezi, hogy nem fogja módosítani."2. Mire való a függvény paraméterlistájában a tömb előtt a "const"?"
Az azt mondja, hogy nem fogja módosítani, ami a gyakorlatban kb. azt jelenti, hogy csak az objektum const metódusait fogja meghívni és a tagváltozóinak sem fog értéket adni.
"Egy kicsit feljebb a Passing std::array to function résznél azt írja, hogy azért kell mert a fordító így nem készít másolatot a tömbről"
Ez mondjuk így hülyeségnek tűnik, hacsak valamit nagyon félre nem értek, amikor referenciát adsz át, akkor se így, se úgy nem készít belőle másolatot.
Azt esetleg el bírom képzelni, hogy valamelyik fordító a
void printArray(const std::array<int, 5> n)-ből csendben magátólvoid printArray(const std::array<int, 5> &n)-t csinál és erre gondolt a költő.[ Szerkesztve ]
DRM is theft
-
#3940
dabadab
titán
m.zmrzlina
#3939
dabadab
titán
válasz
m.zmrzlina
#3939
üzenetére
"Az a kérdésem, hogy mi a gyakorlat ebben az esetben?"
Az, hogy az i-t size_t-ként deklaráljuk.
"Milyen hibákat okozhat ha int-ként definiálom?"
Ez két esetben okoz hibákat:
1. amikor ugyanarra a bináris reprezentációra az int meg az unsigned int más értéket ad (vagyis ha a size érték eléri a 2^31-et, és a signed int negatív számot ad, az unsigned meg pozitívat)
2. illetve létezik az a probléma is, amikor a (64 bites) size_t nem fér bele a 32 bites intbe[ Szerkesztve ]
DRM is theft
-
#3937
dabadab
titán
m.zmrzlina
#3936
dabadab
titán
válasz
m.zmrzlina
#3936
üzenetére
"Ezek szerint az alábbi két deklaráció azonos?
int arr[10][10];"
array<int, 100> arr;Nem az. Fent egy kétdimenziós, 10x10-es tömböt definiálsz, lent meg egy egydimenzióst, 100 elemmel.
Ami neked kell, az ez:
array<array<int, 10>, 10> arr;És akkor ezek után változatlanul működik az, hogy
int z=arr[2][5];(Ha ragaszkodsz hozzá, írhatod úgy is, hogy
arr.at(2).at(5), de miért ragaszkodnál ehhez a formához?)[ Szerkesztve ]
DRM is theft
-
#3928
dabadab
titán
m.zmrzlina
#3927
dabadab
titán
válasz
m.zmrzlina
#3927
üzenetére
1. Túlbonyolítod.
2. Hibás az algoritmus. Képzeld el pl. a következő mátrixot, ebben jó esetben is csak a jó elemek negyedét találja meg (ha meg pl. középen kezd, akkor semennyit):0001000
0001000
0001000
1111111
0001000
0001000
0001000Simán végig kell menni az egészen, a szélek lekezelése meg tényleg nem egy nagy vaszisztdasz, pszeduokódban:
for ( x = X_MIN ; x <= X_MAX ; x++ )
for ( y = Y_MIN ; y <= Y_MAX ; y++ )
if ( isGood(x,y) && isGood(x+1,y) && isGood(x-1,y) && isGood(x,y+1) && isGood(x,y-1) )
store(x,y);
bool isGood(x,y)
if ( x < X_MIN || x > X_MAX || y < Y_MIN || y > Y_MAX )
return true;
return ( matrix[x][y] == 0 )[ Szerkesztve ]
DRM is theft
-
#3904
dabadab
titán
m.zmrzlina
#3902
dabadab
titán
válasz
m.zmrzlina
#3902
üzenetére
A legegyszerűbben a ternary operatorrel:
if( isAscending ? tomb[j]<tomb[i] : tomb[j]>tomb[i] )
{
...
}vagy ha rövidebb, de olvashatatlan kódot akarsz, akkor meg Bool logikával (mondjuk ez annyiban viselkedik másként, hogy ha az isAscending false, akkor az egyenlő értékeket is felcseréli, szóval valamivel lassabb, mint a fenti):
if( isAscending == (tomb[j]<tomb[i]) )
{
...
}[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
cadtamas
#3877
üzenetére
Ha Pythont ismered, ott minden paraméter referenciaként adódik át, sőt, ott gyakorlatilag az összes változó referencia, ami szerintem elég vicces működést tud produkálni meg rengeteg fejtörést azoknak, akik nem igazán értik, hogy mi a referencia.
Egyébként visszatérve azért, hogy miért jobb a referenciaként átadott paramétert módosítani, mint a visszatérési értéket használni: mert sokkal hatékonyabb. Ha tisztán érték szerint átadott, majd visszatérési értékkel átírt objektumnál háromszor kell a komplett objektumot (ami csatolt részeivel együtt akármekkora lehet, akár gigabyte-os méretű is!) háromszor kell mindenestül átmásolni (egyszer az érték szerinti átadásnál, másodszor akkor, amikor ezt átmásoljuk visszatérési értéknek, harmadszor meg akkor, amikor a visszatérési értéket beírjuk a régi helyére), referenciakénti átadáskor meg nullaszor. Egyébként ezért van az, hogy C++-ban (a primitív típusokat (int, double, boolean, ilyenek, amik beleférnek egy regiszterbe) leszámítva) minden paramétert referenciaként szokás átadni, legfeljebb kap egy constot, hogy tudjuk, hogy ahhoz nem fog hozzápiszkálni a függvény.
DRM is theft
-
dabadab
titán
válasz
cadtamas
#3873
üzenetére
(Jézusom, ez a példaprogram... az már önmagában elég ahhoz, hogy azt javasoljam, hogy inkább tanulj valami másból)
Szóval: a mutató egy olyan változó, ami egy másik változó vagy objektum helyére (címére) mutat a memóriában. Ez eddig megvan? Itt a két fő koncepciók az, hogy van olyan, hogy a memóriacím (a számítógépben a byte-ok meg vannak számozva nullától kezdve nagyonsokig és ezzel a számmal lehet rájuk hivatkozni) és hogy minden változó meg objektum valójában egy rakat byte-ként létezik a számítógépben.
A hivatkozás az gyakorlatilag egy mutató, csak a szintaxisban van különbség: ott feltételezik, hogy minket elsősorban a mutatott dolog érdékel, nem maga a memóriacím és így nem várja el a fordító hogy csillaggal meg nyillal bohóckodjunk, megspórolva némi gépelést meg olvashatóbbá téve a kódot.
Miért jó, hogy vannak ilyenek?
A fő felhasználási terület a függvények paramétereinél van. A paramétereket alapvetően átadhatjuk értékként vagy hivatkozásként: ha értékként adjuk át, akkor ha a függvényben bizergáljuk, az nincs kihatással az eredeti változóra - ha hivatkozásként, akkor meg igen.
A másik felhasználás az, amikor new-val hozunk létra objektumokat, hogy az élettartamuk független legyen annak a függvénynek az élettartamától, amelyik létrehozza őket (ugye a helyi változók csak addig élnek, amíg a függvény le nem fut - ha new-val hozol létre valamit, az meg addig, amíg rá nem küldesz egy delete-et).
DRM is theft
-
dabadab
titán
válasz
CPT.Pirk
#3854
üzenetére
Nyilván szükséged van a konkrét példányra ahhoz, hogy meg tudd hívni annak egy függvényét és értelmes adatot kapjál vissza - ez C-ben is pont ugyanígy van, ha egy x változód struct_a típussal, akkor annak nem tudod úgy lekérdezni a tagjait, hogy csinálsz egy struct_a típusú y változót és azt állsz neki olvasni
Mivel a te MainWindow objektumodot pointerét egy random widgetből megkapni nem igazán triviális (és ez jól van így), ezért inkább javasolnám a slotos-signalos megközelítést, az a korrekt (és ennek jelen esetben a C++-hoz semmi köze, ha C-ben lenne megírva a QT, akkor is ez lenne a helyes út).
Ja, az, hogy egy téglalapról szóló infót a QPoint típusú változóban adsz át, azért nem egy nagydíjas ötlet
, ott van a QRect, használd inkább azt, a geometry() úgyis azt adja vissza.DRM is theft
-
-
dabadab
titán
válasz
Hunmugli
#3817
üzenetére
"El tudok érni egy nemglobális változót egy függvényből anélkül, hogy benne hoznám létre, vagy hogy átadnám neki?"
Szerencsére nem.
( Illetve nyilván mindent meg lehet csinálni, pointerekkel pl. megoldható, de ahhoz azért elég jól kell tudni, hogy adott architektúrán az adott fordító mit csinál és pontosan hova kell célozni a stackben. Ja, meg persze feltétel, hogy az adott változó ténylegesen létezzen, mert a példádban a fordítók jó eséllyel kioptimalizálnák a szam változót )
DRM is theft
-
dabadab
titán
válasz
Hunmugli
#3776
üzenetére
"ez egyébként annyit tud, hogy asd értékét beállítja arra, ami a zárójelben van"
Nem, hanem az asd konstruktorát meghívja azzal az értékkel.
Nem nagyon akarlak lelombozni, de ha a konstruktorok sincsenek meg, akkor azért még nagyon sok tanulnivaló áll előtted
DRM is theft
-
dabadab
titán
válasz
pvt.peter
#3692
üzenetére
"Tehát adott egy void* típusú pointer ami reprezentálhat több egymással semmilyen kapcsolatban nem álló típust ami szintén egymással semmilyen kapcsolatban nem álló interfész megvalósítása."
Hát, ez így első nekifutásra az "elbaszott design" c. kategóriába való, ezt szépen nem lehet megoldani.
DRM is theft
-
dabadab
titán
Akkor még egyszer: a C++ oktatásban a C tömb olyasmi, aminek semmi keresnivalója a kezdőanyagban. Az olyan dolog, ami már valami advanced classben jöhet elő, mint különleges nyelvi feature, kb. úgy, mint mondjuk a placement new.
A kezdőknél, amikor tömbökről van szó, akkor STL konténerek.[ Szerkesztve ]
DRM is theft
-
-
dabadab
titán
A Stroustroup könyvnek meg az Effective C++-nak kb. semmi köze nincs egymáshoz.
Az egyik leírja, hogy mit tud a nyelv, a másik meg egy receptgyűjtemény, hogy mit hogyan érdemes használni és mire kell figyelni (és ez feltételezi azt, hogy az ember azért nagyjából már tudja, hogy mit tud a nyelv).
DRM is theft
-
dabadab
titán
válasz
bandi0000
#3460
üzenetére
Semmi szükség arra, hogy az egészet a memóriában tárold, elég csak az éppen aktuális dobást tárolni meg persze a mindenféle egyéb számlálókat, amiket elő kell állítani. Vagyis soronként beolvasod a file-t, de a beolvasott értéket nem tárolod el semmiféle tömbben meg sehol, csak növeled a számlálókat stb.
DRM is theft
-
dabadab
titán
válasz
bandi0000
#3457
üzenetére
"az összes adat memóriában történő egyidejű eltárolása nélkül oldja meg"
vs
"megpróbáltam beledobni egy tömbbe"
Akkor itt "a feladat elolvasása" rész sem sikerült
Egyébként mit kell kiszámolni a bejövő adatokból?
(#3452) jattila48: alapvetően azért kaptad a kritikákat, mert egyrészt C++ topikban egy tanulónak C példakódot adsz (lásd még: "minden nyelven lehet FORTRAN-ban programozni"), másrészt a konkrét kód több dologban is rossz példát mutatott.
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
jattila48
#3446
üzenetére
"A kódom nem rossz (legalábbis remélem)"
Hát ez
char trimmed_ipv6_addr[40];
meg ez
for(int i=0;i<strlen(ipv6_addr);++i){
kiad egy potenciális buffer overflowt.Egyébként kb. ugyanez az algoritmus úgy nézne ki C++-ban, hogy (most nincs nálam fordító, így csak IQ-ból):
string src="2001:0e00:41a0:006b:00de:03c0:0e00:60bc";
string dst;
char prev=0;
bool trimming=true;
for ( char c in src )
{
if ( trimming && c == '0' && prev == '0' )
{
// skip char
continue;
}
if ( c == ':' )
{
trimming = true;
}
else if ( c != '0' )
{
trimming = false
}
dst +=c;
prev=c;
}[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
bandi0000
#3447
üzenetére
Ez is C-ben van
Tényleg nem oktatnak C++-t?C++-ban így lehet stringet intté konvertálni:
std::string hex="0abc";
int i=std::stoi (hex,nullptr,16);(Nézd meg az stoi dokumentációját, a második paraméterének a segítségével végig lehet menni az egész IPv6 stringen)
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
bandi0000
#3397
üzenetére
"Én nem látom át a c++-t"
Tizenpár éve programozok benne, de én se merném azt állítani, hogy átlátom
De persze a nyelv nagyját viszonylag gyorsan össze lehet szedni, a mindenféle idióta elfajzott eseteket (itt a topikban is volt mostanában pár "na, mit ír ki ez a pár soros program?" kérdés) meg kb. soha De ahhoz, hogy nekiállj programozni meg megérte mások kódját, egyáltalán nem kell reménytelenül sokat tanulni.Ami a szintaxison túl még nagyon fontos (sőt, igazán ez a fontos), az az, hogy hogyan lehet jól bánni azzal a sok-sok eszközzel, amit a C++ az ember kezébe ad - ezen a téren amit szokás ajánlani, az Scott Meyerstől az Effective C++ - aminek közben lett egy C++11-ről szóló folytatása, az Effective Modern C++ - ez mondjuk nem kifejezetten kezdőknek szóló könyv, mert ahhoz, hogy megértsd a megoldásokat, nem árt ismerni a problémát, amit megoldanak
- márpedig itt sokszor olyan problémákról van szó, amik kis programoknál nem jönnek elő, csak nagy projekteknél.[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz
bandi0000
#3393
üzenetére
"Ahha, gyakorlatilag a for, if, scanf, scanf, printf, fprintf, while, do while, ezeket ismerem meg pár függvényt a string.h ból"
Jó, akkor ebből felejtsd el a scanf-t, printf-t meg a string.h-t (oké, a printf-fel gyakran össze lehet futni, más nyelveken is, mert a maga módján roppant kényelmes, de C++-ban az is tele van csapdákkal). Azok a C-hez tartoznak és a népszerű tévhittel ellentétben a C-nek meg a C++-nak, mint nyelvnek, nincs sok köze egymáshoz. C-ben meg ma már alig valaki programoz, az sok szempontból az assembler helyét vette át.
Helyette használd a C++-os megoldásokat, amit az előbb írtak: string és streamek, stream operátorokkal."ha meg nem vesznek fel fősulira gyakorlatilag semmit se érnék el vele ha tudnám mert papír nélkül és gyakorlat nélkül úgy se kellenék sehova"
Programozókra iszonyat kereset van, jóval nagyobb, mint a kínálat. Ha nincs diplomád, az gond lehet a bértárgyaláson, de ha tudsz programozni, akkor találsz állást.
[ Szerkesztve ]
DRM is theft
), mert a C++ dinamikusan fejlődő nyelv.
, mert az include-okból se derül ki, hogy mit használsz.
, ott van a QRect, használd inkább azt, a geometry() úgyis azt adja vissza.
Ú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!
- Telekom otthoni szolgáltatások (TV, internet, telefon)
- Nagy "hülyétkapokazapróktól" topik
- Nyíregyháza és környéke adok-veszek-beszélgetek
- Filmvilág
- Linux felhasználók OFF topikja
- World of Tanks - MMO
- Tőzsde és gazdaság
- Telekom mobilszolgáltatások
- Fűzzük össze a szavakat :)
- AMD Ryzen 9 / 7 / 5 7***(X) "Zen 4" (AM5)
- További aktív témák...
- Samsung Galaxy S24 Plus 12/256GB új 3 év garancia + Watch 5 Pro karcmentes
- 32GB 3600MHz hűtőbordás DDR4 kit (2x16GB)! Számlával, garanciával! ÁRON ALUL! BONTATLAN!
- GAINWARD GHOST RTX 4060 Ti eladó! RGB-s! Garanciával, számlával!
- Új Lenovo L0Q Gamer Tervező Laptop 15,6 -30% AMD Ryzen 7 8845HS 16/512 RTX 4060 8GB FHD 144Hz
- ASUS TUF GAMING B760M-PLUS (DDR5) - Keveset futott - Garanciális
Állásajánlatok
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest