#include <windows.h>
#include <stdio.h>

void ErrorExit(LPTSTR lpszFunction);

class Screenshot {
	public:
		char *data;
		int width, height;
		int allocWidth, allocHeight;

		Screenshot();
		void update();
		void alloc( int, int );
		PBITMAPINFO CreateBitmapInfoStruct(HBITMAP hBmp);
};

Screenshot::Screenshot() {
	data = NULL;
	width = height = 0;
	allocWidth = allocHeight = -1;
}

void SaveBitmap( const char *data, int width, int height, const char* lpszFileName);

int main() {
	//window();

	Screenshot screen;
	screen.update();
	printf("Größe: %ix%i\n", screen.width, screen.height );

	SaveBitmap( screen.data, screen.width, screen.height, "c:\\moep.bmp" );
}

void Screenshot::alloc(int w, int h) {
	if( allocWidth != w || allocHeight != h || !data ) {
		if( data ) {
			delete[] data;
		}
		data = new char[w * h * 3];
	}
	allocWidth = w;
	allocHeight = h;
}

void Screenshot::update() {
	HWND desktopHwnd;
	RECT rect;
	HDC desktopDC, dc;

	desktopHwnd = GetDesktopWindow();
	if( !desktopHwnd ) ErrorExit("Update - Hwnd");

	if( !GetWindowRect( desktopHwnd, &rect ) )
		ErrorExit("Update - Rect");

	desktopDC = GetDC( desktopHwnd );
	if( !desktopDC ) ErrorExit("Update-Dc");

	width = rect.right - rect.left;
	height = rect.bottom - rect.top;

	HBITMAP pic = CreateCompatibleBitmap( desktopDC, width, height );
	if( !pic ) ErrorExit("Update-Create");

	PBITMAPINFO infoStruct = CreateBitmapInfoStruct( pic );

	dc = CreateCompatibleDC( desktopDC );
	if( !dc ) ErrorExit("Compatible");

	SelectObject( dc, pic );

	//char *data = new char[width * height * 3];
	alloc( width, height );
	// los gehts

	BitBlt(dc, 0,0, width, height, desktopDC, 0,0, SRCCOPY);

	//#####################################################
	// hier hörts auf, mag das an der infoStruct liegen?
	if( GetDIBits(dc, pic, 0, (WORD) height, data, infoStruct, DIB_RGB_COLORS) ) {
		//SaveBitmap( data, width, height, "C:\\test.bmp" );
	} else {
		ErrorExit("GetDIBits");
	}

	//LocalFree( infoStruct );
	//CloseHandle( desktopHwnd );
	//CloseHandle( pic );
	//DeleteDC( dc );
	//DeleteDC( desktopDC );
	//delete[] data;
}

PBITMAPINFO Screenshot::CreateBitmapInfoStruct(HBITMAP hBmp)
{ 
    BITMAP bmp; 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 

    // Retrieve the bitmap color format, width, and height. 
    GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp);
        //errhandler("GetObject", hwnd); 

    // Convert the color format to a count of bits. 
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel); 
    if (cClrBits == 1) 
        cClrBits = 1; 
    else if (cClrBits <= 4) 
        cClrBits = 4; 
    else if (cClrBits <= 8) 
        cClrBits = 8; 
    else if (cClrBits <= 16) 
        cClrBits = 16; 
    else if (cClrBits <= 24) 
        cClrBits = 24; 
    else cClrBits = 32; 

    // Allocate memory for the BITMAPINFO structure. (This structure 
    // contains a BITMAPINFOHEADER structure and an array of RGBQUAD 
    // data structures.) 

     if (cClrBits != 24) 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER) + 
                    sizeof(RGBQUAD) * (1<< cClrBits)); 

     // There is no RGBQUAD array for the 24-bit-per-pixel format. 

     else 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER)); 

    // Initialize the fields in the BITMAPINFO structure. 

    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    pbmi->bmiHeader.biWidth = bmp.bmWidth; 
    pbmi->bmiHeader.biHeight = bmp.bmHeight; 
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes; 
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel; 
    if (cClrBits < 24) 
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits); 

    // If the bitmap is not compressed, set the BI_RGB flag. 
    pbmi->bmiHeader.biCompression = BI_RGB; 

    // Compute the number of bytes in the array of color 
    // indices and store the result in biSizeImage. 
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
                                  * pbmi->bmiHeader.biHeight; 
    // Set biClrImportant to 0, indicating that all of the 
    // device colors are important. 
     pbmi->bmiHeader.biClrImportant = 0; 
     return pbmi; 
}

void SaveBitmap( const char *data, int width, int height, const char* lpszFileName)
{
    BITMAPFILEHEADER bmfh = {0};
    BITMAPINFOHEADER bmih = {0};

    bmih.biSize      = sizeof(BITMAPINFOHEADER);
    bmih.biBitCount  = 24;
    bmih.biWidth     = width;
    bmih.biHeight    = height;
    bmih.biSizeImage = bmih.biWidth * bmih.biHeight * 3;
    bmih.biPlanes    = 1;

    bmfh.bfType      = 'B' + ((WORD)'M' << 8); 
    bmfh.bfOffBits   = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    bmfh.bfSize      = bmfh.bfOffBits + bmih.biSizeImage;

    FILE *stream = fopen(lpszFileName, "wb");
    if(!stream){
        printf("Can not open %s\n", lpszFileName);
        return;
    }
    fwrite(&bmfh,  sizeof(BITMAPFILEHEADER), 1, stream);
    fwrite(&bmih,  sizeof(BITMAPINFOHEADER), 1, stream);
    fwrite(data, bmih.biSizeImage,           1, stream);
    fclose(stream);
}

void ErrorExit(LPTSTR lpszFunction) 
{ 
    TCHAR szBuf[80]; 
    LPVOID lpMsgBuf;
    DWORD dw = GetLastError(); 

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );

    wsprintf(szBuf, 
        "%s failed with error %d: %s", 
        lpszFunction, dw, lpMsgBuf); 

    MessageBox(NULL, szBuf, "Error", MB_OK); 

    LocalFree(lpMsgBuf);
    ExitProcess(dw); 
}

k.a. obs das ist (ok... bin zu faul das jetzt zu compilieren, vielleicht später... )

- Dein code auf meinen 32bit desktop -> geht net
- Dein code auf meinen 16bit desktop -> geht

- new char[w * h * 4] auf meinen 32bit desktop -> geht

sieht für mich so aus als wärs doch das