- Karácsonyfaként világíthat a Thermaltake új CPU-hűtője
- Az USA vizsgálja a RISC-V kínai terjedésének kockázatát
- Kicsit extrémre sikerült a Hyte belépője a készre szerelt vízhűtések világába
- Egészen nagy teljesítményspektrumon fedné le a mobil piacot az AMD
- Kihívás a középkategóriában: teszten a Radeon RX 7600 XT
- Autós kamerák
- Sony MILC fényképezőgépcsalád
- Amlogic S905, S912 processzoros készülékek
- Mini-ITX
- Kicsit extrémre sikerült a Hyte belépője a készre szerelt vízhűtések világába
- Piacvezető tandem OLED panellel érkezik az iPad Pro
- A Fractal Design fával díszített toronyházának testvére született
- Gaming notebook topik
- A régi node-okra koncentrál a szankciók miatt Kína
- Egészen nagy teljesítményspektrumon fedné le a mobil piacot az AMD
Hirdetés
-
Súlyos adatvédelmi botrányba kerülhet a ChatGPT az EU-ban
it Egyre nagyobb probléma az AI hallucinálása – most az osztrák adatvédelmi hatóság veheti elő a ChatGPT miatt az OpenAI-t, alapvetően a GDPR megsértése miatt.
-
Az USA vizsgálja a RISC-V kínai terjedésének kockázatát
ph A Kereskedelmi Minisztérium egyelőre csak felméri a helyzetet, egyelőre nem látni, hogy tudnak-e bármit is tenni.
-
Spyra: akkus, nagynyomású, automata vízipuska
lo Type-C port, egy töltéssel 2200 lövés, több, mint 2 kg-os súly, automata víz felszívás... Start the epic! :)
Új hozzászólás Aktív témák
-
b.kov
senior tag
válasz m.zmrzlina #3899 üzenetére
Esetleg használhatnál funktorokat, ebben az esetben ideálisak lehetnek.
Ha nem ismernéd, akkor kb ennyit csinál:
A functor is pretty much just a class which defines the operator(). That lets you create objects which "look like" a function:Lényegében csinálsz 2 struct-ot (Less, Greater), amiben túlterheled a () operatort. Ekkor a csere függvényed sablonargumentuma lehetne pl. Compare, az utolsó függvényargumentum pedig ilyen Compare típusú.
Ha bővebben érdekel a téma: C++ jegyzet, 71. oldal (Funktorok).
[ Szerkesztve ]
-
m.zmrzlina
senior tag
-
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
-
PandaMonium
őstag
válasz m.zmrzlina #3905 üzenetére
Ettől általánosabb ha ahogy javasolták is, funktorokat használsz.
bool novekvo(float elso, float masodik)
{
return elso < masodik;
}
int cseres(float tomb[],int meret, const std::function<bool(float, float)>& feltetel)
{
float temp=0;
for (int i=0;i<meret-1;i++)
{
for (int j=i+1;j<meret;j++)
{
if(feltetel(tomb[j], tomb[i]))
{
temp=tomb[i];
tomb[i]=tomb[j];
tomb[j]=temp;
}
}
}
return 0;
}Itt a cseres függvény harmadik paramétere egy olyan funktor ami bool visszatérési értékű, és két float paramétert fogad. Ilyen pl. a novekvo függvény ami felette van definiálva. Tehát az a függvény hívás, hogy
cseres(tombom, tombom_merete, novekvo);
teljesen valid.
Pár megjegyzés még, mert írtad, hogy most tanulod a nyelvet:
- C stílusú (float[], int[], stb.) tömböket ne használj, akkor sem ha ezt látod tutorialokban vagy ezt oktatják egyetemen. Modern C++ban ha folytonosan szeretnénk tárolni valamit a memóriában (ahogy a tömb is semmi más mint egy folytonosan allokált memóriaterület) és fordítás időben (azaz a program írásakor, nem futtatáskor) tudjuk mekkora tömb kell nekünk akkor std::array-t használunk, egyébként, ha dinamikus méretű tömbre van szükségünk akkor std::vector -t.
- Jelenleg a kódod csak egy adott típusú tömbre (float) fog működni. Ha template függvényt csinálsz belőle kirakhatod ezt a típust template paraméterbe és akármilyen típusra fog működni - itt persze feltétel lesz, hogy a funktor is ennek a típusnak két példányát fogja fogadni.
- Nincsen kőbe vésve, de konvenció, hogy ha egy konténer két elemét hasonlítjuk össze akkor az az elem kerül az összehasonlítás bal oldalára ami előrébb van a konténerben. Ennek egy logikai összehasonlításkor nincs sok jelentősége, mert legfeljebb megfordítod az operátort (
(a > b) == (b < a)
), de pl. ha funktoroknak adod át a paramétereket akkor fontos, hogy a funktor milyen sorrendben várja az elemeket.[ Szerkesztve ]
What I cannot create, I do not understand
-
m.zmrzlina
senior tag
válasz PandaMonium #3906 üzenetére
A rendezést megvalósító fv-t átírtam a tanácsaid alapján (a ternary operator egyelőre maradt :-)), most így néz ki:
int sortSwap(array<float,10> &arr, bool isAscending)
{
float temp=0;
for (int i=0;i<arr.size()-1;i++)
{
for (int j=i+1;j<arr.size();j++)
{
if( isAscending ? arr.at(i)>arr.at(j) : arr.at(i)<arr.at(j))
{
temp=arr.at(i);
arr.at(i)=arr.at(j);
arr.at(j)=temp;
}
}
}
return 0;
}Azt olvasom itt meg itt, hogy a void tipus mint visszatérési érték akkor használatos, amikor a függvényünk csak lépéseket hajt végre, de nem állít elő konkrét értéket. Az a kérdés, hogy nem célszerűbb-e ennek a fv-nek void tipust adni mivel ez sem csinál mást mint egy adott memóriacímtől kezdődő tömb elemeinek sorrendjét átrendezi?
Ugyanez a kérdés a köv. két fv-re. Az egyik feltölt egy a main()-ban létrehozott tömböt:
int fillArr(array<float,10> &arr, int rndL, int rndH, int rndSt)
{
srand(time(0));
for(int i=0;i<arr.size();i++)
{
arr.at(i)=rand()%(rndH-rndL)+(rand()%100)/100.0 + rndSt;
}
return 0;
}Ez pedig kiírja a std outputra:
int printArr(array<float,10> &arr)
{
for(int i=0;i<arr.size();i++)
{
if(i%10==0)cout<<endl;
cout<<arr.at(i)<<"\t";
}
return 0;
} -
m.zmrzlina
senior tag
Illetve volna még egy kérdésem.
Ha a fillArr() fv három utolsó, és a sortSwap() utolsó argumentumát a felhasználótól szeretném bekérni - és csak valid értéket engedni - egy külön függvénnyel azt milyen adatszerkezetbe szokás írni?
[ Szerkesztve ]
-
Domonkos
Ármester
válasz m.zmrzlina #3907 üzenetére
Ezek a fuggvenyek lehetnek
void
ok. Abban az esetben lehet ertelme hogy plint
visszateresi erteke van, ha meg szeretned mondani, hogy hany elemet sikerult kiirni, vagy egyeb hibajelzest szeretnel visszaadni... bar c++-ban mar vannak erre is "fejlettebb" eszkozok, mint a try-catch-es kivetelkezeles stb.[ Szerkesztve ]
Gender of electrical connectors is defined by the pins.
-
Domonkos
Ármester
válasz m.zmrzlina #3908 üzenetére
En irnek ra egy kulon osztalyt ami tartalmazza a szukseges inputokat es elvegzi a megfelelo validaciokat is.
Minden egyes bekert dolognak lenne egy megfelelo adattagja az osztalyban, egy hozza tartozo fuggveny ami bekeri, ellenorzi es beallitja azt (setter), valamint egy olyan amivel ki lehet azokat olvasni (getter) vagy hibat irni, ha nem sikerult az olvasasig ertelmesen beallitani.
Es akkor azt is meg lehtne tenni, hogy asortSwap()
nem 3 kulonbozo parametert var, hanem egy ebbol az osztalybol szarmazo peldanyt.
Vegtelen lehetosegek...Gender of electrical connectors is defined by the pins.
-
Domonkos
Ármester
válasz m.zmrzlina #3911 üzenetére
Azt azert irtam, mert mar vartam hogy a szakik felsoroljak, hogy az epp aktualis szabvanynak es a most hypeolt paradigmanak milyen megoldasok felelnenek meg.
Eddig akarhany C++ projektben vettem reszt valahogy sosem volt egybehangzo dontesunk, hogy mely featureoket szeretnenk hasznalni. Tul sok van es altalaban nincs "legjobb".Gender of electrical connectors is defined by the pins.
-
leviske
veterán
Sziasztok! Ismertek olyan oldalt, ahol compiler-eket hasonlítanak össze? Vagy, ha kíváncsi vagyok, hogy pl két msvc verzió által végzett fordítás közt van-e érdemi eltérés az egyik javára, akkor azt nekem kell tesztelnem?
Leginkább az érdekelne, hogy a 2017 mennyivel fordít hatékonyabban a 2012-nél a Skylake és Zen architektúrákra.
-
m.zmrzlina
senior tag
void getUserInput(vector<int> &ui)
{
int entry=0;
bool isEntryValid=true;
system("cls");
do
{
if(isEntryValid==false)
{
cout<<"Ervenytelen adat!"<<endl;
}
cout<<"Lista meret: <1-100>"<<endl;
cin>>entry;
if(entry < 1 || entry > 100 )
{
isEntryValid=false;
system("cls");
}
else
{
isEntryValid=true;
}
}
while (isEntryValid==false);
ui.push_back(entry);
}A fenti kódrészlet szépen működik számok bevitele esetén de betű leütésére végtelen ciklusba kerül. Mi erre a magyarázat?
-
EQMontoya
veterán
válasz m.zmrzlina #3915 üzenetére
Inicializálod ezt:
bool isEntryValid=true;
cin>>entry;
if(entry < 1 || entry > 100 )
{
isEntryValid=false;
system("cls");
}Nem olvasol be semmit az entrybe, mert a betű nem szám. Az inputon pedig ott marad a betű, tehát nem üres, sikerül a következő beolvasás is.
while (isEntryValid==false);
Ez meg továbbra sem állítja le.
A megoldás: stringbe olvasunk be, azt konveráljuk számmá. Ha nem sikerül, lehet hibát dobni.
Same rules apply!
-
m.zmrzlina
senior tag
válasz EQMontoya #3916 üzenetére
A megoldás: stringbe olvasunk be, azt konveráljuk számmá. Ha nem sikerül, lehet hibát dobni.
Ha jól sejtem ez az a megoldás amit javasolsz (16-30 sor)
-
daninet
veterán
Sziasztok!
kezdő téma, klasszik iskolapéldát akarom megoldani, dobókockás játék. Kb minden kész már, csak az elején statikus még,
először beadom a játékosok számát, majd be kellene irni a neveket, de c++ nem támogat int értéket array-nek, csak konstansot. Próbáltam keresni, de string-re nem láttam semmit, nyilván nem tudom mit keressek annyi kellene legyen az array mérete ahány a játékosok számaMiért vegyem meg, ha 3x annyiért, 3x annyi idő alatt megépíthetem? ´¯`·.¸¸.·´¯`·.¸><(((º>
-
b.kov
senior tag
válasz daninet #3923 üzenetére
Beolvasod az N-et, aztán indítasz egy ciklust, ami N-szer fog lefutni. A ciklusmagban pedig szépen belepakolod a vectorba a beolvasott értéket, hiszen az egy tároló, amivel a tömböt helyettesíted.
Nagyon egyszerűen:
#include <iostream>
#include <vector>
int main(int argc, char** argv)
{
int N; // jatekosok szama
std::cin >> N;
std::vector<std::string> names;
for(int i = 0; i < N; ++i)
{
// beolvasas
std::string tmpName;
std::cin >> tmpName;
// vektorba iras
names.push_back(tmpName);
}
return 0;
} -
b.kov
senior tag
válasz daninet #3925 üzenetére
Nem-nem, az std konténereknek pont ez a feladatuk, hogy helyettesítsék a régi tömböket.
Nagyobb a választék, feladatonként eltérően tudsz dönteni közülük, hogy melyik számodra éppen a legoptimálisabb.
Sok esetben nem kell a memória allokálásával, deallokálásával foglalkoznod.
Sok jó setter/getter műveleteik vannak, és működnek rájuk az std algoritmusok.Szóval ha van egy kis időd, nagyon érdemes rájuk szánni.
Érdemes esetleg itt kutakodni. -
m.zmrzlina
senior tag
Algoritmizálásban kellene kis segítség.
Adott egy 10x10-es mátrix, vélerlenszerűen feltöltve 0 és 1 értékekkel. Ki szeretném válogatni azokat az elemeket amelyeknek csak 0 értékű szomszédjuk van.
1, Az első elemet találomra választom.
2 Indítok egy ciklust és összeadom az elem összes szomszédjának értékét, ha ez 0 akkor az indexét (sor oszlop) eltárolom egy "eredmény" tömbbe. Illetve eltárolom a 0 értékű szomszédok indexét is egy "eztismegkellnézni" tömbbe.
3, A 0 értékű szomszédokra ("eztismegkellnézni" tömb elemeire) is lefuttatom az előző ciklust. Ha összeg==0 akkor az is megy az "eredmény" tömbbe, Teszem ezt mindaddig amíg a 0 szomszédnak van 0 szomszédja és annak 0 szomszédja....stb.A ciklus úgy néz ki hogy veszi az első elem bal felső szomszédját és a sor és oszlopindexek megfelelő iterációjával "körbejárja" az elemet. Ez mindaddig oké is amíg a vizsgálandó elem nem a mátrix szélén található (0.sor vagy 0.oszlop vagy 10.sor vagy 10. oszlop a sarki elemekről nem is beszélve) ezeket az elemeket ugyanis nem lehet a fent említett módszerrel "körbejárni" Oké, hogy ezekre az elemekre is meg lehet írni a megfelelő ciklust csak ez eredményezne egy végeláthatatlan programot egy ilyen kis feladatra. (lehet, hogy nem is olyan kicsi ez a feladat)
Az lenne a kérdés, hogy ki hogyan oldaná meg ezt a feladatot?
-
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
-
m.zmrzlina
senior tag
válasz dabadab #3928 üzenetére
Visszaolvasva a kérdésemet nem voltam teljesen pontos:
1. Peremfeltétel, hogy véletlenszerűen kiválasztott (esetleg userinput-ból származik) a kezdő elem .
2. Csak a kezdő elem környezetében lévő elemek érdekesek nem kell az egész mátrixot végigellenőrizni.
3. A sarkukkal érintkező elemek is szomszédosnak számítanak (egy elemnek 8 szomszédja van).Az alábbi példánál a (0,7) (0,8) (0,9) (1,7) (1,8) (1,9) (2,8) (2,9) (3,8) (3,9) számítanak találatnak ha a kezdő elem a (0,8) (0,9) (1,8) (1,9) elemek bármelyike. (sor, oszlop)
A (2,0) (3,0) (4,0) azért nem érvényes találat ((0,8) (0,9) (1,8) (1,9) kezdőcella esetén) mert közöttük vannak olyan elemek amelyeknek nem csak 0 szomszédjuk van. A "közöttük" azt jelenti, hogy a jöbb felső sarok és (2,0) (3,0) (4,0) elemek között.
1 0 1 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 1 0 1 1 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 1 0 0 0 1 0
1 0 1 0 0 0 1 0 1 0
0 0 0 1 0 0 0 0 1 0
1 1 1 0 0 1 0 1 1 0
0 0 0 0 0 0 0 0 0 0[ Szerkesztve ]
-
mgoogyi
senior tag
válasz m.zmrzlina #3929 üzenetére
3. az if, amiben van 4 isGood, kiegészíted még 4-gyel ((-1,-1) (-1,+1) (+1,+1) (+1,-1))
Akkor a feladat gyakorlatilag átültethető arra, hogy csinálsz egy ugyanekkora 0-kal feltöltött mátrixot és abban a kezdőponttól indulva minden irányban elkezdessz 1-eseket rakni, amíg tudsz olyan mezőkön haladni, hogy csak 0-ás szomszédok vannak. Kb mintha vizet engednél a mátrixba és csak a keresett elemek adnák ki a tó medrét.
Pl:
void Flood (int x, int y)
{
if (floodMatrix[x][y] == 0 && összes szomszéd + (x,y) isGood )
{
floodMatrix[x][y] = 1;
Flood() összes szomszédra
}
}Mire végez, addigra a floodMatrixban ott lesznek a megoldásaid.
[ Szerkesztve ]
-
daninet
veterán
Azt mondjátok már meg ebben a loop-ban miért nem áll meg gombnyomáshoz az első körnél, csak a másodiknál.
for (int i = 0; i < playerz; i++)
{
for (int x = 0; x < 2; x++)
{
cout << names.at(i) << " " << x + 1 << ". dobasa!";
do
{
cout << "\nGuritashoz nyomj Entert...";
} while (cin.get() != '\n');
srand(time(0));
cout << "\nEredmeny: " << gurit();
cout << "\n\n";
}
}Miért vegyem meg, ha 3x annyiért, 3x annyi idő alatt megépíthetem? ´¯`·.¸¸.·´¯`·.¸><(((º>
-
PandaMonium
őstag
válasz daninet #3931 üzenetére
Cpp.sh-n kipróbáltam, működik és megáll az elsőnél. Persze az Linux-on fordít GCC-vel.
I/O streamek kezelése mindig macerás, főleg az input kezelés. Sokszor a terminál/shell bufferelni az inputot Linux alatt is, Windows-on pedig külön egy macera az egész.A do-while ciklusodat próbáld meg kicserélni erre a 3 sorra:
cout << "\nGuritashoz nyomj Entert...";
cin.clear();
cin.ignore(10000,'\n');És a \n helyett érdemesebb
std::endl
-t használni cout-ra íráskor az új sorhoz, ez platform független. Arra viszont figyelj, hogy ilyenkor flusholja a streamet, szóval performance hit lehet ha nem jól használod.What I cannot create, I do not understand
-
daninet
veterán
válasz PandaMonium #3934 üzenetére
Fogalmam sincs mi tortenik, szoval a kodban az elso ilyen megallast nem ertelmezi legyen az barhol. Szoval beraktam az elejere egyet, atugorja, utana jo. Ha nem megy esszel oldd meg erovel
[ Szerkesztve ]
Miért vegyem meg, ha 3x annyiért, 3x annyi idő alatt megépíthetem? ´¯`·.¸¸.·´¯`·.¸><(((º>
-
m.zmrzlina
senior tag
Van egy kisebb programom amiben C tipusú kétdimenziós tömböket használok (pl: int a[10][10]={....}) amit át szeretnék írni std::array tipusúra Itt tanácsoltátok.
Az a kérdésem, hogy hogyan működik a második esetben a kétdimenziós tömb? Azt olvasom, hogy a C-ben a tömb egy pointer ami a tömb első elemére mutat, az elemek pedig sorban ez után találhatóak a memóriában.
Ezek szerint az alábbi két deklaráció azonos?
int arr[10][10];
array<int, 100> arr;Illetve a C tipusú tömb egy elemére így hivatkozom:
z=arr[2][5];
Ez ekvivalens a következővel?
z=arr.at(25);
[ Szerkesztve ]
-
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
-
m.zmrzlina
senior tag
Még egy kérdés:
Ha számlálós ciklusba feltételként konténer méretét adom meg pl:
for(int i=0;i<arr.size();i++){
//stb...stb...stb...
}akkor a fordító jelzi hogy különböző tipusú értékeket hasonlítok össze, mert az arr.size() az unsigned int tipusú az i az meg int.
Az a kérdésem, hogy mi a gyakorlat ebben az esetben? Én unsigned int-ként definiáltam az i-t. Milyen hibákat okozhat ha int-ként definiálom?
-
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
-
b.kov
senior tag
válasz m.zmrzlina #3939 üzenetére
Mondjuk szélsőséges esetben túlcsordul az int változó, és a legnagyobb felvett értéke után megnöveled -> felveszi a lehető legkisebb értéket (valami mínusz szám, attól függ, hány byte-on van ábrázolva). Ez ugye akkor probléma, ha pl. az arr.size() nagyobb, mint az int változó maximálisan felvehető értéke.
És konkrétan így nézne ki (egy általános esetben):
i = 0, i = 1, ... , i = 32767 , i = –32767 , ... , i = 32767 -> végtelen ciklus, ha pl az arr.size() nagyobb, mint 32767 . De mégegyszer említem, ez elég szélsőséges eset.Próbálj minél pontosabb típusokat használni, szebb, később olvashatóbb kódot fogsz így írni, illetve elkerülöd a warningokat (amiket pont az ilyen esetek miatt szeretünk).
Szerk.: igen, az előttem szólóhoz hozzákapcsolódva, size_t-vel jobban jársz.
[ Szerkesztve ]
-
m.zmrzlina
senior tag
válasz dabadab #3937 üzenetére
Belefutottam egy ilyen leírásba amiben nem értek két dolgot.
(oldal legalja a Passing a multidimensional std::array to a function résznél)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?
2. Mire való a függvény paraméterlistájában a tömb előtt a "const"? 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 (és ettől jobb lesz a világ ) Erről tud valaki bővebbet mondani? Ha túl hosszú vagy bonyolult akkor egy link is megteszi.
[ Szerkesztve ]
-
cattus
őstag
válasz m.zmrzlina #3943 üzenetére
Ha nagyon nagy méretű objektumokat érték szerint adsz át, akkor a lemásolásuk jelentős késleltetést vonhat maga után (értsd: lassú lesz a program). Emiatt használnak referencia szerinti átadást. Ilyenkor ugye alapesetben a függvény módosíthatná a kapott objektumot, emiatt használnak const-ot, hogy ne legyen rá lehetősége.
Do the thing!
-
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
-
daninet
veterán
nos kész a dobókocka játék, kb 2 hetet tanultam egy mobilapplikációból a c++ -t ezt hoztam ki. Azóta utánanéztem pár dolognak, de ezt újra már nem kezdem.
-eleinte kicsit inkonzisztensen használtam a printf()-et, annak valamiért jobban tetszik a syntax-ja, de abbahagytam
-goto-val ugrálok előre hátra a kódban (vissza a menühöz pl) azóta olvastam ez nemjó, értem miért bár nem teljesen tudom mi válthatja ki
-nem gyűjtöttem semmi szemetet
-nem használtam semmiféle class-t és objectet, azt még nem nagyon értem, illetve kellene egy komplexebb feladat ahol értelmet nyer
-ide illeszd be a kommentjeid[ Szerkesztve ]
Miért vegyem meg, ha 3x annyiért, 3x annyi idő alatt megépíthetem? ´¯`·.¸¸.·´¯`·.¸><(((º>
-
PandaMonium
őstag
válasz daninet #3947 üzenetére
Állásinterjúra még ne menj vele, de két hét után nem rossz.
Pár apró meglátás, javaslat:
- Printf-et felejtsd el, használd a streameket
- Rand, srand függvényeket szintén felejtsd el, van C++11 óta <random> és szuper(komplikált) randomszám generátor osztály
- Goto-kat függvényhívásokra nagyon egyszerűen ki tudod cserélni
- Olyat nem csinálunk, hogyif (minden_rendben) {} else { hibakezeles; }
, hanem negáljuk a feltételt:if (!minden_rendben) { hibakezeles; }
- Pastebin helyett jobb a Github Gist-je, főleg ha több fájlban van a kódod
- Nagyon hasznos volna újraírnod a mostani kódot objektum-orientált stílusban, osztályokat használva, sokat tanulnál belőleHa lesz újra gépem (valszeg péntek) és szeretnéd megírom neked szépen, modern C++ban, hogy lásd a különbséget és tudj belőle tanulni.
[ Szerkesztve ]
What I cannot create, I do not understand
-
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
-
PandaMonium
őstag
válasz dabadab #3949 üzenetére
Nem kell, hogy elsőre megértse miért jobb ha objektum-orientáltan írja meg, csak tudja hogyan kell. Aztán majd ha kicsivel nagyobb fába vágja legközelebb a fejszéjét és belebukik a procedurális paradigmába, lehet magától előveszi az OOP-t.
What I cannot create, I do not understand
Ú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!