C, VS, Struct

[Anonymous U. (gastt)]

Hallo allerseits,

ich versuche seit Stunden Daten von einem Array als Bitmap zu speichern. 
Jetzt bin ich drauf gekommen, dass der Header nicht stimmt. Ich habe den 
Header in 2 structs aufgeteilt. Dieses Padding hab ich schon 
ausgeschaltet (muss man erst mal drauf kommen).
In dem struct sind verschiedene Formate nacheinander abgespeichert. Mein 
Plan war (auch in vielen Beilpielen ist das so realisiert), dass dieses 
Struct dann einfach byte für byte in die Datei geschrieben wird. Nun ist 
es so: struct bmpheader.widthbmp = 640. Wenn ich bmpheader.widthbmp 
ausgebe, so erhalte ich 640. Allerdings wenn ich den Speicherbereich von 
bmpheader.widthbmp auslese kommt Murks raus und ich verstehe nicht 
warum. Warum ist das so und wie kann ich das Problem lösen?

typedef struct fileheader{
  char filetype1, filetype2;
  DWORD sizefile;
  DWORD reserved = 0;
  DWORD offsetdata = 54;
};
typedef struct bmpheader{
  DWORD sizeheader = 40;
  DWORD widthbmp;
  DWORD heigthbmp;
  WORD planes = 1;
  WORD colbits = 8;
  DWORD compression = 0;
  DWORD sizedata;
  DWORD pixpmx = 0;
  DWORD pixpmy = 0;
  DWORD coltbl1 = 0;
  DWORD coltbl2 = 0;
};

void bmpout(char *inputarr, struct ginterface_2d_1d *settings){

  /*Bitmapfileheader*/
  fileheader fheader;
  fheader.sizefile = (settings->resolutionx*settings->resolutiony)+sizeof(fileheader)+sizeof(bmpheader);
  fheader.filetype1 = 'B'; fheader.filetype2 = 'M';
  /*Bitmapinfoheader*/
  bmpheader bheader;
  bheader.colbits = 8;
  bheader.heigthbmp = settings->resolutiony;
  bheader.sizedata = settings->resolutionx*settings->resolutiony;
  bheader.widthbmp = 256;// (DWORD)settings->resolutionx;

  std::ofstream bmpdata("test.bmp", std::ios::out | std::ios::binary);
  bmpdata.write((char*)&fheader, sizeof(fheader));
  bmpdata.write((char*)&bheader, sizeof(bheader));

  char test[60] = { 0 };
  for (int i = 0; i != 14; ++i){
    test[i] = *((char*)&bheader + i);
    for (int ii = 7; ii >= 0; --ii){
      if ((1 << ii)&test[i])
        printf("1");
      else
        printf("0");
    }
    printf(" | %8x\n", test[i]);
  }
  printf("\n");

  int zähler = 0;  //#
  char b = 0x01;  //#
  for (int i = 0; i != settings->resolutiony; i++){
    for (int ii = 0; ii != settings->resolutionx; ii++) {
      bmpdata.write(&b, 1);  //#
      //bmpdata.write(&pic_diagram[ii][i], 1);
      zähler++;  //#
      continue;
    }
  }
  bmpdata.close();

  //#
  printf("Headersize: %d & %d\n", sizeof(fheader), sizeof(bheader));
  printf("dazasize: %d\n\n", zähler);
  printf("bmp headerdata:\n|");
  for (int i = 0; i != 10; i++){
    printf(" %ld |", *((long *)&bheader + i));
  }
  scanf("%c", &b);
  //printf("%s", ginterface.pic_diagramm);
}

[Michael S. (schiko)]

Dreh den Spieß mal um:
Nehme ein x-beliebiges Malprogramm, erzeuge Dir 'ne Bitmap
wie Du sie wünscht, und schau's Dir binär an.

[Anonymous U. (gastt)]

Michael Schikora schrieb:
> Dreh den Spieß mal um:
> Nehme ein x-beliebiges Malprogramm, erzeuge Dir 'ne Bitmap
> wie Du sie wünscht, und schau's Dir binär an.

Ja hab ich gemacht: Es liegt an dem Struct.

Beispiel:

struct test{
word a;
dword b;
dword c;
};

struct test newtest;
newtest.a = 10;
newtest.b = 20;
newtest.c = 600;

printf("%i", newtest.c);

Als Ausgabe erhalte ich 600. Würde passen. Und nun:

printf("%x,%x", *((char*)&newtest+2+4+2),*((char*)&newtest+2+4+3));

Da kommt als Ausgabe Murks. Aber eigentlich erwarte ich 600 in 
hexadezimal!!!

[DirkB (Gast)]

Du musst erst newtest in einen char* casten und dann dein Offset darauf 
addieren.
Dazu reicht es etwas anders zu klammern.

[Anonymous U. (gastt)]

DirkB schrieb:
> Du musst erst newtest in einen char* casten und dann dein Offset darauf
> addieren.
> Dazu reicht es etwas anders zu klammern.

Wie macht man sowas?

[Michael S. (schiko)]

ich würde "0,0" erwarten auf nem x86 (Little Endian)

[Anonymous U. (gastt)]

Michael Schikora schrieb:
> ich würde "0,0" erwarten auf nem x86 (Little Endian)

Ja stimmt natürlich. In dem Beispiel müssen 2 weniger addiert werden:

printf("%x,%x", *((char*)&newtest+2+4+1),*((char*)&newtest+2+4+0));

[Michael S. (schiko)]

Anonymous User schrieb:
> Michael Schikora schrieb:
>> ich würde "0,0" erwarten auf nem x86 (Little Endian)
>
> Ja stimmt natürlich. In dem Beispiel müssen 2 weniger addiert werden:
>

> printf("%x,%x", *((char*)&newtest+2+4+1),*((char*)&newtest+2+4+0));
>

char* p = (char*)&newtest;
printf("%02X ", *(p + ..)  );
..
.

[Anonymous U. (gastt)]

Hmm, anscheinend kommt bei mir doch kein direkter Murks raus... 
printf("%x") gibt bei größeren zahlen als 255 grundsätzlich erstmal 
ffffff aus. Der Rest dahinter passt: ffffff80, und der nächste hex-Wert 
ist 02, also 640. Das würde passen. Was ist hier verkehrt?

[Michael S. (schiko)]

Anonymous User schrieb:

> [..]  Was ist hier verkehrt?

Du hast noch kein Bild mit Paint gemalt und verglichen.

[Arc N. (arc)]

Wenn C und VS im Betreff steht, warum dann nicht die von MS 
bereitgestellten Strukturen und Funktionen benutzen?

Storing an Image
https://msdn.microsoft.com/en-us/library/windows/desktop/dd145119%28v=vs.85%29.aspx

File header
https://msdn.microsoft.com/de-de/library/windows/desktop/dd183374%28v=vs.85%29.aspx
https://msdn.microsoft.com/en-us/library/windows/desktop/dd183380%28v=vs.85%29.aspx
https://msdn.microsoft.com/en-us/library/windows/desktop/dd183381%28v=vs.85%29.aspx

Info Header
https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376%28v=vs.85%29.aspx

[Anonymous U. (gastt)]

Arc Net schrieb:
> Wenn C und VS im Betreff steht, warum dann nicht die von MS
> bereitgestellten Strukturen und Funktionen benutzen?

Ich wills ja verstehen warums nicht funktioniert.


So, ich glaub mich trifft der Schlag: mit folgendem cast geht das 
printf: (unsigned char*). Ich dachte damit wird nur eingestellt um wie 
viele bytes der pointer bei ++ weiterspringt. Was macht der Compiler da 
schon wieder im Hintergrund für Sachen???

Das Problem ist nun, dass ofstream nur mit zeiger vom typ (char*) 
umgehen kann und nicht mit (unsigned char*). Was kann ich noch tun?

[Anonymous U. (gastt)]

Hier nochmal zum Verdeutlichen:

  printf("%x\n", ((char*)&bheader + 4));
  printf("%x\n", ((unsigned char*)&bheader + 4));
  printf("%x\n", *((char*)&bheader + 4));
  printf("%x\n", *((unsigned char*)&bheader + 4));

Ausgabe:

20ad6c
20ad6c
ffffff80
80

[Rolf M. (rmagnus)]

Anonymous User schrieb:
> Was macht der Compiler da schon wieder im Hintergrund für Sachen???

Nennt sich Integer Promotion.

[Anonymous U. (gastt)]

Rolf Magnus schrieb:
> Nennt sich Integer Promotion.

Ah, da kennt sich wer aus. Das Stichwort hätt ich in 100 Jahren nicht 
gefunden.

Und schon wieder ein Grund warum ich am liebsten bei Assembler bleiben 
würde ;-)

[Anonymous U. (gastt)]

Gute Erklärung: 
http://www.idryman.org/blog/2012/11/21/integer-promotion/