3. Problem bei Dynamischer Speicherverwaltung

Problem bei Dynamischer Speicherverwaltung

  • ?

    Hallo wie kann ich die Variable char *var; auf die größe von der Variable size setzen ?

    Also size gibt z.b. 20 aus dann soll char *var; auch 20 Byte reservieren.
    Aber ich weiss nicht mehr wie das geht.

    cout<<sizeof(var)<<endl; // gibt immer 4 aus int = 4 Byte.

    #include <windows>
#include <iostream>
using namespace std;

int main()
{

HANDLE file_handle;
DWORD nbt = 0;
int ret =0;

int size;
char *var="0";

file_handle =   CreateFile  ( "datei.txt", GENERIC_READ , FILE_SHARE_READ , 0,  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 );
size = GetFileSize ( file_handle , 0 );

var = new char [ size ];

cout<< size <<endl;
cout<<sizeof(var)<<endl;

delete [] var;

system("PAUSE");
}
    0
  • Mod

    char* schrieb:

    Hallo wie kann ich die Variable char *var; auf die größe von der Variable size setzen ?

    Also size gibt z.b. 20 aus dann soll char *var; auch 20 Byte reservieren.
    Aber ich weiss nicht mehr wie das geht.

    Dein Code macht schon das was du willst.

    cout<<sizeof(var)<<endl; // gibt immer 4 aus int = 4 Byte.

    Und? var ist ja auch ein Zeiger auf deine 20 Byte, warum solltest du bei sizeof(var) etwas anderes bekommen als die Größe eines Zeigers?

    ⚠ Und jetzt erklärst du noch, warum du dafür weder einen vector noch einen string benutzt. Und diese Erklärung sollte verdammt gut sein. ⚠

    0
  • ?

    Hallo, soweit ich weiß, wird sizeof() zur Compilerzeit ermittelt und nicht zur Laufzeit! Somit kann sizeof() bei dynamisch allozierten Arrays nicht richtig rechnen.

    0
  • ?

    sizeof wird zur Compilezeit ausgewertet und ist konstant. Mit sizeof(var) kriegst du hier die Größe des Zeigers - bei dir 4 Byte - nicht die Größe des Speicherbereichs, auf den dieser zeigt. Diesen wirst du dir an anderer Stelle merken müssen (etwa in size).

    Alternativ könntest du natürlich std::vector oder std::string benutzen, beide haben eine .size()-Methode:

    #include <string>

// ...

std::string var = "0";
assert(var.size() == 1);
    0
  • N

    Das passt schon so. Der Wert von sizeof ist die Größe des Zeigers. Die Elemente-Anzahl musst du dir selber merken. Abhilfe schafft ein std::vector, der kennt immer seine Größe.

    0
  • ?

    Ich hab kein string oder vector genommen weil ich wissen wollte wie das ganze mit char* funktioniert. (=

    Aber danke für die Antworten.

    0
  • V

    Wenn du einen char* bzw. vector<char> verwendest und diesen direkt ausgeben lassen möchtest, sollte er nullterminiert sein.

    var = new char [ size +1 ]; 
// aus Datei einlesen
var[size] = 0;

cout << var << endl;
    0
  • N

    char* schrieb:

    Ich hab kein string oder vector genommen weil ich wissen wollte wie das ganze mit char* funktioniert. (=

    Aber danke für die Antworten.

    Okay, dann kurz die Unterschiede:

    size_t size = 20; // Groeße festlegen
// ab hier weiter mit char *
char * feld = new char[size];
char element = feld[pos];
char * pelement = &feld[pos];
// wie groß war nochmal feld?
size;
delete [] feld;
// und hier mit vector
std::vector<char> feld(size);
char element = feld[pos];
char * pelement = &feld[pos];
// wie groß war nochmal feld?
feld.size();
// feld löschen? unnötig Destructor wird automatisch gerufen, wenn das Objekt den Gültigkeitsbereich verlässt

    Wie man erkennen kann liegt der Unterschied darin, dass ich kein delete[] vergessen kann und mir nicht die Größe merken brauch.
    Ein weiterer Vorteil tritt auf, wenn du mehr Platz benötigst. Dann erledigt der vector das umkopieren automatisch.

    0
Anmelden zum Antworten