unsigned char c;
unsigned int pC;
--> pC ist in wirklichkeit ein Array, das die Farbwerte enthält

Wie kann ich mit c den letzten Byte von pC überschreiben?

und wie kann ich c wieder auslesen?

Byte:
7 6 5 4 3 2 1 0
---------------
              |
              c

#include <iostream>

int main(int argc, char *argv[])
{
    unsigned int Zahl = 123;
    unsigned char Byte = 2;
    *(reinterpret_cast<unsigned char*>(&Zahl) + 3) = Byte; // hier der vierte byte
    // das ganze dann so gezählz, dass 0 der byte ist, der bei dir 7 ist.
    std::cout << Zahl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

mfg.

Und wie bekomme ich meinen char Wert wieder heraus?

Hallo,
Ich verstehe nicht ganz, warum man hier einen reinterpret_cast<>() verwendet... Geht doch viel einfacher und schöner mit einfachen Bitmanipulationen.

Beispiel:

unsigned int i = 512; // bitmuster: 00000000 00000000 00000010 00000000
unsigned char c = 16; // bitmuster: 00010000

// Letztes Byte eines Ints mit den Bits eines Char-Werts überschreiben.
unsigned int out = i | c; // out enthält den Wert 528, denn bitmuster: 00000000 00000000 00000010 00010000

// Letztes Byte aus dem Int wieder herstellen:
unsigned int out = i & 0xFF; // out enthält den Wert 16, denn bitmuster: 00010000

Gruß Caipi

Tc++H schrieb:

Und wie bekomme ich meinen char Wert wieder heraus?

Hallo,
Ich verstehe nicht ganz, warum man hier einen reinterpret_cast<>() verwendet... Geht doch viel einfacher und schöner mit einfachen Bitmanipulationen.

Beispiel:

unsigned int i = 512; // bitmuster: 00000000 00000000 00000010 00000000
unsigned char c = 16; // bitmuster: 00010000

// Letztes Byte eines Ints mit den Bits eines Char-Werts überschreiben.
unsigned int out = i | c; // out enthält den Wert 528, denn bitmuster: 00000000 00000000 00000010 00010000

// Letztes Byte aus dem Int wieder herstellen:
unsigned int out = i & 0xFF; // out enthält den Wert 16, denn bitmuster: 00010000

Gruß Caipi

Aber das geht ja jetzt nur für den letzten Byte, oder?

#pragma  pack(1)
struct BMFH // BitmapFileHeader
{
	char         bmtype[2];     // 2 bytes - 'B' 'M'
	unsigned int iFileSize;     // 4 bytes
	short int    reserved1;     // 2 bytes
	short int    reserved2;     // 2 bytes
	unsigned int iOffsetBits;   // 4 bytes

};
#pragma pack()

#pragma pack(1)
struct BMIF // BitmapInfoHeader
{
	unsigned int iSizeHeader;    // 4 bytes - 40
	unsigned int iWidth;         // 4 bytes
	unsigned int iHeight;        // 4 bytes
	short int    iPlanes;        // 2 bytes
	short int    iBitCount;      // 2 bytes
	unsigned int Compression;    // 4 bytes
	unsigned int iSizeImage;     // 4 bytes
	unsigned int iXPelsPerMeter; // 4 bytes
	unsigned int iYPelsPerMeter; // 4 bytes
	unsigned int iClrUsed;       // 4 bytes
	unsigned int iClrImportant;  // 4 bytes
};// End of stBMIF structure - size 40 bytes
#pragma pack()

struct Image
{
	unsigned int iWidth;
	unsigned int iHeight;
	unsigned int* pARGB; // Alpha Red Green Blue
};

...
std::basic_fstream<char> in("test1.bmp", std::ios_base::in | std::ios_base::binary);
if(!in)
return -1;

BMFH bMFH;
BMIF bMIF;

in.read((char*) &bMFH, sizeof(BMFH));
in.read((char*) &bMIF, sizeof(BMIF));

Image img;
img.iWidth  = bMIF.iWidth;
img.iHeight = bMIF.iHeight;
img.pARGB	= new(unsigned int[img.iWidth * img.iHeight]);

int iNumPaddedBytes = (img.iWidth * 3) % 4;

in.seekp(bMFH.iOffsetBits);
for(unsigned int h = 0; h < img.iHeight; h ++)
{
	for(unsigned int w = 0; w < img.iWidth; w ++)
	{
		unsigned char r, g, b;

		in.read((char*) &b, sizeof(char));
		in.read((char*) &g, sizeof(char));
		in.read((char*) &r, sizeof(char));

		img.pARGB[w + h * img.iWidth] = (r << 16 | g << 8 | b);
	}

	if(iNumPaddedBytes != 0)
	{
		unsigned char skip[4];
		in.read((char*) &skip, sizeof(skip));
	}
}

//////////////////////////////////////////////////////////////////////////////
// Speichern
std::basic_fstream<char> out("test3.bmp", std::ios_base::out | std::ios_base::binary);
out.write((char*) &bMFH, sizeof(BMFH));
out.write((char*) &bMIF, sizeof(BMIF));

unsigned char r, g, b;
for(unsigned int h = 0; h < img.iHeight; h ++)
{
	for(unsigned int w = 0; w < img.iWidth; w ++)
	{
		r  = img.pARGB[w + h * img.iWidth] = GetRValue(img.pARGB[w + h * img.iWidth]);
		g  = img.pARGB[w + h * img.iWidth] = GetGValue(img.pARGB[w + h * img.iWidth]);
		b  = img.pARGB[w + h * img.iWidth] = GetBValue(img.pARGB[w + h * img.iWidth]);

		out.write((char*) &r, sizeof(char));
		out.write((char*) &g, sizeof(char));
		out.write((char*) &b, sizeof(char));

	}
}

delete[](img.pARGB);
...

Kann mir jemand helfen, wie man eine Bitmap speichert?? und acu effizient lädt?

Jo, ich hab gerade im anderem Beitrag beim WinAPI Forum geantwortet.

mfg.

int main()
{
	unsigned int i = 512;
	unsigned char c = 16;
	unsigned out1 = i | c;
	cout << out1 << endl;

	unsigned int out2 = i & 0xff;
	cout << out2;

	char a;
	cin >> a;
	return 0;
}

Aber ich habe noch ein andres Prob: Warum darf i nur 512 oder 1024 betragen?