Argthtjtr

I am trying to read a little-endian hex string from a binary file, and put that value into an integer to work with it. When I try to read, instead of getting a number I get ascii symbols. I've tried casts and atoi and nothing seems to work. What is the best way to use fstream to read a hex string into an integer from a file?

This is essentially my program:

#include <iostream>

#include <fstream>

#include <string>

using namespace std;



int main(int argc, char* argv) {

    fstream input;

    fstream output;

    char cbuffer[4];

    char revbuffer[8];



    input.open(argv[1], fstream::binary | fstream::in);

    output.open("output.txt", ios::out | ios::app);

    input.seekg(16, input.beg);

    input.read(cbuffer, 4);



    cout << sizeof(revbuffer) << endl;

    cout << cbuffer[0] << cbuffer[1] << cbuffer[2] << cbuffer[3] << endl;

}

If it's an integer value stored in binary format, I guess it's either a int32_t or a uint32_t. Since you mention that the value is stored in little-endian byte order, I guess you want to make sure that the host running your program converts it (if it needs to). C++20 has std::endian. If that's not available to you, there are usually macros for detecting endianness at compiletime that you can use instead of the std::endian tests I've used. I've assumed that the value is a uint32_t below.

#include <iostream>

#include <fstream>

#include <string>

#include <vector>

#include <type_traits> // std::endian



// little endian unsigned 32 bit integer to host byte order

inline uint32_t Le32toh(uint32_t le) {

    #if __cplusplus <= 201703L

    // run-time check

    static constexpr uint16_t endian = 1;

    if(*reinterpret_cast<const uint8_t*>(&endian)==1) return le;

    #else

    // compile-time check

    static_assert(std::endian::native == std::endian::little || std::endian::native == std::endian::big);

    if constexpr (std::endian::native == std::endian::little) return le;

    #endif



    const uint8_t* c=reinterpret_cast<const uint8_t*>(&le);

    return // little-to-big endian conversion

        (static_cast<uint32_t>(c[0])<<24) |

        (static_cast<uint32_t>(c[1])<<16) |

        (static_cast<uint32_t>(c[2])<<8) |

        (static_cast<uint32_t>(c[3]));



    return le;

}





int main(int argc, char* argv) {

    std::vector<std::string> args(argv+1, argv+argc);



    std::fstream output("output.txt", std::ios::out | std::ios::app);



    uint32_t cbuffer;



    for(const auto& file : args) {

        std::fstream input(file, std::fstream::binary | std::fstream::in);

        input.seekg(16, input.beg);

        // read directly into the varibles memory

        input.read(reinterpret_cast<char*>(&cbuffer), 4);

        // output the value unconverted

        std::cout << std::hex << cbuffer << "n";

        // convert if needed

        cbuffer = Le32toh(cbuffer);

        // output the value converted

        std::cout << std::hex << cbuffer << "n";

    }

}