Új hozzászólás Aktív témák
-
Karma
félisten
válasz Ton-ton #2050 üzenetére
A Qt licencét mindenképpen olvasd újra. LGPL alatt van (a Nokia egyik legnagyobb achievementje volt ez!), azaz semmi akadálya nincs annak, hogy fizetős, zárt forráskódú alkalmazást építs rá.
Ilyen igényekre mással neki se láss szerintem, ha a C++ a célnyelv.
[ Szerkesztve ]
“All nothings are not equal.”
-
modder
aktív tag
válasz Ton-ton #2050 üzenetére
nekem az Eclipse jól bevált C++-ra. Automake meg mindenféle van benne, cross-compilingra is biztosan be lehet lőni. Lehet, hogy nem tökéletes, de elég jól működik benne a kódkiegészítés, meg minden cucc. A Qt developert még nem próbáltam ki sima C++ alkalmazás készítésére, egyszer volt alkalmam vele találkozni, és nagyon tetszett az egyszerűsége és gyorsasága.
-
Ton-ton
tag
modder, Karma köszönöm.
http://qtp.hu
-
axelf92
csendes tag
Sziasztok!
A C++ házi feladatom felépítéséről nem sok fogalmam van, ezért szeretnék segítséget kérni. Ez a következő:Kulcs-érték párokat tároló generikus asszociatív hash tömböt kell létre hozni, melyben az elemek hash táblában tárolódnak. A kulcs és az érték osztályok legyenek sablonparaméterek, a kulcsokat az < operátorral lehessen összehasonlítani. A tömbhöz lehessen új elemeket hozzáadni, módosítani, törölni, lekérdezni, hogy adott kulcshoz van-e érték tárolva. Működjön az indexelő operátor is és valósítsa meg a másoló konstruktort, az értékadást és az egyenlőség vizsgálatot is!
Jelenleg a fő problémám, hogy az osztályok hogyan nézzenek ki, tehát legyenek leszármaztatva valamiből, vagy egyik a másikból? És az osztályokban milyen private tagok legyenek?
A függvényeket szerintem meg tudom írni, de ehhez kellene tudnom, hogyan néz ki az egész struktúra, ami gondot okoz, mert nem beszéltünk asszociatív tömbökről. (tehát ebben is örülnék bárminemű segítségnek
Köszönöm, hogy elolvastad.
-
pvt.peter
őstag
Sziasztok!
A virtuális függvények használatára tudna vki olyan példát mondani, ami megmutatná, hogy ténylegesen mi értelme van ezek használatára? Illetve milyen helyzetekben érdemes használni őket?
Köszi,
PetiEz egy .50-es rombolópuska, elég szép visszarúgással.
-
mgoogyi
senior tag
válasz pvt.peter #2057 üzenetére
röviden:
polimorf osztályoknál van értelme, amikor specializálod a működését az ősosztálynak és minden leszármazottat kezelhetsz úgy, mint ha az egy ősosztálybeli objektum lenne.
pl. minden almát és körtét kezelhetsz gyümölcsként
pl. Akkor van ennek haszna, mikor van egy rakás valamilyen gyümölcsöd mondjuk egy halmazban és együtt akarod kezelni őket, mert pl. az adott helyzetben számodra nem lényeg, hogy milyen specializált gyümölcsről van szó.Amikor örökölsz, akkor a virtuális függvények mindig befigyelnek!
hosszan:
class Gyumolcs
{
...
virtual void print() {printf("gyumolcs")}
...
};
class Alma() : public Gyumolcs
{
...
virtual void print() {printf("alma")}
...
};
class Korte() : public Gyumolcs
{
...
virtual void print() {printf("korte")}
...
};
Gyumolcs * a = new Alma();
a->print(); //azt írja ki, hogy alma, pedig ez egy Gyumolcs pointer
/*mivel: a virtuális függvényeknél futási időben dől el (dinamikusan), hogy mi hívódik (megnézi, hogy valójában milyen objektumról van szó és annak a függvényét hívja - a háttérben egyébként van az objektumnak egy virtuális táblája és abból nézi ki, hogy mit kell hívni)
ha nem virtuális lenne a függvény, akkor fordítási időben (statikusan dőlne el, mit kell hívni és "gyumolcs" íródna ki)*/ -
modder
aktív tag
válasz pvt.peter #2057 üzenetére
Hali. Polimorfizmus (többalakúság, ugyanolyan ős típusú objektumok másképpen viselkedhetnek). Amikor több osztályod van, ami ugyanazokat a tulajdonságokat (metódusokat) definiálja, ezért közös ősből származik, de mégis minden osztály egy kicsit másképpen viselkedik, vagyis kicsit más az implementációjuk, viszont az interfészük (amit az osztály használója lát) megegyezik.
Most hirtelen a Java JDBC API jut eszembe:
//Create the connection using the static getConnection method
Connection con = DriverManager.getConnection (connectionURL);
//Create a Statement class to execute the SQL statement
Statement stmt = con.createStatement();Itt a DriverManager egy factory osztály, ami olyan Connection példányt ad vissza, ami adatbázis specifikus a szerint, hogy milyen adatbázis típus szerepel a connection URL-ben. A Connection csak egy interfész, minden konkrét adatbázis JDBC driver a sajátját specifikálja, és a konkrét, con változóhoz kötött példány lehet, hogy mondjuk MysqlConnection típus lesz. Itt a lényeg az, hogy a MysqlConnection a Connection-ből származik, és felülírja a Connection metódusait.
Ami fontos megjegyezni futás időben fog eldőlni, hogy melyik metódus fog meghívódni, mert fordításkor lehetetlen eldönteni a fenti kódrészletből, hogy a con változó konkrétan milyen osztály lesz.
C++-ban explicite ki kell írnod a virtual kulcsszót a függvény elé. Ha nem teszed ki, akkor is felülírhatod a metódust, de nem biztos, hogy azt az eredményt fogod kapni, amit vársz. Például
class A {
public:
void valami() { std::cout << "A"; }
virtual void virt() { std::cout << "A"; }
}
class B : A {
public:
void valami() { std::cout << "B"; }
void virt() { std::cout << "B"; }
}A b = new B();
b.valami(); // "A" fog kiíródni, mert valami() nem virtuális, tehát a változó "statikus" típusa alapján dől el, hogy melyik metódus fog meghívódni. A statikus típus pedig "A"B b = new B();
b.valami(); // itt a statikus típus "B", tehát "B" fog kiírodóni.Ezzel szemben
A b = new B();
b.virt(); // itt "B" fog kiíródni azért, mert a virt() függvény virtuális. futás időben a virtuális függvény táblából a program megnézi, hogy melyik konkrét függvény hívódjon meg. Mindezt a b változó futásidejű (dinamikus) típusa alapján, ami itt "B"Heterogén kollekciókban szokták hasznát venni, amikor (mint az első példában) egy közöt ős van, ami szolgáltatja az interfészt, de többféle implementációt tárolsz egy tömbben vagy listában. Amikor végigiterálsz rajtuk, hogy meghívd mindegyiken valamelyik metódusát, nem kell foglalkoznod a konkrét típussal, ami nagyban leegyszerűsíti a programozó munkáját. Ez annyira az általános elvárt működés, hogy Javában minden metódus virtuális. Ha nem akarod, hogy valamelyiket felül lehessen írni, akkor a final kulcsszót kell elé tenni.
Amikor egy osztályt kiterjeszthetőségre tervezel, ki kell választanod azokat a metódusait, amiket felül lehet majd írni, és virtuálissá teszed őket. Ezzel elég körültekintőnek kell lenned, mert egy felülírt virtuális metódus a származtatott osztályban el is ronthatja az alap működést.
[ Szerkesztve ]
-
mgoogyi
senior tag
válasz axelf92 #2056 üzenetére
Valami ehhez hasonló kéne legyen az osztályod:
template < class Key, class Value>
class HashArray
{
bool Insert(const Key & index, const Value & value);
Value operator[] (Key index) { return ...}
stb..
}A kérdés az, hogy a mögöttes adatstruktúra hogy kéne, hogy kinézzen.
Két általános módszer van:
1, Bináris fában vannak a kulcs-érték párok. Ezesetben a kulcsra értelmezhető kell legyen a < operátor.
2, Vagy úgynevezett bucketokban, kb van egy tömb, aminek minden eleme egy lista. A tömbbéli indexet valamiféle hasheléssel találod ki. Pl. ha a kulcs egy szám és 1024 elemű a belső tömböd, akkor a kulcs % 1024 helyen lévő listába tolod bele az új elemet. Csakhogy itt generikus kulcsról van szó, azt nem annyira triviális hash-elni.Itt valszeg az 1-es az ésszerű irány, ami nagyrészt ugyanez, mint az stl mapje:
pl:
#include <map>
#include <string>
std::map<int, std::string> m;
m[1] = "kutya";A legegyszerűbb az lenne nyilván, ha lenne belül egy std::map-ed memberként. (leszármaztatni nem szabad belőle)
De valszeg az 1-es irányt akarja az oktatód, szerintem kérdezd meg, hogy arra gondolt e. -
scream
veterán
Egy olyan kérdésem volna, hogy magasabb szinteken mennyire használatosak a nevezetes/egyéni felsorolók ?
Mert most a 2. progbeadandóban nevezetes felsorolókat kell használni (szekvenciális input file) és nem nagyon értem, pontosan mi előnyöm van belőle,ha felsorolóval írom meg?
Miért jobb felsorolókat használni, mint mondjuk sima intervallumos tételeket alkalmazni?
Nekem sokkal bonyolultabbnak és sok felesleges dolognak tűnik, bár valószínű én nem értem
[ Szerkesztve ]
-
modder
aktív tag
Ez így elég absztrakt. Ez az iterátor akar lenni? Iterátort azért használnak, hogy elrejtsék a tároló adatstruktúra sajátosságait. például ha tároló struktúra egy bináris fa, azt nem tudod tömbként visszaadni anélkül, hogy le ne másolnád az egész struktúrát, aminek nem sok értelme van. Ezért csinálnak iterátort.
-
modder
aktív tag
-
-
scream
veterán
válasz mgoogyi #2067 üzenetére
Van egy konkrét feladatom :
"Egy szöveges állományban tároljuk egy magasugró verseny eredményét. Az állomány minden sorában egy-egy versenyző adatait találjuk: a versenyző nevét (szóközök nélküli szöveg) és mellette azt, hogy az egyes próbáknál mekkorát ugrott. A versenyen egy versenyző 6-szor próbálkozhatott. Ha leverte a lécet, X a próba eredménye, ha kihagyta az adott magasságot, akkor O. Feltehetjük, hogy az állomány helyesen van kitöltve.
Listázza ki azoknak a nevét a konzolra, akiknek csak egy sikeres próbálkozása (150 cm-nél magasabb ugrása) volt, valamint adja meg a legjobb ugrást teljesítő sportoló nevét és összes eredményét! "Például az input fájl adatai:
Nagy_Bela 120 X O 125 130 X
Kiss_Agoston 140 145 X 150 155 X
Toth_Pal 135 O 140 145 X 155Namármost kell használnom szekvenciális inputfile-t, majd a két feladatra kell egy keresést meg egy max.kiv-t csinálnom, nem ?
Én úgy indultam neki, hogy egy struktúrában (7 string) vannak az adatok, a beolvasás is megvolt, az adatok a megfelelő helyen szerepelnek. Viszont innen most nem tudom hogyan induljak tovább, mert csak 1-szer lehet bejárni a meghívott file-t.
Intervallumos progtételek : ITT.
Nevezetes felsorolós progtéltelek : ITT[ Szerkesztve ]
-
WonderCSabo
félisten
Miért, elég egyszer is végigmenni a fájlhoz egy ilyen lekérdezéshez.
akiknek csak egy sikeres próbálkozása (150 cm-nél magasabb ugrása) volt
Megnézed, hogy az aktuális épp beolvasott embernek hány nagyobb ugrása volt, mint 150, ha 1, akkor kiírod a konzolra a nevét.valamint adja meg a legjobb ugrást teljesítő sportoló nevét és összes eredményét!
Sima max keresés az ugrás magassának függvényében, ezt tudod egy menetben az előző lekérdezéssel végezni. Temporális változóban tárolnod kell az éppen legjobb sportoló összes eredményét.Látható, hogy az egész cucchoz a memóriában két ember adatait (a struktáradat) kell tárolnod, egyrészt az éppen legjobbnak tartottat, másrészt az éppen beolvasottat, és egyszer végigolvasni a fájlt elég is.
[ Szerkesztve ]
-
Brumi˘
addikt
Üdv all!
Egy kis segitséget szeretnék kérni. Olyan feladatom van, hogy adott egy struktúra aminek 5 eleme van.
Ebből kellene kinyernem az egyik elem szerinti 10 legkissebbet, úgy hogy az eredeti struktúra sorrendje változatlan maradjon. (kezdő vagyok még a témába ) A segítséget előre is köszönöm. -
WonderCSabo
félisten
A következőt teheted:
1. lépésben kiválasztod a 10. legkisebb elemet valamelyik kiválasztó algoritmussal.
2. lépésben még egyszer végigiterálsz a listádon, és ha az aktuális elem kisebb vagy egyenlő a 10. legkisebb elemmel, akkor kiírod.Arra figyelj, hogy van a linken felsoroltak között van olyan algoritmus, ami megváltoztatja a listádat. Ha olyat használsz, akkor először másold le az egész listát, hogy az eredeti ne változzon.
Egy másik módszer lehet, hogy ha rendező algoritmust használsz, vagy elemeket rendezetten tároló segéd adatszerkezetet, de asszem egyszerűbb lesz számodra az előző megoldás.
[ Szerkesztve ]
-
modder
aktív tag
Hali,
Csinálsz egy 10 elemű segédtömböt, amibe a 10, tag1 attribútum szerinti legkisebb értéket fogod tárolni. Ez a segédtömb tag1 szerinti NÖVEKVŐ sorrendben fogja tartalmazni az Adatszerk típusú adatokat.
Végigiterálsz az eredeti tömbön, és minden egyes elemére megnézed, hogy a tag1 attribútuma kisebb-e, mint a legnagyobb tag1 attribútum a segédtömbödben. Ha igen, akkor az addigi 10 legkisebb közé be fog kerülni, err szolgál a pushMin() metódus.struct Adatszerk {
int tag1;
int tag2;
}
// legyen egy listád az adatszerkezettel
Adatszerk adatok[] = { Adatszerk(1,1), Adatszerk(1,2), ... }
int adatokSize = 50 // vagy akármennyi
Adatszerk[] legkisebb10 = Adatszerk[10];
initLegkisebb10( legkisebb10 ); // mindegyiket feltöltöd legalább akkora értékkel, amekkora maximum értéke lehet tag1-nek
for( int i = 0; i < adatokSize; i++ ){
if( adatok[i].tag1 < legkisebb10[9].tag1 ) {
pushMin( legkisebb10, adatok[i] );
}
}
// ezzel a függvénnyel növekvő sorrendbe szúrjuk be 'legkisebb10'-be a legkisebb tag1 attribútum szerinti
// adatokat
void pushMin( Adatszerk[] legkisebb10, Adatszerk adat ) {
int i = 0;
for ( i = 0; i < 10 ; i++ ) {
if ( adat.tag1 < legkisebb10[i].tag1 ) {
break;
}
}
// a legkisebb10 tömbben az i. helyen volt az elem, ami már nagyobb volt 'adat'-nál
// ezért oda tesszük be az 'adat'-ot, és a maradékot hátra toljuk a tömbben
// fontos, hogy a for-ciklus a tömb hátulja felől menjen i-ig
for( int k = 9 ; k > i ; k-- ) {
legkisebb10[k] = legkisebb10[k-1];
}
// i-edig helyre beszúrjuk az új 'adat'-ot
legkisebb[i] = adat;
}Amit WonderCSabo is említett, ha nem olyan nagy a listád, szóval lemásolhatod, akkor lehet, hogy egyszerűbb először rendezve lemásolni, majd az első 10-et kiírni
[ Szerkesztve ]
-
pvt.peter
őstag
mgoogyi: és modder köszönöm szépen a válaszaitokat, illetve a részletes példákat is.
Ez egy .50-es rombolópuska, elég szép visszarúgással.
-
pvt.peter
őstag
class A {
public:
void valami() { std::cout << "A"; }
virtual void virt() { std::cout << "A"; }
}
class B : A {
public:
void valami() { std::cout << "B; }
void virt() { std::cout << "B"; }
}És ha ezek helyett:
A b = new B();
b.valami();
B b = new B();
b.valami();ezek lennének:
A* b = new B();
b.valami();
B* b = new B();
b.valami();akkor is "A" illetve "B" íródna ki? Tehát nem befolyásolná az, hogyha heapen van létrehozva?
[ Szerkesztve ]
Ez egy .50-es rombolópuska, elég szép visszarúgással.
-
Karma
félisten
válasz pvt.peter #2074 üzenetére
Az első variáció nem fordulna le szerintem (a new operátor mindig pointert ad vissza). A második se az azonos nevű változók miatt, de ettől elvonatkoztatva az első hívás A, a második B kellene hogy legyen.
A tárolási mód nem befolyásol semmit.
“All nothings are not equal.”
-
modder
aktív tag
válasz pvt.peter #2074 üzenetére
Szia, Karmának igaza van mindkét esetben. A heap vagy stack nem befolyásol semmit a virtuális függvények terén, a new operátor pedig tényleg hibát dobna az első esetben. Javítva:
A b = B();
b.valami();
// most vonatkoztassunk el attól, hogy ugyanaz a változónév
B b = B();
b.valami()(már régen c++-tam)
-
mgoogyi
senior tag
"A b = B();"
Itt lehet van egy kis zavar az erőben, ugyanis ez a sor arra enged következtetni a 'b' változónévvel, hogy ez egy B típusú objektum lesz.
Holott ez a sor a következőt a jelenti:
A b ( B() );
Azaz hozz létre egy A típusú objektumot annak a copy konstruktorával, amely egy B objektumot kap paraméterként.
Ennek két lényeges aspektusa van.
Egyrészt a B() objektumból ledarálódik minden és A típusú objektum marad, merthogy a copy konstruktor érték szerinti A típusú bemenetet vár.
kb így néz ki és defaultból létrejön a copy constructor: A (A input)
Ez a ledarálás az ős irányába meg mindig implicit ( ~= láthatatlanul magától) megtörténik.Másrészt A típusú objektum fog létrejönni.
Másik dolog, hogy ez a kései virtuális kötés csak pointeren és referencián keresztül értelmezhető.
-
modder
aktív tag
válasz mgoogyi #2079 üzenetére
Hali,
Azt hiszem igazad van, a "A b = B();" tényleg az A copy konstruktorát fogja meghívni, tehát ez egy A objektum lesz. Akkor viszont pvt.péter felvetésére mégis csak jogos, hogy a dinamikus kötés csak pointeren keresztül lehetséges C++-ban. De nem a stack vs. heap miatt, hanem a pointer miatt.
Megnéztem az egyik régi házimat, ahol nem lehetett new operátort használni, és így oldottam meg:
Henger henger;
Asztal asztal;
Object* objects_[ MAX_OBJECTS ] = {&henger,&asztal};Ezt csak azért írom, mert a new operátort direkt el akartam kerülni az egész példámban, hogy látszódjon, anélkül is lehet dinamikus kötést alkalmazni.
Köszi a tisztázást!
-
chabeee
tag
sziasztok, operátor túlterhelést vettünk, de az indulásnál elakadtam.
// 1.: Irjal egy CSet osztalyt, amely int-eket tarolo halmaz. Az osztaly rendelkezzen egy egesz erteket varo
// konstruktorral, amely inicializalja a belso adatszerkezetet ugy, hogy az objektum annyi elemet tudjon tarolni,
// amennyi a parameter erteke. Ird meg a masolo konstruktort, es a destruktort is.// 2.: Terheld tul az << operatort ugy, hogy a segitsegevel uj elemeket lehessen belerakni a halmazba. Figyelj arra,
// hogy a halmazban minden elem legfeljebb egyszer fordulhat elo!
// {
// CSet a(60);
// a<<3<<4<<53<<3;
// }első az megvan, csak hogy értsétek mi a feladat azért másoltam be
-
modder
aktív tag
-
chabeee
tag
-
WonderCSabo
félisten
válasz chabeee #2083 üzenetére
Ehhez én annyit tennék hozzá, hogy gondolom azért térsz vissza az objektummal, mert szeretnéd, hogy láncolva lehessen hívni az operátort. Csak ez úgy nem fog működni, ha tagfüggvényként deklarálod.
Ha tagfényként deklarálod, például így:
class CS {
public:
CS& operator<<(int be);
};Akkor az valójában így fog "megjelenni" fordítás után:
CS & operator<<(int be, CS& cs);
Ezzel még működni fog ez a hívás:
cs << 2;
De ez már nem:
cs << 2 << 3;
Megoldás: ha szeretnéd, hogy láncolni lehessen, globális operátort kell definiálnod, így:
CS & operator<<(CS& cs, int be);
[ Szerkesztve ]
-
Zoli133
őstag
Sziasztok kellene egy kis segítség.
Van egy map típusú objektumom, eslő kulcsa string, második egy set ami szintén stringeket tartalmaz, valami ilyesmi:
map<string, set<string> ab;A kérdés az, hogy hogyan tudok iterátort csinálni ami végig megy adott stringhez tartozó halmaz elemein?
Köszönöm a választ."It's a fez. I wear a fez now. Fezzes are cool."
-
Jester01
veterán
válasz WonderCSabo #2084 üzenetére
Ez nem igaz
Kiválóan működik tagfüggvényként is, miért ne menne?Zoli133: mi okozza a problémát? Kiveszed a halmazt a map-ból, onnantól meg iterálhatsz rajta kedvedre.
const set<string>& s = ab["foo"];
for(set<string>::const_iterator it = s.begin(); it != s.end(); ++it) ...Jester
-
chabeee
tag
válasz WonderCSabo #2084 üzenetére
rendben, köszönöm
de igen, nekem is működik tagfüggvényként[ Szerkesztve ]
-
chabeee
tag
lenne még egy feladat.
van egy aru osztályom amiből származtattam elelmiszert és muszakicikket.
van egy raktár osztályom ahol árukat (élelmiszerekre és műszakicikkekre mutató pointereket tárolok)
A raktárban polcok vannak. tudjuk, hogy a raktárban hány darab polc van, és ismert az is, hogy egy polcon hány darab (minden polcon ugyanannyi) áru tárolható. Raktár osztályhoz van egy konstruktort amely paraméterként átveszi a raktárban tárolt polcok számát, illetve azt az értéket, hogy a polcokon egységesen maximum hány árú fér el.
kell egy addÁru függvény ami nálam így néz ki:bool raktar::addAru(aru* pt, int ppolc){
int i = 0;
while(i < max_aru && tomb[ppolc][i]){
i++;
}
if(max_aru > i){
tomb[ppolc][i] = pt;
return 1;
} else{
delete pt;
return 0;
}továbbá a main-ben így hívnám meg:
r1.addAru(new elelmiszer("Liszt", 540,2013,10,23),0); // a 0. polcra kerül
r1.addAru(new elelmiszer("Kenyer", 250,2012,11,17),0); // a 0. polcra kerül
r1.addAru(new muszakicikk("Hangfal", 12000,"Philips"),1); // az 1. polcra kerülmásoló konstruktor megvan, igaz lehet az a rossz, mai nap csináltam először 2 dimenziójú dinamikus tömböt:
raktar::raktar(int v1, int v2) : tomb(0), sz(0), polc(v1), max_aru(v2){}
raktar::raktar(const raktar & a){
tomb = new aru**[polc];
for(int i = 0; i < polc; i++){
tomb[i] = new aru*[max_aru];
}
for(int i = 0; i < polc; i++){
for(int j = 0; j < max_negy_aru; j++){
tomb[i][j] = a.tomb[i][j];
}
}
sz = a.sz;
polc = a.polc;
max_aru = a.max_aru;
}hiba: memória hiba miatt elszáll, valaki ötlet?
[ Szerkesztve ]
-
Jester01
veterán
-
WonderCSabo
félisten
válasz Jester01 #2086 üzenetére
Bocs, teljesen hülye vagyok, összekevertem a másik iránnyal, általában kiíró operátort szoktam írni, elnézést kérek, nem figyeltem.
#include <string>
#include <iostream>
class c {
public:
// std::ostream& operator<<(std::ostream& os) { // ez nem megy
// return os;
// }
};
std::ostream& operator<<(std::ostream& os, c& a) {
return os;
}
int main() {
c a;
std::cout << a;
return 0;
} -
chabeee
tag
válasz WonderCSabo #2092 üzenetére
ezt én így tanultam/csináltam:
class Vector {
double * elemek;
int mennyi;
public:
friend ostream & operator<<(ostream & os,
const Vector & v) {
for (int i = 0; i < v.mennyi; i++)
os<<v.elemek[i]<<" ";
return os;
}
};[ Szerkesztve ]
-
-
Dave-11
tag
Néztem egy videót, amiben a srác létrehoz egy tömböt a dinamikus memóriában úgy, hogy a felhasználó adja meg a méretét:
cin >> size;
int * array = new int[size];
Aztán bejárja ezt a töböt egy for ciklussal, de egy valamit nem értek.
for(int i=0; i<size; i++)
{
array[i] = 7*(i+1);
}
A ciklusmagon belül az array elé miért nem kell a * operátor?
*array[i] = 7*(i+1); // miért nem így?[ Szerkesztve ]
:D Semmi :D
Ú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!
- Asus ROG Strix G513IE laptop / RTX3050Ti GPU / 144Hz / Ryzen 7 4800H / 1tb SSD /16gb RAM 3200MHz
- 27" Eizo Flexscan EV2780 IPS LED Használt monitor 2év garancia MONITORCENTER
- HP Victus 16 - 16.1" FHD IPS 144Hz / i5-12500H / 16Gb DDR5 / 1Tb PCIe 4.0 / RTX 3050 Ti / HUN
- Lenovo S3 Yoga 14 i3-5010 4Gb ram 180Gb SSD FHD érintő, számlával, garanciával
- ZBook 17 G6 17.3" FHD IPS Xeon E-2286M RTX 3000 32GB 512GB NVMe DVD író gar
Állásajánlatok
Cég: Ozeki Kft.
Város: Debrecen
Cég: Promenade Publishing House Kft.
Város: Budapest