- Az NVIDIA szerint a partnereik prémium AI PC-ket kínálnak
- Két Zen 5-ös dizájnjának mintáit is szállítja már az AMD
- A Colorful "fagyosan kompakt" alkatrészekkel megy elébe a nyárnak
- A Keychron ismét egy űr betöltését vállalta magára az egerek szegmensében
- Az átlagnál vaskosabb ventilátorok kandikáltak ki a Corsair vitorlája mögül
Hirdetés
-
Egyre közelebb a Poco F6 startja
ma Újabb ár/érték csatát nyerhet a Xiaomi almárka.
-
Toyota Corolla Touring Sport 2.0 teszt és az autóipar
lo Némi autóipari kitekintés után egy középkategóriás autót mutatok be, ami az észszerűség műhelyében készül.
-
Premier előzetest kapott a V Rising
gp Napokon belül befut a teljes PC-s kiadás, az év során pedig megkapjuk a PlayStation 5 változatot.
Új hozzászólás Aktív témák
-
Jester01
veterán
válasz EQMontoya #2643 üzenetére
Minden bizonnyal olyan környezetben vagy ahol az int és a double között van egy kis üres hely. Például ha az int 32 bites a double meg 64 akkor lesz közöttük 4 byte üres hely. Az ip++ erre az üres helyre fog mutatni, viszont a dp már félig át fog lógni a double tagba. [ Szerkesztve ]
Jester
-
zsambek
aktív tag
válasz EQMontoya #2682 üzenetére
Haha
Ha mar itt tartunk, most neztem, hogy meg biztosan le van mentve a 2003-as evfolyamig a felhasznalo fiokok, szoval nem tudom, h mikor vegezted az infot, de esetleg meg te is be tudnal lepniValósítson meg C++ nyelven egy olyan osztályt (F12),
amely egyrészt átadható a 2. feladat megoldását segítő
függvénynek (solveF2(const F2&)), másrész képes az STL deque
sablonjához hasonlóan működve ASCII karaktereket tárolni!
C++ nyelven a többszörös öröklést célszerű használni, ha
egy objektumnak többféle interfésszel kell rendelkeznie, ezért
a feladat megoldásához előkészített f12.h állományban, mely
az aktuális katalógusban (...) található,
az F12 osztályt az F2 és a Queue osztályból származtattuk.
Az F2-ben deklaráltuk azt az f() függvényt, ami a hftest 2. feladatát
hivatott megoldani. A Queue osztály pedig egy karaktereket tároló
kétvégű sort valósít meg az STL deque sablonjának felhasználásával,
de attól egy kicsit eltérő funkcionalitással.
Az Ön feladata megvalósítani az f12.cc állományban az F2,
az F12 és a Queue osztály tagfüggvényeit és statikus adattagjait.
Az F2 osztály double f(double) tagfüggvénye a következő függvényt
kell, hogy megvalósítsa (ld. 2. feladat):
f(X) = X/120.90, ha X > 35,
f(X) = 0.472*X^4 - 0.943*X^3 + 60.38*X^2 + 3*X - 35, ha X <= 35
A Queue osztálynak van egy myIteraror nevű iterátora is,
amellyel a karaktersorozat az elejétől a végéig bejárható.
Segitségképpen egyes tagfüggvényeket már definiáltunk az f12.h
állományban.
Figyelje meg, hogy az iterator milyen egyszerűvé teszi a tároló
kezelését! Az f12_main.cc állományban lát erre példát, ami az aktuális
(...) katalógusban található a fordítást segítő
f12.mak állománnyal együtt.
Ha elkészült, fordítsa le, ill. tesztelje az osztályt
a következő paranccsal:
make -f f12.mak
A make lefordítja az f12.cc-t valamint az
f12_main.cc-t és így futtatható a keletkező f12 nevű program.
Az f12_main.cc a teszetlést segíti. Azt igénye szerint módosíthatja.
Az f12.h állományt azonban NE módosítsa!
Ha úgy gondolja, hogy helyesen oldotta meg a feladatot, akkor a
make -f f12.mak submit
paranccsal adja be azt az automatikus feladatellenőrző rendszernek.
Az automatikus teszt csak az f12.cc állományban megvalósított
F2, F12 és Queue osztályok működését vizsgálja, azaz, hogy megfelelnek-e
a fent megadott specifikációnak. Így nem veszi figyelembe az f12_main.cc
tartalmát, és azt sem, ha esetleg módosított az f12.h-ban![ Szerkesztve ]
-
EQMontoya
veterán
válasz EQMontoya #2695 üzenetére
Válaszolva erre is: ma már eléggé nagy multi lett, keresnek kezdőt, tapasztaltat, javast, pythonost, PM-et, stb.
C++-os vonalon igazából nem kell semmilyen ilyen múlt, akinek van tapasztalata és vágja a c++, vagy kezdő de van jó agya és affinitása, azt felveszik simán.Lassan 700 fő a cég, szegedi irodával, nincs már olyan nagy válogatás... Azért mondjuk az Ericssonnál, NSN-nél magasabban van a mérce még mindig.
[ Szerkesztve ]
Same rules apply!
-
dabadab
titán
válasz EQMontoya #2707 üzenetére
"Miert ne tenned?"
Mert a bennem élő egészséges lustaság arra késztet, hogy ne foglalkozzak az implementáció részleteivel, ha nem muszáj. Ha kell, akkor tudom, hogy ott a this is, de általában nem kell tudno, ill. amikor tanítják a C++-t, akkor azért problémás lehet ezt elővezetni, mert ez szinte az első dolog lehet(ne), ugyanakkor a megértéséhez szükséges az, hogy az ember értse, hogy hogyan is működnek a dolgok a CPU-ban, ami gyakran hiányzik a nebulókból.
DRM is theft
-
jattila48
aktív tag
válasz EQMontoya #2721 üzenetére
Azért az újabb C++ 11 fordítóknak (pl. VS2012) tudtommal tudniuk kell. Főleg az unnamed RVO-t, ami szinte biztosan működik minden "normális" C++ fordítóval.
std::pair<int,int> swap(int x,y){
return std::pair<int,int>(y,x);
}Itt nincs a pair-ből temporális változó (ezért unnamed), ezért szinte biztos , hogy az RVO működik. Tehát körültekintő módon megírva a programot, nyugodtan számíthatsz az RVO-ra. Egyébként kis méretű visszatérő értékek esetén (pl. két int) akkor is a pair célszerűbb, ha netán nincs RVO. Vagyis tényleg ne féljetek a pair/tuple-től, a felvetett problémára szerintem ez a legelegánsabb C++ megoldás.
„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
jattila48
aktív tag
válasz EQMontoya #2723 üzenetére
Az RVO nem ugyanaz mint a move szemantika (bár hasonló célt szolgál), az én példámban URVO történik, nem pedig move. Az RVO hatékonyabb lehet, mivel se copy, se move ctort nem hív. Bár most már kezdünk elkanyarodni az eredeti problémától.
„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
ToMmY_hun
senior tag
válasz EQMontoya #2736 üzenetére
Először is köszönöm a választ.
A feltételes példányosítás alatt pedig azt értem, hogy csak akkor történjen meg a példányosítás, ha bizonyos feltételeknek ( például tömeg nagyobb mint nulla, hossz nem negatív) megfelelnek az argumentumok.
Végülis ha a factoryban csinálok minden példányosítani kívánt osztályra egy publikus kreátort, akkor rendben van.
C programmers never die, they are just cast into void.
-
jattila48
aktív tag
válasz EQMontoya #2746 üzenetére
Nem is állítottam, hogy RVO==move, pont azt írtam, hogy nem. Ha lehet, akkor célszerűbb az RVO-ra hagyatkozni, mint a move-ra. Hogy koncepcionálisan milyen a példa, az csak egy dolog. A move szemantikát akarta bemutatni, azt viszont teljesen hibásan. Ez a baj!
„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
dabadab
titán
válasz EQMontoya #2753 üzenetére
Hahó, printf, nincs ott se típusellenőrzés, se cast, adsz neki valamit és majd azt valahogy értelmezi, akkor is, ha annak úgy semmi értelme. Szóval nem hogy csak lefordul, de még csak warning se lesz (hacsak nem olyan nagyon okos a fordító, hogy külön ismeri a printf-et, végigparse-olja a format stringet és megnézi, hogy értelmes adatokat adtál-e meg neki - de nem tudom, hogy ezt tényleg megcsinálja-e bármelyik fordító (Visual Studio biztosan nem))
DRM is theft
-
válasz EQMontoya #2760 üzenetére
Na jó, csak azt kellene csinálnom, hogy az alábbi strukturában van egymás alatt rengeteg, nagy mennyiségű adat:
1 2 3 4 5
6 7 8 9 10
11 12 13 14 1516 17 18 .......
.....................
..........................................
....................
....................Na és ezt kellene az elpőbb felvázolt módon egymás mellé pakolgatni, hogy így nézzen ki:
1 2 3 4 5 16 17 18 ....... .....................
6 7 8 9 10 ..................... .....................
11 12 13 14 15 ..................... .....................Szóval akkor marad a fapados megoldásom?
-
Karma
félisten
válasz EQMontoya #2762 üzenetére
Egy 2 GB-os fájlnál ez a stratégia már nem nagyon fog működni (Windowson, 32-bites bináris esetén).
Nekem egyébként nem világos, hogy a történet merről kezdődik: van egy blokkokra (három soros egységekre) tagolható, gyakorlatilag végtelen fájl, amit "el kéne forgatni" úgy, hogy egy blokk hosszú legyen és végtelen széles?
A blokk magassága fix?
Mert akkor meg lehet csinálni minimális memóriaigénnyel és a bemenet egyszeri olvasásával. Ha külön ideiglenes fájlba gyűjtesz minden egyes sort (ez blokkmagasság darab fájlt jelent), mindegyiknek szigorúan a végére írsz (minden 3*m+i-edik sort a bemenetről, ahol m a blokk száma, i pedig a fájl indexe), majd a legvégén összefűzöd a három fájlt, kész is az eredmény.
Ha a blokkmagasság nem ismert, akkor a feladatnak nincs sok értelme.
“All nothings are not equal.”
-
-
nagyúr
válasz EQMontoya #2779 üzenetére
Hat vagy igen, vagy nem. En ugy kepzeltem, hogy a problemaja az, hogy a leszarmazottakat nem 'Part'-kent akarna hasznalni, hanem a leszarmazottak specialis tulajdonsagaira van szukseg.
Tehat ha van Part, meg PartSubC1 meg PartSubC2, akkor neki adott esetben csak a PartSubC2 a megfelelo, es PartSubC1 nem.
Persze az lehet, hogy a Part-nak van egy virtualis fuggvenye, ami kozli a sajat nevet/tipusat, es a problema meg is van oldva -- ez az egyik megoldas a sok kozul. A dynamic_cast egy masik. A lenyeg, h runtime check az kell.
[ Szerkesztve ]
while (!sleep) sheep++;
-
ToMmY_hun
senior tag
válasz EQMontoya #2786 üzenetére
Azért nem template class, mert nem tudom mi az, nem találkoztam még vele. Nagyjából másfél hónapja kezdtem el a projektet nulla c++ tudással (és kevés OOP-vel is, mivel villamosmérnökként nem tananyag az objektum orientált programozás), de igyekszem kihozni a maximumot magamból és a programból is. Inkább segítséget mit kritikát kérnék, mert abból többet tanulok és végső soron ez a cél.
"Ha PartSubC mellett lesz egy PatrSubD, ami szintjén jó Neked, akkor 2x fogsz castolni, és még pár módosítás múlva láncolt listát bejáva fogsz castolni ( ), vagy lesz egy PartSubVirtualCD osztály, amiből leszármazik mindkettő, tehát az objektumstruktúrádat b@szod szét fölöslegesen?"
Nekem van egy Part ősosztályom, abból származnak le a specifikusak, mint Effector, Joint, ArmPart és Body, ezek egy robotkar részeit képezik. A kereső metódus az ezeket tároló map-ben keres és mindig csak egy adott objektum típusra lesz szükségem, amit majd elkérek a factory-tól. Szerintem így sosem lehet szükségem dupla kasztolásra, vagy rosszul látom?
C programmers never die, they are just cast into void.
-
ToMmY_hun
senior tag
válasz EQMontoya #2788 üzenetére
Ez jogos, de nem látok rá esélyt, hogy fog. A matematikai számításokhoz a karrészek hosszára, szélességére van szükség, azokból pedig létrehozhatok bármennyi példányt és az működik a jelenlegi koncepcióval. Persze ha van valami frankó ötleted a megvalósításra, azt szívesen meghallgatom és ha nem tart napokig a megvalósítása, akkor meg is csinálom.
A template tippet köszönöm, utána fogok járni mielőtt újra a kódhoz nyúlnék.
C programmers never die, they are just cast into void.
-
yossarian14
tag
válasz EQMontoya #2797 üzenetére
A c++ kódban a ciklusmag üres, direkt tesztelés céljából.
A Java kódom sokkal gyorsabb még úgy is, hogy a ciklusmagban komoly dolgok folynak (egy adatszerkezetet építek fel a memóriában a beolvasott szöveg alapján):
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(file));
String line;
while ((line = br.readLine()) != null) {
process(line);
}Köszi a segítséget!
-
yossarian14
tag
válasz EQMontoya #2801 üzenetére
Így írtam be, de elszállt a program, nem fut le. Gondolom valamit rossz helyre tettem.
void process(string fileName) {
cout << ++j << ": " << fileName << endl;
ifstream file(fileName);
string line;
const int size = 10*1024*1024;
char mybuffer [size];
file.rdbuf()->pubsetbuf(mybuffer,size);
while (getline(file, line))
{
}
} -
#99472384
törölt tag
válasz EQMontoya #2814 üzenetére
Üdv.
Tévedsz, nem maradt ki az utánaolvasás, de nem is ezzel van a gond, mert nagyvonalakban értem.
A fordítással van a gond, mivel nincs Visual C++ -om, ami meg ingyenes, az nem fordítja le, de nem is csoda mert szinte önmagával sem kompatibilis.Hogy milyen operációs rendszerre kell, azt leírtam. 32 vagy 64 bit szinte tökmindegy, mert 64bites Athlonom van, és az op rendszerből is van 32 és 64 bites verzióm. Persze a 32bites verzió lenne a jobb megoldás. Az meg hogy mit és hogyan számol, az tökmindegy, és nincs egyszerűbb megoldás, ugyanis amit számolnia kell az eleve nem publikus.
Ezt a programot is azért írta egy német fickó, mert az egyik ilyen fájlja megsérült, és használhatatlanná vált.No, de ezek jelenleg lényegtelen információk.
Amit linkeltél, az eddig is világos volt számomra, de mint írtam nem is ez a gond.
[ Szerkesztve ]
-
LordX
veterán
válasz EQMontoya #2835 üzenetére
Erősen ellenjavallott kétoperandusú operátoroknál a tagfüggvényes megvalósítás, ha létezik implicit konverzió más típusokról. Eléggé hülyén néznek a userek, ha a*b lefordul, b*a nem. (Jó, most a mátrixszorzásnál ez nem annyira számít, mert amúgy is csak a megfelelő mérteket kell hagyni.) Ha lehetséges, legyen az operátor szabad függvény, és legyen friend, ha belső dolgokban is turkál.
-
LordX
veterán
válasz EQMontoya #2838 üzenetére
struct X {};
struct Y {
Y() = default;
Y(X) {}
Y operator +(const Y& right) { return *this; }
};
Y operator *(const Y& left, const Y& right) { return left; }
void f() {
X x1, x2;
Y y1, y2;
auto t1 = x1 + y1; //member op - nem fordul le
auto t2 = y2 + x2; //member op - lefordul
auto t3 = x1 * y1; //free op - lefordul
auto t4 = y2 * x2; //free op - lefordul
}[ Szerkesztve ]
-
jattila48
aktív tag
válasz EQMontoya #2845 üzenetére
Valóban, az operator+ tagoperator helyesen my_matrix operator+(const my_matrix &mm) const
operator* tagoperator pedig nincs. const_cast azért kell, mert a nem const verzió ugyanaz mint a const verzió, csak nem const objektum egy elemére ad vissza nem const referenciát. Itt most egyszerűbb lett volna beírni ugyanúgy azt az egy sort, azonban ha const verzió változik, változtatni kell a nem const verziót is. Bonyolultabb esetekben is általában ez a megfelelő megoldás. A const_cast-ok csak a fordítónak szólnak, nem generálódik kód hozzá, így aztán hatékony is.„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
jattila48
aktív tag
válasz EQMontoya #2847 üzenetére
Az assert valóban nem véd alul indexelés ellen, nem akartam annyit írni. Ez amúgy is csak egy vázlat. Megoldható úgy is ahogy írod, de szerintem így elegánsabb (és talán hatékonyabb). Amúgy nem sok eset van, amikor a const_cast-nak létjogosultsága van, ez az egyik (más most nem is jut eszembe), ezt is szerettem volna bemutatni. Ha teljesen kidolgoznám a példát, akkor pl. a scalar_type-ot is megnézném, hogy triviálisan másolható-e, és ettől függően írnék vagy nem írnék hozzá copy ctort és értékadó operátort. Esetleg a default ctort lenne érdemes átalakítani, hogy az összes elemet adott értékkel feltöltse (ekkor persze már nem default) pl. így:
explicit my_matrix(T x=T()){
int i,j;
for(i=0;i<n;++i){
for(j=0;j<m;++j){
matrix[i][j]=x;
}
}
}[ Szerkesztve ]
„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
ToMmY_hun
senior tag
válasz EQMontoya #2866 üzenetére
Először is köszi a választ! Azért szeretném ezt használni, mert lenne egy osztályom amiben egy szerver socketet szeretnék futtatni és a socketet új threadben akarom indítani. Az új threadet az osztály konstruktorában indítom és ugye ott kéne neki átadni a futtatandó metódust is, ezért lenne szükségem a pointerre. Az osztálynak csak a socket által kiküldött vektor feltöltése és magának a socket kommunikációnak a lebonyolítása a feladata, egy példány lesz belőle. Ha erre lenne valami szebb megoldási javaslat, akkor annak örülnék és köszönöm előre is! Addig is kipróbálom amit javasoltál.
Static metódus ugye azért nem frankó, mert akkor nem érem el az osztály belső változóit. Persze ha úgyis csak egy példány lesz, akkor lehet singleton és úgy el is érem, de nem tűnik szimpatikusnak a megoldás, tuti van ennél szebb.
[ Szerkesztve ]
C programmers never die, they are just cast into void.
-
jattila48
aktív tag
válasz EQMontoya #2870 üzenetére
A T s=T(); deklarációban nincs copy elision (és másfajta optimalizáció sem), mert nincs rá szükség, ha triviális a copy ctor, ha nem. Egyszerűen a T() ctor hívódik meg és hozza létre az s-et mindenféle optimalizációtól függetlenül.
"Ha mondjuk van ott egy logolás, akkor simán le fog futni a default ctr majd a copy"
Mármint a copy ctor-ban van logolás? Nem fog lefutni, és a log sem fog kiíródni, és ez nem az optimalizáció miatt van, hanem mert deklarációban ez egyszerűen így működik. Próbáld ki! Mellesleg copy elision esetén (itt nem aróól van szó!) akkor is kioptimalizálhatja a copy ctor hívást, ha van megfigyelhető mellékhatása (ol. logolás). Ez is benne van a szabványban.[ Szerkesztve ]
„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
jattila48
aktív tag
-
LordX
veterán
válasz EQMontoya #2870 üzenetére
Nem, mellékhatással rendelkező konstruktor is áldozatul eshet a copy elisionnek:
[class.copy] bekezdés (jó hosszú alfejezet, a vége felé):
"When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the constructor selected for the copy/move operation and/or the destructor for the object have side effects."
(A "certain criteria" az (N)RVO, a "hagyományos" copy elision és a throw ill catch esetében az exception objektumok konstrukciója listát tartalmazza.)
[ Szerkesztve ]
-
LordX
veterán
válasz EQMontoya #2897 üzenetére
Ez talán a link order hülyeség lesz. Nem ignorálja a paraméteredet, hanem hülyén működik a linker: a paraméterek sorrendjében megy végig a linkelendő objektumokon (.cpp esetében forditás után), és belinkeli a {main függvényt, namespace static objektumokat, eddigiek által referált függvényeket}. Szóval a .cpp-ben hiába referálsz a protobuf függvényére, linker nem találja meg, mert nem találkozik vele a cpp után.
Én is falra tudok mászni ettől..
-
dobragab
addikt
válasz EQMontoya #2901 üzenetére
Pontosan ugyanebbe futottam bele Linux Mint-en, 4.8-as GCC. Arch-on 5.2-es GCC mellett írtunk egy makefile-t, ami gond nélkül megette. Utána Minten próbáltam fordítani, a linker undefined reference miatt halt el szinte minden linkelendő függvénynél. Szerencsére hallottam már a problémáról, röpke 10 perc alatt rájöttem.
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
dobragab
addikt
válasz EQMontoya #2905 üzenetére
Rosszabb. ZH-ban láttam.
int emelet(int szobaszam)
{
switch(szobaszam / 100)
{
case 0: return 0; break;
case 1: return 1; break;
case 2: return 2; break;
case 3: return 3; break;
case 4: return 4; break;
case 5: return 5; break;
case 6: return 6; break;
case 7: return 7; break;
}
return -1;
}Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
Ú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!
- Házi barkács, gányolás, tákolás, megdöbbentő gépek!
- SSD kibeszélő
- Luck Dragon: Asszociációs játék. :)
- Termékoldal buktatta le a Huawei Watch Fit 3-at
- OLED TV topic
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- Vezeték nélküli fülhallgatók
- Milyen CPU léghűtést vegyek?
- Milyen billentyűzetet vegyek?
- Samsung Galaxy S23 Ultra - non plus ultra
- További aktív témák...