C++ lire et comparer le nombre magique à partir du fichier

Question

J'ai un fichier que je veux lire en C++. La première chose que je dois lire et vérifier est le nombre magique du fichier. Dans mon cas, il est le Hex Valeur: 0xABCDEF00

Je lis et compare le nombre de cette façon:

ifstream input ("C:/Desktop/myfile", ios::binary); 
if (input.is_open()) { 
input.seekg(0, ios::beg); 
unsigned char magic[4] = {0}; 
input.read((char*)magic, sizeof(magic)); 

if(magic[0] == 0xAB && 
    magic[1] == 0xCD && 
    magic[2] == 0xEF && 
    magic[3] == 0x00) { 
    cout << "It's my File!" << endl; 
} else { 
    cout << "Unknown File!" << endl; 
} 
} 

Cela fonctionne très bien, mais est-il un moyen de comparer l'ensemble de lecture char [] - Array à la fois? Comme cette façon:

unsigned int magicNumber = 0xABCDEF00; 
... same code for reading file as above ... 
Instead of checking each Array-Entry a way like this: 

if(magic == magicNumber) { 
    do something ... 
} 

Ce serait bien de savoir s'il y a une telle façon - sinon merci de me TEELING qu'il n'y a pas de telle façon :)

Answer 1

bon vieux memcmp pourrait aider. Une fois que vous avez lu le unsigned char magic[4] vous pouvez faire la comparaison aussi simple que:

const unsigned char magicref[4] = {0xAB, 0xCD, 0xEF, 0} 
if (memcmp(magic, magicref, sizeof(magic)) == 0) { 
    // do something ... 
} 

C'est indépendant boutisme.

Si vous savez ce que vous la plate-forme vous donnera le numéro magique et ne se soucient pas de la portabilité sur d'autres plates-formes, vous pouvez traiter directement tout comme uint32_t:

uint32_t magic, refmagic = 0xABCDEF00; // big endian here... 
input.read(reinterpret_cast<char *>(&magic), sizeof(magic)); // directly load bytes into uint32_t 
if (magic == refmagic) { 
    //do something... 
} 

Ce n'est pas portable sur différentes plates-formes, mais peut être utilisé dans les cas simples ont fait un commentaire dans la police rouge clignotant gras en disant ATTENTION: utilisez uniquement sur grand système endian

Answer 2

Si vous connaissez les ENDIANNESS de votre plate-forme, vous pouvez utiliser une variable uint32_t pour le faire.

Pour un petit système endian, utilisez:

unit32_t number; 
input.read(reinpterpret_cast<char*>(&number), 4); 
if (number == 0x00EFCDAB) 
{ 
    cout << "It's my File!" << endl; 
} 

Pour un grand système endian, utilisez:

unit32_t number; 
input.read(reinpterpret_cast<char*>(&number), 4); 
if (number == 0xABCDEF00) 
{ 
    cout << "It's my File!" << endl; 
} 

Answer 3

Il y a déjà de très bonnes réponses ici! Pour les enregistrements, ici en utilisant une variante equal() de la bibliothèque standard: <algorithm>

unsigned char magic[4] = {0}; 
input.read((char*)magic, sizeof(magic)); 

const unsigned char code[4] = { 0xab, 0xcd, 0xef, 0x00 }; 
if(equal(code, code+sizeof(code), magic)) 
    cout << "It's my File!" << endl; 
else 
    cout << "Unknown File!" << endl; 

Il est très similaire à la version memcmp() mais il fonctionne avec tout récipient, non seulement les tableaux de CHAR.

Online demo

Answer 4

Vous pouvez faire:

union magic_t { 
    uint8_t bytes[4]; 
    uint32_t number; 
}; 

alors que vous vouliez à l'origine:

magic_t my_magic = {0xAB, 0xCD, 0xEF, 0}; 
magic_t file_magic; 
input.read((char *) file_magic.bytes, sizeof(file_magic)); 
if (file_magic.number == my_magic.number)... 

et vous n'avez pas besoin de se soucier de endianess du tout.

En fonction de l'endianness nombre peut être différent mais cela n'a pas d'importance du tout car ce serait toujours la bonne séquence d'octets même si le nombre n'est pas 0xABCDEF00. Ou, en option, nous pouvons simplement utiliser le casting (mais je pense que c'est moche).