ich bin gerade dabei meinen C Code in C++ Klassen zu packen und bin dabei auf folgendes Problem gestossen:

Öffne ich eine Datei in meiner Main Funktion mit

char bootsector[512];
ifstream is;
is.open("../../Windows7FreshDropperStage1.dd", ios::binary);

if (!is.is_open()) {
  return false;
}

is.read(bootsector, 512);
is.close();

dann funktioniert das ganze einwandfrei.

Packe ich das ganze aber jetzt in eine Klasse mit

class Bootsector {
  bool read(){
   char bootsector[512];
   ifstream is;
   is.open("../../Windows7FreshDropperStage1.dd", ios::binary);

   if (!is.is_open()) {
     return false;
   }

   is.read(bootsector, 512);
   is.close();
  }
}

dann schmiert mir das Programm beim is.read mit einem Segfault ab. Debuggen ist auch essig weil der Segfault gleich passiert.

Was ist da los? Ich bin ziemlich ratlos

Eine reine C Funktion innerhalb der Klasse funktioniert dann wieder reibungslos:

FILE *fp = fopen("../../Windows7FreshDropperStage1.dd", "rb");
	fread(bootsector, 1, 512, fp);
	fclose(fp);

#include <fstream>
#include <iostream>

class Bootsector
{
public:
    bool read()
    {
        char bootsector[512];
        std::ifstream is;
        is.open("/dev/sda",std::ios::binary);

        if (!is.is_open())
            return false;

        is.read(bootsector,512);
        is.close();
        return true;
    }
};

int main()
{       
    Bootsector x;
    std::cout << x.read() << "\n";
    return 0;
}

$ g++ code.cpp -o code
$ ./code
0
$ sudo ./code
1
$

Vielleicht machst du schon vorher was kaputt. Wenn man kein reproduzierbares Beispiel postet, kann man das nicht sagen.

Und die Bootsektorgröße würde ich irgendwo speichern. Ist blöd, zweimal so eine Konstante im Code zu haben.

if (!is.is_open())

richtigerweise ab.

Main.cpp

#include "Bootsector.h"

int main(int argc, char**argv) {
  Bootsector bs;
  string filename = "Windows7FreshDropperStage1.dd";
  bs.read(filename);
}

Bootsector.h

#pragma once
#pragma pack(1)

#include <stdint.h>
#include <string>
#include <iostream>
#include <fstream>

using namespace std;

class Bootsector {
private:
	char bootsector[512];
public:
	Bootsector() {}
	bool read(string filename);
};

Bootsector.cpp

#include "Bootsector.h"

bool Bootsector::read(string filename) {
    ifstream is;
    is.open(filename, ios::binary);

    if (!is.is_open()) {
		return false;
	}

    is.read((char*)bootsector, 512);
    is.close();
}

Was nutzt du denn für einen Compiler/Umgebung etc.?

void open (const char* filename, ios_base::openmode mode = ios_base::in);

Offensichtlich ist der Compiler schon moderner als du.

using namespace std;` hat in einem Header nix verloren.

Dein read() hat keinen Rückgabewert (siehe dachschadens Posting).

Was soll das pragma pack da?

Doch nicht so ganz minimal wie ich dachte. Das brauche ich im restlichen Code für meine structs damit ich kein 32bit alignment habe. Vergiss die Zeile hier einfach. Ist mir durchs Copy&Paste reingerutscht

pragma pack(1) vor den includes ist wohl das Problem.
Die gesamten headaer files in Bootsector.h ist Quark. Inkludier dort nur was Du brauchst ( <string> im Beispiel). In der *.cpp genauso (nur was Du dort brauchst).
`

using namespace std;` hat in einem Header nix verloren.

Dein read() hat keinen Rückgabewert (siehe dachschadens Posting).

Hm. Tastächlich. Pragma Pack war das Problem. Nur wieso? Das sollte dem Compiler doch eigentlich nur mitteilen alle Structs im Byte Alignment anzuordnen...

Sollte im Header File nur dass inkludiert werden was ich für das Header File brauche und im CPP File nur dass was fürs CPP nötig ist?

Du kann jedoch gerne noch ein pragma push und pop einfügen, um das Alignment danach wieder zurückzusetzen.

Wie funktioniert das mit pragma push und pop? Kenne das nicht.

Wie funktioniert das mit pragma push und pop? Kenne das nicht.

Wieso verwendest du das dann?

Keine Gewähr, dass das so funktioniert, den Code habe ich so bei mir drin, bin aber noch nicht dazu gekommen zu testen:

/*Wir wollen 1-Byte-Alignment haben*/
#pragma pack(push,1)

/*Jetzt haben wir 1-Byte-Alignment, hier kommen jetzt unsere Typen:*/
struct winapi_registry_timezone_date
{
        uint16_t year;
        uint16_t mon;
        uint16_t wday;
        uint16_t wmon;
        uint16_t hour;
        uint16_t min;
        uint16_t sec;
        uint16_t ms;
};

/*Und damit der Rest nicht kaputtgeht ...*/
#pragma pack(pop)

EOP_hat_wiedermal schrieb:

void open (const char* filename, ios_base::openmode mode = ios_base::in);

Offensichtlich ist der Compiler schon moderner als du.

Das ist O-Ton cppreference.com.

void open( const std::string &filename,                                  
           ios_base::openmode mode = ios_base::in );
	(2) 	(since C++11)

hab ich erst jetzt entdeckt. Keine Ahnung, wo ich vorhin nachgesehen hab, daß da nur die vorherige Version stand.