#include <iostream>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

int main() {
  ifstream ifs("datei.txt");

  if (!ifs)
    return 1;

  vector<unsigned char> vec;
  char chr;

  while (ifs.good()) {  
    ifs.get(chr);
    vec.push_back(chr);
  }
        ShowMessage("size:"+IntToStr(vec.size()));
        ShowMessage("capacity:"+IntToStr(vec.capacity()));

  ifs.close();
  return 0;
}

Die Datei ist jetzt Original 209 KB (214.200 Bytes) (nicht Speicher auf HDD!!)
size() sagt: 154299
capacity() sagt: 262144

*nix peil*

1. Warum sind die Werte unterschiedlich
2. Warum stimmen die Werte nicht mit den zu lesenden Bytes überein.

Eigentlich wollte ich statt

handle=_open("datei.txt",_O_RDONLY);
if (!handle) return;
unsigned char array = (unsigned char*) malloc(filesize+1);
_read(handle,&array[0],filesize);
_close(handle);

das mit vectoren lösen, aber da passiert ja nur Quatsch

Etwas grundlegendes vergessen?

capacity Returns the largest possible size of the vector.

Warum willst du überhaupt einen Vector nehmen? Ich halt das für Unsinn... :-S

grüße

capacity Returns the largest possible size of the vector.

Das war wohl die Antwort auf die Frage: Was macht max_size(), oder?
size() liefert die Anzahl der gespeicherten Elemente,
capacity() die Anzahl von Elementen, die ohne Größenänderung des Vectors (also Speicherallokierung) gespeichert werden können. Drum ist size immer <= capacity.

Ich weiss nicht was du mit den eingelesenen Daten sonst noch so vorhast, aber im zweiten Punkt muss ich David_pb recht geben ...

grüße

vector muss keine schlechte wahl für diesen zweck sein, tatsächlich ist es sogar eine sehr gute wahl, allerdings nicht mit der obigen methode :p
wenn du mit der C methode filesize bereits kennst, diese information im C++ dem vector aber vorenthälst, musst du dich über merkwürdigkeiten nicht wundern

@Sepp Brannigan:
Danke für den Hinweis, du hast natürlich recht. Ich bin da wohl in der Zeile verrutscht!

grüße

C Version

unsigned char *variable = (unsigned char*) malloc(filesize+1);
read(handle,&variable[0],filesize);
free (variable);

C++ mit new

unsigned char *variable = new unsigned char(filesize+1);
read(handle,&variable[0],filesize);
delete[] variable;

Ergebnis: Crash in read()

C++ mit auto_ptr

auto_ptr<unsigned char> variable( new unsigned char(filesize) );
read(handle,&variable[0],filesize);

Ergebnis: Binaerer Operator '[' : 'class std::auto_ptr<unsigned char>' definiert diesen Operator oder eine Konvertierung in einen für den vordefinierten Operator geeigneten Typ nicht

Ich wüsste jetzt natürlich gerne warum new und auto_ptr nicht funktionieren

C++ mit new

unsigned char *variable = new unsigned char(filesize+1);
read(handle,&variable[0],filesize);
delete[] variable;

Ergebnis: Crash in read()

...

Ich wüsste jetzt natürlich gerne warum new und auto_ptr nicht funktionieren

Deine new-Version erzeugt EIN char mit dem Wert '(filesize+1)%256', um ein Array von chars anzulegen, benötigst du eckige Klammern:

unsigned char* variable = new unsigned char[filesize+1];

(und auto_ptr ist sowieso nur für Solo-Objekte vorgesehen - schau dir doch mal Boost's scoped_array an)

Ich habe mir mal boost_1_33_1 raufgehauen.

#include "boost/scoped_ptr.hpp" 
using namespace boost;

scoped_ptr<unsigned char> variable(new unsigned char[filesize+1]); 
read(handle,&variable[0],filesize);

Ergebnis: Binaerer Operator '[' : 'class boost::scoped_ptr<unsigned char>' definiert diesen Operator oder eine Konvertierung in einen für den vordefinierten Operator geeigneten Typ nicht

Ich will die variable in einer Klasse definieren.
Als new würde man das so machen

class bla
{
private:
unsigned char *variable;
}

bla:bla()
{
long filesize = ......
variable = new unsigned char[filesize+1];
}

Wie müsste das bei scoped_array() ausschauen? Ich bekomme es absolut nicht hin zu teilen *zu blöd dafür bin*

class test
{
public:
  test(int fsize) : filsize(fsize), filedata(new unsigned char[fsize+1]
  {
    ...
  }
private:
  int filesize;
  scoped_array<unsigned char> filedata;
  //bei näherem Überlegen: hier wäre ein shared_array wohl hilfreicher
};

Anders gefragt... dieser Zweizeiler:

unsigned char *variable;
variable = new unsigned char[filesize+1];

müsste bitte wie für scoped_array aussschauen?

scoped_array<unsigned char> variable;
variable(new unsigned char[filesize+1]);

Hier meckert er ja das es keine Funktion ist.
Und warum sollte shared_array besser geeignet sein?

scoped_array<char> var(new char[size+1];

(und shared_arrays haben den Vorteil, daß sie Referenzzählung und Kopier-Operationen unterstützen)

PS: Im Magazin gibt es übrigens einen Artikel über die ganzen Boost-Smartpointer - den solltest du dir mal durchlesen