- Luck Dragon: Asszociációs játék. :)
- sziku69: Fűzzük össze a szavakat :)
- LordOLOG Szféra
- sh4d0w: Netflix? Ugyan, VW előfizetés!
- GoodSpeed: Bye PET Palack, hello SodaStream
- sziku69: Szólánc.
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- Magga: PLEX: multimédia az egész lakásban
- LordAthis: Ismét egy "Idióta" A.I. Projekt, hogy meglovagolja az aktuális trendeket...
- bambano: Bambanő háza tája
Új hozzászólás Aktív témák
-
#4000
PandaMonium
őstag
m.zmrzlina
#3999
PandaMonium
őstag
válasz
m.zmrzlina
#3999
üzenetére
std::stoi-val próbáld meg. Minden nem C-s függvény alapvetően az std névtérben van deklarálva. -
#3999
m.zmrzlina
senior tag
m.zmrzlina
senior tag
Egyik kódomban szeretném használni a stoi() fv-t de a fordító "error 'stoi' was not declared in this scope" hibaüzenetet dob.
A környezet:
Codeblocks v16.0.1
GNU GCC Compiler v. 4.9.2
A CodeBlocks-ban a Compiler settingsnél a "Have a g++ follow the C++ ISO C++ language standard [-std=c++11]" flag ki van pipálva.
A <string> fejlécállomány inkludálva.Mi lehet az oka a hibának?
-
#3998
PandaMonium
őstag
mgoogyi
#3992
PandaMonium
őstag
válasz
mgoogyi
#3992
üzenetére
Biztos, hogy nem ez a probléma, különben a for-ciklus el sem indulna (i < v.size() feltétel).Félreértettem amit mondtál, jogos a felvetés.
(#3997) gepa7: Örülök, hogy megoldódott, de két apróság. Ha csak a vector mögött levő buffer méretét akarod állítani, anélkül, hogy létrejönnének benne az objektumok vagy változna a v.size(), használd a v.reserve() függvényt. A másik, hogy felejtsd el az egy betűs változókat, mert ettől minden programozó falnak megy, és ha másnap ránézel a saját kódodra már te sem fogod tudni mi micsoda. Nekem is többször át kellett olvasnom a kódodat, hogy megértsem, pedig nem egy bonyolult algoritmus.
Szerk: Az is sokat segít ha konzisztensen formázod a kódodat, behúzások rendben vannak, stb.
-
-
mgoogyi
senior tag
válasz
#74220800
#3995
üzenetére
Visual Studio Express 2013, de debuggolni más ide-ben is lehet.
Ez nem elég a végére?
if (v[i].size() > 0)cout << v[i][0] << " "; else cout << "- ";Vagy azokra az indexekre beírsz egy -1-et, ahol nem gyűlt ki a k=4 szumma?
A későbbiekben pedig a -1 jelezné, hogy attól az indextől kezdve nem lehet kihozni a szumma>=4-et.Nem értem ezt az előre definiálós problémádat. A v vektor sorindexek jelentése, hogy hanyadik számtól kezdve adod össze a számokat. Ezen belül a 0. index jelzi, hogy hány darab számot kell összeadj, utána meg be vannak írkálva, hogy ezek mely indexű számok az "a" vektorban. Ami mondjuk bármikor számítható a sorindexből és a darabszámból, én valszeg nem tárolnám el.
Mi a kimenet, ami szeretnél?
-
#74220800
törölt tag
válasz
mgoogyi
#3992
üzenetére
Hi,
Nem. Arrol van szo, hogy az "a" vektor egyes elemeiből indulva kummulalom az ertekeket. Kerdes mikor eri el az osszeg leghamarabb a 4-et. De a feladat sztem elvben jol van megoldva. Ha lefuttatod a progit ki is tudtam iratni az eredmenyvektort. De vhogy az elso oszlop kiiratasa nem megy, vagyis megy de utana leall. Vmi memoria gond lehet.
-
#74220800
törölt tag
Hi,
Egy 2d-s vektor elso oszlopat szeretnem kiiratni. A progi megcsinalja, de utána az irja, hogy az exe has stopped working. Mi lehet a baj? A problemas for ciklust kikommenteltem a progi vegen. Pls help.
(egyebkent arrol van szo egy egy 2ds vektorban gyujtottem ki, hogy egy masik vekotorban balrol jobbra folytonosan milyen legalabb 4 erteku utak vannak. Sor elso eleme az utak hossza, utana meg a bejart ut. A legrovidebb utat szeretnem, ezert kene az elso oszloppal operalnom).
thx
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> a ={1, 1, 1, 1, 1, 2, 3, 0, 1 };
vector<vector<int>> v;
v.resize(a.size());
int k = 4;
int b = 0;
for(int i = 0; i<a.size(); i++){
int s =a[i];
int j = i + 1;
while(j<a.size() && s<k){
s = s + a[j];
j++;
}
if(s>=k){
v[b].push_back(j-i-1);
for(int l = i; l<=j-1; l++){
v[b].push_back(l+1);
}
b++;
}
}
for(int i = 0; i<v.size(); i++){
for(int j = 0; j<v[i].size(); j++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
/*for(int i = 0; i<v.size(); i++){
cout<<v[i][0]<<" ";
}*/
} -
#3990
b.kov
senior tag
PandaMonium
#3989
b.kov
senior tag
válasz
PandaMonium
#3989
üzenetére
Nálunk detto 50 sor, persze néha kivitelezhetetlen.
-
#3989
PandaMonium
őstag
dobragab
#3986
PandaMonium
őstag
-
#3987
m.zmrzlina
senior tag
dobragab
#3986
m.zmrzlina
senior tag
válasz
dobragab
#3986
üzenetére
Igen, pont erről van szó. Van egy switch-case-zel működő menürendszer ami gyárt egy 80x25-ös keretet illetve elhelyezi benne a kiírnivalókat.
Aztán a user válaszától függően vagy csak megjelenít pár sort vagy elindítja a játékot ami értelemszerűen nem pár sor. Ezt a blokkot próbáltam volna egyben kezelni de úgy látszik ennek nem ez a módja.
-
b.kov
senior tag
-
#3983
mgoogyi
senior tag
m.zmrzlina
#3980
mgoogyi
senior tag
válasz
m.zmrzlina
#3980
üzenetére
Ha csak egyszer hívnád meg azt a függvényt, akkor semmi értelme.
A többször használt kódot szokásos függvénybe kirakni. -
#3981
Domonkos
addikt
m.zmrzlina
#3980
Domonkos
addikt
válasz
m.zmrzlina
#3980
üzenetére
C++-ban nincs ra mod hogy egy fuggveny belsejeben egy masikat deklaralj.
A legkozelebbi amit tehetsz, hogy irsz ra egy lambdat. Azt hiszem hogy C++11-tol tamogatott. -
#3980
m.zmrzlina
senior tag
m.zmrzlina
senior tag
Az rendben van, hogy egy függvény deklarációját a meghívása előtt kel elhelyezni a programban de mennyire elfogadott az, hogy ha egy függvényt bizonyosan csak egy másik függvényben fogunk meghívni (és azon kívül biztosan nem) akkor magát a hívott fv-t a hívó belsejében deklarálom és ott is fejtem ki (definiálom)?
Számomra kicsit átláthatóbbá tenné a programot de nem tudom, hogy van-e erre vonatkozó konvenció.
-
#3979
m.zmrzlina
senior tag
choco01
#3977
m.zmrzlina
senior tag
-
#3975
Domonkos
addikt
m.zmrzlina
#3974
Domonkos
addikt
válasz
m.zmrzlina
#3974
üzenetére
A keretet es formazast sajat magad megszivatasa miatt rakod bele?
Szerintem amellett hogy helypazarlo meg zavarossa is teszi a kiirt infokat. En lemondanek rola.
Ha megis ilyen nagyon fancy elrendezest szeretnel, akkor ennel sokkal jobb nem lesz. A parameterlistaval annyit tudsz csinalni, hogy tombben vagy valami c++-os kontenerben adod a parametereket at.
De vannak hasonlo celra mar jol bevalt konyvtarak is, mint az ncurses. Egyszeru dolgok rajzolasanal mondjuk nem fogsz sokat nyerni vele... -
#3974
m.zmrzlina
senior tag
m.zmrzlina
senior tag
Dolgozom egy programon amihez szeretnék menüt készíteni Több irányból nekiszaladtam már, értem is el némi eredményt. Az első változatban textfájlban letároltam a képernyőképeket és azokat írtam ki képernyőre a user válaszától függően.
A második változatban C tipusú tömb változóban tárolom a kiírnivalót és azt írom ki egy switch szerkezetbe rakosgatott fv segítségével. Itt lehet megnézni.
Ennek az a hibája, hogy egyrészt már öt menüpont esetén is szinte kezelhetetlen a kiíró fv paraméterlistája plusz minden menüpont sztringjét és a sztring méretét külön tárolja és adja át a fv-nek ami több almenü esetén megint rettentő terjedelmes kódot eredményezne.
Biztos vagyok benne, hogy van egyszerűbb út, csak nem tudom merre. Jól jönne pár tipp.
-
#3973
dabadab
titán
m.zmrzlina
#3971
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;
} -
#3972
b.kov
senior tag
m.zmrzlina
#3971
b.kov
senior tag
válasz
m.zmrzlina
#3971
üzenetére
Hát igen, azt mondják, hogy a programozás egyik legkihívóbb feladata a konzisztens nevek használata. Tehát egyébként sem szokás a, b, c neveket adni változónak, mert ha egy kicsit is összetettebb a program, akkor rengeteg idő elmehet azzal, hogy megértse más, te mire is gondoltál éppen akkor.
Egyébként igen, amit írtál az "teljesen jó", tehát lefordul, és működni is fog. Én személy szerint azért kerülöm, és kiírom a paraméterneveket is. Ez főleg akkor is hasznos, ha majd pl interfészeket írsz osztályokhoz, aztán szintén jön megint valaki, akinek sokkal egyszerűbb lesz megérteni egy-egy függvény működését, ha látja a paramétereit is annak.
-
#3971
m.zmrzlina
senior tag
b.kov
#3969
m.zmrzlina
senior tag
Ezek után teljesen felesleges még 3 változót létrehozni, nem leszel előrébb semmivel.
Ezt értem és el is fogadom csak számomra talán valamivel átláthatóbb lenne a program ha végig ugyanaz a név jelöli ugyanazt a változót nem pl úgy hogy ami a mainben "egyik" az a fvAkármiben "a" de ha a fvAkármi meghívja a fvMásvalamit akkor ott már ugyanaz a változó lehet akár "c" is. Ezért kérdeztem hogy mi itt a best pactice.
a függvény deklarációjánál nem fontos neveket megadni, de definíciónál annál inkább,
Úgy kell ezt érteni, hogy az előbbi példánál maradva a következő megoldás teljesen jó?
int fvAkármi(int,int,int);
int main(){
}
int fvAkarmi(int a,int b,int c){
return (a+b)*c;
} -
#3969
b.kov
senior tag
m.zmrzlina
#3968
b.kov
senior tag
válasz
m.zmrzlina
#3968
üzenetére
Szia!
Felesleges ilyenkor külön változókat létrehozni csak azért, hogy egyenlővé tedd a paraméterekkel, hiszen a paraméterek is ekkor lokális változók lesznek a függvényre nézve, melyek a függvény hívásakor lesznek megkonstruálva az adott paraméterek alapján.Tehát a fenti példádban az a, b és c akkor fog létrejönni, mikor meghívod a main-ben a fvAkarmi-t, és ekkor a megadott értékekkel fognak inicializálódni (2, 5, 10). Ezek után teljesen felesleges még 3 változót létrehozni, nem leszel előrébb semmivel.
A másik kérdésre pedig: a függvény deklarációjánál nem fontos neveket megadni, de definíciónál annál inkább, hogy tudj hivatkozni a paraméterekre. Lefordulni lefordul ha nem teszed meg, de én nem láttam még ilyet a gyakorlatban.
-
#3968
m.zmrzlina
senior tag
m.zmrzlina
senior tag
Az érdekelne, hogy mi a programozói gyakorlat a függvény prototipusok esetében?
Van pl egy ilyen fv-em:
int fvAkarmi(int a,int b,int c);meghívom a mainből
int main(){
int egyik=2;
int masik=5;
int harmadik=10;
int eredmeny=0;
eredmeny=fvAkarmi(egyik, masik, harmadik);
cout<<eredmeny;
}int fvAkarmi(int a,int b,int c){
return (a+b)*c;
}Nekem úgy lenne logikus, hogy a függvényben először létrehoznék három változót (akár a main-ben használt nevükön) és átadnám nekik az argumentumokat és azokat használnám tovább.
Láttam olyat is, hogy a prototipusban nincs is név adva az argumentumnak csak a tipusa van megadva. Ebben az esetben mivel azonosítom (hogyan használom) a fv-ben az egyes argumentumokat?
-
#3967
m.zmrzlina
senior tag
PandaMonium
#3966
m.zmrzlina
senior tag
válasz
PandaMonium
#3966
üzenetére
Miért keresnél egyáltalán ilyet?
Semmi különös oka nincs csak volt egy jelenség amit nem értettem. (ha csak egy volna
)Egy tab-bal tagolt fájlban az n. sor utolsó és az n+1. sor első eleme között ez a két karakter látszik (Notepad ++) és gondoltam, ha már a \n megtalálható akkor az \r is.
Egyébként álítólag ha windowson text módban nyitunk meg egy fájlt akkor a sorvégi \r\n kombináció lecserélődik \n-re ezzért nem lehet megtalálni az \r-t. Bináris módban kell megnyitni és akkor ott lesz mindkettő.
Nem magamtól vagyok ilyen okos itt olvastam.
-
#3966
PandaMonium
őstag
m.zmrzlina
#3965
PandaMonium
őstag
válasz
m.zmrzlina
#3965
üzenetére
A '\r' egy carriage return karakter, ami nem feltételnül fog szerepelni a fájlban. Miért keresnél egyáltalán ilyet? ('\n' = új sor, '\t' = tab, ezeket gondolom tudod)
-
#3965
m.zmrzlina
senior tag
m.zmrzlina
senior tag
Van itt ez a függvény:
void readToArray(array<string,ARR_SIZE> &arr){
string word;
int crPos=0;
ifstream file("napok.txt");
if(file.is_open())
{
for(int i = 0; i < ARR_SIZE; ++i)
{
getline(file,word,'\t');
arr[i]=word;
if(i==ARR_SIZE-1){
for(size_t i=0;i<word.length();i++)
crPos=word.find('\n');
cout<<crPos;
}
}
}
}Egy TAB-bal tagolt fájlból olvas be egy sort egy tömbbe szavanként. Az
arr[i]=word;utáni rész az utolsó tömbelemben keresi meg a '\n' karaktert. Szépen működik is. Azonban ha a '\r'-t szeretném megkeresni vele akkor nem ad vissza értékelhető találatot.Mi erre a magyarázat?
-
#3963
m.zmrzlina
senior tag
m.zmrzlina
senior tag
Van két db kétdimenziós tömböm. Az egyik int a másik char tipusú adatokat tárol. Ki szeretném iratni mindkettőt ugyanazzal a függvénnyel. Azt olvasom itt, hogy a template-ek pont ilyen feladatokra valók (ti. amikor kb ugyanaz a függvény csak más tipusú változókkal dolgozik)
El is készítettem a templatet:
template <class T>
T print2DArray(const array<array<T,COL_MAX>, ROW_MAX> &a){
cout<<" "; //column header
for(int i=0;i<COL_MAX;i++){
cout<<i<<" ";
}
cout<<endl;
for(int i=0;i<ROW_MAX;i++){ //array body
cout<<i<<" ";
for (int j=0;j<COL_MAX;j++){
cout<<a[i][j]<<" ";
if(j==COL_MAX-1) cout<<i<<endl;
}
}
cout<<" "; //column footer
for(int i=0;i<COL_MAX;i++){
cout<<i<<" ";
}
cout<<endl<<endl;
return 0;
}Aztán meghívom a main()-ból így:
print2DArray<int>(intArray);meg igy:
print2DArray<char>(charArray);A két tömb kiíródik, mindenki örül.
Szeretném úgy módosítani a template-t, hogy <char>-ral való meghíváskor (de csak akkor) még egy további (int tipusú változót) is ki tudjak vele iratni. Hogyan lehetséges ez? -
"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.
-
kutkut
addikt
válasz
dabadab
#3949
üzenetére
Már miért kéne sok ezer soros kód ahhoz, hogy objektumokat használj?! Pláne, tanulási fázisban... Pl. matekban az integrálásnak is akkor van értelme, ha kellően "girbegurba" a függvény, mégis egyszerűbb megérteni a lényegét az y = x típusú függvényekkel...
Bár azzal egyetértek, hogy még korai elővenni az objektumokat, először a pointereket kéne átvenni. De mindenekelőtt a goto-kat elhagyni!
-
#3957
dobragab
addikt
PandaMonium
#3956
dobragab
addikt
válasz
PandaMonium
#3956
üzenetére
std::string-et megstd::vector-t lehet ugy hasznalni, hogy nincs kimondva az objektum vagy RAII szo.Nem muszaj tudnia, hogy mi az az egysegbezaras, adatrejtes, peldanyositas, polimorfizmous, adatabsztrakcio, interfesz, amig azokat tanulja, hogy linearis kereses, fuggveny, visszateresi ertek, szamlalas, rendezes. Persze elobb-utobb annak is eljon az ideje, de az eggyel magasabb absztrakcios szint, eggyel kesobb fogja ertelmet latni, es amennyire latom, most meg nem tart ott.
-
#3956
PandaMonium
őstag
dobragab
#3955
PandaMonium
őstag
válasz
dobragab
#3955
üzenetére
Az STL is objektum-orientált, hogy fogja megérteni pl. hogy működnek a file handlerek, vagy smart pointerek, ha nem tudja mi az a konstruktor és destruktor? Vagy, hogy mikor és miért akkor szabadul fel pl. a vector által allokált memóriaterület? Ez nem Java, hogy majd a GC kipucolja, érteni kell a memória allokálás és felszabadítás folyamatát, különben sokszor lábon fogod lőni magad.
Persze, tanuljon algoritmusokat meg konténereket, adatszerkezeteket, de a nyelv szemantikája és a benne használt paradigmák ugyanilyen fontosak. Ezeket sem kell rögtön PhD szinten tudni, csak annyira, hogy értsd amit csinálsz.
-
#3955
dobragab
addikt
PandaMonium
#3954
dobragab
addikt
válasz
PandaMonium
#3954
üzenetére
Amíg alapvető algoritmusokat és adatszerkezeteket nem ismer, addig nem fogja tudni megérteni, ezek mire jók. Annak is eljön az ideje, de semmi értelme úgy írogatnia a class és provate szavakat, hogy nem ismeri a jelentését és az értelmét.
-
#3954
PandaMonium
őstag
dabadab
#3951
PandaMonium
őstag
válasz
dabadab
#3951
üzenetére
Nyilván nem ennyit tanulna belőle. Rögtön jön a header-ekre bontás, akkor az hozza magával az include guardokat, utána osztályon belül scope és láthatóság, statikus adattagok és függvények, getter/setter-ek, öröklődés, stb. Az OOP nagyon nem annyi, hogy "class".
(#3953) emvy: Igen, de ezzel fog a legtöbbet találkozni akkor is ha tutorialokat nézeget, illetve erre épülnek további alapvető (observer, factory, facade, ...) és összetettebb (MVC, ECS, ...) szoftvertervezési minták. Azt mégsem javasolhattam, hogy kezdjen el monad-okról szóló oktatóanyagot keresni funkcionális programozáshoz C++ban.
-
#3953
emvy
félisten
PandaMonium
#3950
válasz
PandaMonium
#3950
üzenetére
Raadasul az OOP az nem az egyetlen udvozito iranyzat.
-
#3951
dabadab
titán
PandaMonium
#3950
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.
-
#3950
PandaMonium
őstag
dabadab
#3949
-
#3949
dabadab
titán
PandaMonium
#3948
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. -
#3948
PandaMonium
őstag
daninet
#3947
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.
-
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 -
#3945
dabadab
titán
m.zmrzlina
#3943
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ő. -
#3944
cattus
addikt
m.zmrzlina
#3943
cattus
addikt
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.
-
#3943
m.zmrzlina
senior tag
dabadab
#3937
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. -
#3941
b.kov
senior tag
m.zmrzlina
#3939
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.
-
#3940
dabadab
titán
m.zmrzlina
#3939
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 -
#3939
m.zmrzlina
senior tag
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?
-
#3937
dabadab
titán
m.zmrzlina
#3936
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?) -
#3936
m.zmrzlina
senior tag
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); -
#3935
daninet
veterán
PandaMonium
#3934
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 
-
#3934
PandaMonium
őstag
daninet
#3931
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. -
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";
}
} -
#3930
mgoogyi
senior tag
m.zmrzlina
#3929
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.
-
#3929
m.zmrzlina
senior tag
dabadab
#3928
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 -
#3928
dabadab
titán
m.zmrzlina
#3927
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 ) -
#3927
m.zmrzlina
senior tag
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?
-
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. -
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;
} -
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áma -
#3917
m.zmrzlina
senior tag
EQMontoya
#3916
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)
-
#3916
EQMontoya
veterán
m.zmrzlina
#3915
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.
-
#3915
m.zmrzlina
senior tag
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?
-
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.
-
#3912
Domonkos
addikt
m.zmrzlina
#3911
Domonkos
addikt
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". -
#3910
Domonkos
addikt
m.zmrzlina
#3908
Domonkos
addikt
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... -
#3909
Domonkos
addikt
m.zmrzlina
#3907
Domonkos
addikt
válasz
m.zmrzlina
#3907
üzenetére
Ezek a fuggvenyek lehetnek
voidok. Abban az esetben lehet ertelme hogy plintvisszateresi 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. -
#3908
m.zmrzlina
senior tag
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?
-
#3907
m.zmrzlina
senior tag
PandaMonium
#3906
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;
} -
#3906
PandaMonium
őstag
m.zmrzlina
#3905
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. -
#3904
dabadab
titán
m.zmrzlina
#3902
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]) )
{
...
} -
#3902
m.zmrzlina
senior tag
kispx
#3900
m.zmrzlina
senior tag
-
#3901
b.kov
senior tag
m.zmrzlina
#3899
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).
Szerintem amellett hogy helypazarlo meg zavarossa is teszi a kiirt infokat. En lemondanek rola.
)
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Új hozzászólás Aktív témák
Hirdetés
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Luck Dragon: Asszociációs játék. :)
- sziku69: Fűzzük össze a szavakat :)
- AMD K6-III, és minden ami RETRO - Oldschool tuning
- Megjött a jubileumi Pixel széria
- Jövedelem
- Óra topik
- AMD Ryzen 9 / 7 / 5 9***(X) "Zen 5" (AM5)
- Asztalos klub
- Rekordokra vágyik! Kezünkben az Asus ROG Matrix GeForce RTX 5090
- Mafia: The Old Country teszt
- További aktív témák...
- Intel Core i5 3470 confidential Ivy bridge Quad Core
- IKEA Format lámpák eladóak (Egyben kedvezménnyel vihető!)
- GYÖNYÖRŰ iPhone 13 mini 256GB Blue -1 ÉV GARANCIA - Kártyafüggetlen, MS3180
- TELJES KÖRŰ IT BESZERZÉS
- Gamer Notebook! Csere-Beszámítás! Asus Tuf F15 FX506H / 11400H / RTX 3050 / 16GB DDR4 / 512 SSD
Állásajánlatok
Cég: FOTC
Város: Budapest