Miért nem tudok egy tömbbe n darab adatot beolvasni?

#7

leginkább azért, mert semmi okunk explicit módon heapet használni?

szinte biztos vagyok, hogy nem lesz olyan mintabemenet, ami stackoverflow-t eredményezne, és onnantól meg csak egy felesleges túlbonyolítás ami természetéből adódóan veszélyes.

ha már heapet akarunk mindenképpen használni, akkor már inkább legyen egy std::vector vagy std::unique_ptr tömb.

de ez a post bennem nagyon ilyen kezdő, érettségi szerű algoritmizálós érzést kelt, és ezen a szinten tök felesleges szegény kérdezőt dinamikus memóriakezeléssel összezavarni.

#5 és 11

végülis igazad van, rossz szokásom. C-ből jövök, azért nem ismerem annyira az STL megoldásait (a vectort igen, a többit kevésbé)

Mikrokontrolleren dolgozok, azon meg van pár száz bájt stack, bár mondjuk a dinamikus memória is eléggé tiltott kategória (bár van determinisztikus megoldás rá). Emiatt ódzkodok a stack-es nagy tömböktől :D

De egyébként igen, éppen érettségi jellegű feladat szintnek tippelem én is, ezért gondoltam a new és delete megoldást, mert sok helyen elvárás házi feladatban és hasonlókban a dinamikus memória használata, hogy szokja/tanulja a diák, nyilván viszont egyszerű példán, amikre a valóságban nem használnánk ilyet.

Amúgy ha nem dinamikus memóriánál maradunk, én még mindig jobban preferálom, ha statikus modulszintű tömbbe vesszük fel, vagyis a forrásfájlban mindenen kívül static int[]. Ekkor nem a stacket veszi el, fordítási időben létrehozza, és korlátlan méretet foglalhatunk kb gond nélkül, mert belefordítja, akarom mondani előre lefoglalja a helyet a memóriában :)

Azért remélem nem mondtam nagyon hülyeségeket, nyitott vagyok az érvekkel alátámasztott vitákra, és én is szeretek újakat tanulni, vagy rájönni hibáimra.

Jó hát igen, mindenki a környezete rabja.

Igazából én, mint mondtam, a természetéből adódóan nem szeretek c++on belül nyers pointerekkel dolgozni. Főleg egy nagyobb, keszekuszább projektben könnyű figyelmetlennek lenni, és memory leakbe futni.

Ugye a modern STL-nek már nagyon sok olyan feature-je van (kiemelném a smart pointereket: unique_-/shared_-/weak_ptr) ami biztonságosabbá teszi a dinamikus memóriakezelést.

Ezek a feature-ök (vektortól és más adatszerkezetektől az okospointerekig) gyakorlatilag egyfajta primitív garbage collectiont oldanak meg (poniter köré épült wrapper classok) ahol a destruktor amutomatikusan elvégzi a heap felszabadítását amikor kell.

Sőt, van egy olyan programozási irányelv is a modern c++ban, hogy az ilyen wrapper classok megvalósításán felül nem szabad leírni a new és delete kulcsszavakat (ennek több oka is van), ezért léteznek olyan függvények, mint a std::make_unique.

Szerintem nagyon érdekes téma a modern c++ memóriakezelése, érdemes utána nézni:)