Also

....bla bla Eingabe wieder gespeichert in iAnzahl

Und dann:
int my_array[iAnzahl];

Doch beim Compilieren meckert.
Er erwartet nen Konstanten Wert.
Aber wie erzeuge ich nen Array anhand von ner Eingabe

std::size_t n;
std::cin >> n;
int* array = new int[n]; // Speicher zur Laufzeit anfordern
array[0] = 23;
array[1] = 11;
delete [] array; // löschen

Bitte ein Buch benutzen und untensiv durcharbeiten, das Thema ist sehr wichtig (bzw. verlagere es nach hinten, falls du noch nicht so weit bist).

Mit dem Heap:

std::size_t n;
std::cin >> n;
int* array = new int[n]; // Speicher zur Laufzeit anfordern
array[0] = 23;
array[1] = 11;
delete [] array; // löschen

Bitte ein Buch benutzen und untensiv durcharbeiten, das Thema ist sehr wichtig (bzw. verlagere es nach hinten, falls du noch nicht so weit bist).

Ok danke.
Aber wenn ich es lösche, dann sind meine Werte weg, richtig?
Muss ich denn - wenn ich z.B. mit den Werten weiterarbeiten möchte - sie nochmal extra in eine Variabel speichern?

Du kannst auch malloc benützen!

(nicht getestet:)

typedef struct _mem_float{
private:
float *_ptr;
size_t _size;
public:
_mem_float() {_ptr=0;};
_mem_float(int i) {size=i*sizeof(float); _ptr=(float*)malloc(size); };
~_mem_float(){ free(_ptr);};
_mem_float &operator=(const _mem_float&__cpy)
{
  if(this==&__cpy) return *this;
  if(_ptr) free(_ptr);
  size=__cpy.size;
  _ptr=(float*)malloc(size);
  memcpy((void*)_ptr,(void*)__cpy._ptr,size);
 return *this;
}
float &operator[](const int &i){ return (*(_ptr+i*sizeof(float)));};
}MEMFLOAT;

malloc alloziert den benötigten speicher, der operator [] gibt dir die referenz auf das float an position i, welches du dann beschreiben und lesen kannst.

new benutze ich meist nur, wenn ich ein object im Speicher erstellen will, bei dem der ctor gleich mit aufgerufen wird, ansonsten versuche ich immer auf ein alloc (winapi Global/Local/HeapAlloc) auszuweichen.

grüüße

Die Schleife klappt einwandfrei.
Aber sobald er ins Delete geht, kommt ne Error-Meldung:

Heap Corruption detected: after normal block #178 at 0x004....

CRT detectet that the application wrote to memor after end of heap buffer

new benutze ich meist nur, wenn ich ein object im Speicher erstellen will, bei dem der ctor gleich mit aufgerufen wird, ansonsten versuche ich immer auf ein alloc (winapi Global/Local/HeapAlloc) auszuweichen.

Die Funktion, die den rohen Speicher besorgt, den new verwendet, versteckt sich hier:

_mem_float(int i) {size=i*sizeof(float); _ptr=(float*)operator new(size); };

Vielleicht könnte die auch Dein Freund werden.

for (i=1; i!=iAnzahl; i++){

zeusosc schrieb:

new benutze ich meist nur, wenn ich ein object im Speicher erstellen will, bei dem der ctor gleich
mit aufgerufen wird, ansonsten versuche ich immer auf ein alloc (winapi Global/Local/HeapAlloc) auszuweichen.

Warum? new sollte gelegentlich schneller sein.

Die Funktion, die den rohen Speicher besorgt, den new verwendet, versteckt sich hier:

_mem_float(int i) {size=i*sizeof(float); _ptr=(float*)operator new(size); };

Um die Geschwindigkeit, welche sich nur durch den zusätzlichen call ctor's von
malloc unterscheidet, geht es mir nicht. Bei meinen anfängen des copy ctor
proggen habe ich zahlreiche run-time excepions mit new /delete mitgenommen,
vlt. auch durch meine dusseligkeit, dass ich mir die nutzung von new/delete
einfach abgewöhnt habe und dementsprechend mir lieber den speicher nativ hole.

Das ich dass so mache heißt ja nicht zwangsläufig, dass ich der Meinung bin,
dass alle diesen Weg nutzen sollen .
Prinzipiell wollte ich hier dem Kloas nur eine alternative
zu new anbieten, die mit Basistypen wunderbar klappt und auch
nahebringt wie der Speicher eigentlich verwendet wird/(werden kann).

Sei gegrüßt Volkard

typedef struct _mem_float{   // typedef struct brauchts in C++ nicht.
private:       // Nimm gleich class und du lannst dir das private sparen ;)
float *_ptr;
size_t _size;
public:
_mem_float() {_ptr=0;};
_mem_float(int i) {size=i*sizeof(float); _ptr=(float*)malloc(size); };
~_mem_float(){ free(_ptr);};
_mem_float &operator=(const _mem_float&__cpy)   // Zwei führende Unterstriche sollte man doch nicht verwenden, weil reserviert für Compiler, oder?
{
  if(this==&__cpy) return *this;
  if(_ptr) free(_ptr);        // geht free(0) schief? Mit delete kann man sich den Test auf NULL sparen.
  size=__cpy.size;
  _ptr=(float*)malloc(size);   // AFAIK soll man doch den return von malloc nicht casten.
  memcpy((void*)_ptr,(void*)__cpy._ptr,size);
 return *this;
}
float &operator[](const int &i){ // das const int& i bringt gar nix an Performance,
// da int zu kopieren genauso schnell ist wie ne Adresse zu übergeben.
    return (*(_ptr+i*sizeof(float)));};
}MEMFLOAT;

Mir ist klar dass das Beispiel dafür gedacht war, das malloc zu zeigen.

angenommen ich vergesse das array zu deleten, wird der speicher denn automatisch bei programmende gelöscht?

Nein, zumindest nicht durch dein Programm. Viele Betriebssysteme holen sich aber alle Ressourcen zurück, wenn ein Programm beendet wird, egal ob freigegeben oder nicht.

Man sollte immer alles was man mit new holt, wieder mit delete freigeben. Oder besser noch seine Klassen so anlegen, dass dies automatisch im Destruktor passiert. Oder einen der STL-Container benutzen, denn diese machen das schon automatisch.

float &operator[](const int &i){ // das const int& i bringt gar nix an Performance,
// da int zu kopieren genauso schnell ist wie ne Adresse zu übergeben.

Ja, dass ist richtig. Bei überladung anderer Operatoren wird aber nicht unbedingt auf ein int referenziert. Daher dient das quasi nur der Kontinuität.

Selbst LocalAlloc/GlobalAlloc/HeapAlloc sind zu casten.

Delete überprüft meines wissens nach den gepointed Speicher auf NULL (oder halt die konsistenz des stacks nach einen initialisierten typ, was wohl net immer klappt wenn es kein basistyp ist,...

Was mich interessiert ist: //typendefinitionen typedef struct in c++ brauchts net
Meines wissens ist es ein unterschied mir eine structurvariable zu deklarieren oder einen global typ in form einer structur die ich beliebig initialisieren kann ?!

Seit gegrüßt

Bilden Sie ein Array von 10 nullterminierten Strings! Speichern Sie mit Pointerarithmetik in jedem der Arrayelemente einen automatisch erzeugten Zufallstext mit einer Länge von mindestens 5 und maximal 30 Buchstaben! Der Text beginnt in jedem Element mit einem Großbuchstaben enthält dann ausschließlich Kleinbuchstaben!

kann jemand mir bisschen erklären und auch vllt die Lösungen vorschlagen

kann jemand mir mal weiter helfen, ich stecke gerade fest:

Bilden Sie ein Array von 10 nullterminierten Strings! Speichern Sie mit Pointerarithmetik in jedem der Arrayelemente einen automatisch erzeugten Zufallstext mit einer Länge von mindestens 5 und maximal 30 Buchstaben! Der Text beginnt in jedem Element mit einem Großbuchstaben enthält dann ausschließlich Kleinbuchstaben!

kann jemand mir bisschen erklären und auch vllt die Lösungen vorschlagen

1. Was hat das mit diesem Thread zu tun? Fang lieber ein neues Thema an.
2. Bevor du das neue Thema anfängst, lies dir unbedingt diesen Thread gründlich durch. Denn mit einer Frage wie du sie da oben stellst, wirst du keine ernstgemeinten Antworten bekommen.