ich hantiere gerade mit mehreren größeren Arrays herum und der Arbeitsspeicher wird knapp. Daher mal eine grundsätzliche Frage:

Welchen Speicherplatz benötigt ein bool-Array?
Spare ich hier Speicher gegenüber einem char-array?

In Büchern &Co. werden für alle Datentypen die benötigten Bits beschrieben nur eben nie für bool.

Der Horst

Eine Variable vom Typ bool braucht ein Byte!

lg, freakC++

Hallo zusammen,

ich hantiere gerade mit mehreren größeren Arrays herum und der Arbeitsspeicher wird knapp. Daher mal eine grundsätzliche Frage:

Welchen Speicherplatz benötigt ein bool-Array?
Spare ich hier Speicher gegenüber einem char-array?

In Büchern &Co. werden für alle Datentypen die benötigten Bits beschrieben nur eben nie für bool.

Der Horst

Wieviel bool braucht, ist plattformabhängig.
std::cout << sizeof(bool) << '\n'; sagt Dir mehr.

Vielen Dank für die Hilfe und die vector<bool> = 1byte->1bit "Zauberei"
Das wir ne Menge Platz schaffen

Der Horst

Ja, der Arbeitsspeicher wird leider wirklich knapp.
(so lange ich noch auf 32 bit tippe)

Vielen Dank für die Hilfe und die vector<bool> = 1byte->1bit "Zauberei"
Das wir ne Menge Platz schaffen

Der Horst

Gibt auch noch std::bitset falls du das nicht schon kennst.

#include <bitset>
...
const int N=1;
vector <bitset<N>> A;
...

einen Vektor deklarieren, dessen Elemente nur ein bit groß sind?

als könnte ich mit mit:

#include <bitset>
...
const int N=1;
vector <bitset<N>> A;
...

einen Vektor deklarieren, dessen Elemente nur ein bit groß sind?

Dein, mit std::bitset<24> set legst Du ein Bitset an, welches 24 Bits hält.
Leider lässt sich das Bitset während der Laufzeit nicht dynamisch erweitern.

Danke nochmal an alle!

DerHorst

als könnte ich mit mit:

#include <bitset>
...
const int N=1;
vector <bitset<N>> A;
...

einen Vektor deklarieren, dessen Elemente nur ein bit groß sind?

Unfug.
vector<bool> braucht für 100 bools erstmal 12.5 bytes, nee, 13 natürlich, muß ja aufrunden, und natürlich 32 bytes, das ist ja die allocation granularity. und dazu noch mindestens 16 bytes für das mutterobjekt.
kein gedanke daran, daß EIN EINZIGER bool NUR EIN BIT braucht.
aber 1000000000 bools brauchen halt nur 125000000 Bytes, evtl auf den nächsten 32-er gehen wegen granularity und internen heapzeigern, 125000032 bytes, noch großzügig 32 bytes für den vector, 125000064 bytes, macht 1,000000512 bit pro bool.
bitset hat nicht so <ironie>wahnsinnig viel overhead von dutzenden von bytes</ironie>. aber ist dafür nicht so klug wie ein vector und weiß nichst von dynamischen größen.

Für diese Untersuchungen brauche ich halt verschiedene Arrays (gleichzeitig), um pixelbezogene Ereignisse abzufragen.
Jedenfalls ist mir noch nichts gescheiteres (als ein weiteres Array in Bilddimensionen) eingefallen, um ein pixelbezogenes Ereignis zu speichern.

DerHorst

Es geht um sehr große arrays (Bilder), die ich auf vielfältige Weise untersuchen will.
Die Quelldaten sind etwa (400MB) groß und ich muss mehrere gleichzeitig verarbeiten (mindestens 2, besser mehr).

Für diese Untersuchungen brauche ich halt verschiedene Arrays (gleichzeitig), um pixelbezogene Ereignisse abzufragen.
Jedenfalls ist mir noch nichts gescheiteres (als ein weiteres Array in Bilddimensionen) eingefallen, um ein pixelbezogenes Ereignis zu speichern.

DerHorst

Vielleicht geht es ja auch mit blockweiser Verarbeitung. Also immer einen Block Daten einlesen, diesen verarbeiten, und ihn dann wieder hinausschreiben.

Aber mal schauen. Evtl. muss ich es halt stückeln.

Das wollte ich vermeiden.

Das ist aber bei größen Datenmengen der optimale Ansatz.

Das wollte ich vermeiden.
Aber mal schauen. Evtl. muss ich es halt stückeln.

Ich wollte mal mit dem Sieb des Eratosthenes viele Primzahlen ausrechnen. Ich habe auch sowas gepacktes wie vector<bool> genommen. Und ich habe gestückelt. Stückeln ist natürlich doof, weil ich für jedes neue Stück wieder alle Streichzahlen von 2 bis ... durchlaufen mußte. Also lautete die Devise: "So wenig Stücke wie möglich". War aber ganz falsch. Lustigerweise war das Programm am schnellsten, wenn ein Stück in den Cache gepaßt hat, also was minikleines wie 64k. Also obwohl dadurch viel mehr Operationen ausgeführt werden mußten, hat einfach die Schnelligkeit des Caches am Ende die ganzen Performanceüberlegungen dominiert. Da wünsch ich Dir mal viel Glück, daß Deine Berechnungen auch gut stückelbar sind.

und los ...

Für diese Untersuchungen brauche ich halt verschiedene Arrays (gleichzeitig), um pixelbezogene Ereignisse abzufragen.
Jedenfalls ist mir noch nichts gescheiteres (als ein weiteres Array in Bilddimensionen) eingefallen, um ein pixelbezogenes Ereignis zu speichern.

DerHorst

Vielleicht könntest du ein Array einer Bitfield-Struct verwenden um Platz zu sparen (statt mehrere bool Arrays):

struct PixelProperties
{
    unsigned char isX : 1;
    unsigned char isY : 1;
    unsigned char fooType : 2;
    unsigned char barType : 2;
};
std::vector<PixelProperties> pixelProps;

Würden den Lookup vermutlich unglaublich beschleunigen.

was ich nicht verstehe/kenne ist die Struktur deiner Struktue. Genauer gefragt,
was macht:

unsigned char isX : 1;        //is = 1bit groß?
unsigned char fooType : 2;    //fooType = 2bit groß?

Idee:
Du "baust" eine Struktur mit 4 u-char-Elementen auf, von denen 2 1-Bit und 2 2-Bit groß sind?

http://msdn.microsoft.com/en-us/library/ewwyfdbe(VS.71).aspx

Die Zahl hinter dem : gibt an wieviel Bits man braucht, wie du schon richtig vermutet hast.

Du "baust" eine Struktur mit 4 u-char-Elementen auf, von denen 2 1-Bit und 2 2-Bit groß sind?

Ja.
Die von mir gezeigte Struktur sollte insgesamt aber nur 1 Byte gross sein, da die 4 u-char Elemente zu einem einzigen u-char zusammengefasst werden.

Danke für den Tip - und den Link.
Interessante Sache das

DerHorst