С++ чтение беззнаковых значений int из байтового буфера

Тип char вашего компилятора подписан. char — это то, что вы получаете от std::string.

Никогда не следует сдвигать или возиться со значениями знакового типа, если вы не очень хорошо знаете, что делаете. Немедленно переведите на unsigned char:

iReturn = (unsigned char)File_Content[iPos] 
        | ((unsigned char)File_Content[iPos + 1] << 8);

Живая демонстрация.

Все равно решил опубликовать для возможных будущих читателей: Моя первоначальная проблема (как я думаю) в минимально воспроизводимом примере) с решением Реми Лебо, реализованным в ней. Наслаждаться!

#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

//==============================================================================
// Global Variables
//==============================================================================
std::string File_Content = "";
uint32_t File_Pos = 0;

//==============================================================================
// read the entire file into a string/ByteArray
//==============================================================================
static uint8_t GetFileContents(const std::string sFileName)
{
   uint32_t iFileSize = 0;  

   iFileSize = (uint32_t)std::filesystem::file_size(sFileName);

   std::ifstream strStream(sFileName, std::ios::in | std::ios::binary);
   if (strStream)
   {  
      File_Content.resize(iFileSize);
      strStream.read(File_Content.data(), iFileSize);
      strStream.close();
   }  // end if (sStream)

   return 0;
}  // end get_file_contents

//==============================================================================
// read 2-bytes-int out of the string, considering Endian
//==============================================================================
static uint8_t Read2Bytes(uint8_t iEndian, uint16_t &iReturn)
{
   uint8_t bHiByte, bLoByte;

   if (iEndian == 0)  // little Endian
   { 
      // my first attempt, not-working, HiByte gets lost
      //iReturn = File_Content[File_Pos] | (File_Content[File_Pos + 1] << 8);

      // my 2nd attempt, WORKING, but too complicated
      //bLoByte = File_Content[File_Pos];
      //bHiByte = File_Content[File_Pos + 1];
      //iReturn = (bHiByte << 8) | bLoByte;

      // Remys solution, with re-casting to unsigned char per byte
      iReturn = (unsigned char)File_Content[File_Pos] | ((unsigned char)File_Content[File_Pos + 1] << 8);

   }  // end if (iEndian == 0)
   else
   {  // Big Endian
      // not importand here
   }  // end else (iEndian == 0)

   // 2 bytes read, move along PosMarker accordingly
   File_Pos += 2;

   return 0;
}  // end Read2Bytes

//==============================================================================
// read 4-bytes-int out of the string, considering Endian
//==============================================================================
static uint8_t Read4Bytes(uint8_t iEndian, uint32_t &iReturn)
{
   uint8_t bByte1, bByte2, bByte3, bByte4;

   if (iEndian == 0)  // Little Endian
   {
      // my first attempt, not-working, HiByte gets lost
      //iReturn = File_Content[File_Pos] | File_Content[File_Pos + 1] << 8 | File_Content[File_Pos + 2] << 16 | File_Content[File_Pos + 3] << 24;

      // my 2nd attempt, WORKING, but too complicated
      //bByte1 = File_Content[File_Pos];
      //bByte2 = File_Content[File_Pos + 1];
      //bByte3 = File_Content[File_Pos + 2];
      //bByte4 = File_Content[File_Pos + 3];
      //iReturn = bByte1 | (bByte2 << 8) | (bByte3 << 16) | (bByte4 << 24);

      // Remys solution, with re-casting to unsigned char per byte
      iReturn = (unsigned char)File_Content[File_Pos] | ((unsigned char)File_Content[File_Pos + 1] << 8) | ((unsigned char)File_Content[File_Pos + 2] << 16) | ((unsigned char)File_Content[File_Pos + 3] << 24);
   }
   else
   { // Big Endian
     // not important here
   }
   
   // 4 bytes read, move along PosMarker accordingly
   File_Pos += 4;

   return 0;
}  // end Read4Bytes

static uint8_t AnalyzeFileContents()
{

   uint32_t Some4ByteInt = 0;    // 4 bytes, unsigned
   uint16_t Some2ByteInt = 0;    // 2 bytes, unsigned

   Read2Bytes(0, Some2ByteInt);  // read 2 byte int from the string
   Read4Bytes(0, Some4ByteInt);  // read 4 byte int from the string

   // ... and so on
   // omitted: whatever is done with the values afterwards, not essential to the problem

   return 0;
} // end AnalyzeFileContents


int main(int, char const* argv[])
{
   std::string sFileName;
   sFileName = "SomeFile.bin";

   // read the entire file into the string
   GetFileContents(sFileName);  

   // analyze the data in the string
   AnalyzeFileContents(); 
}  // end int main()

Оглядываясь назад, это довольно очевидно.

Моя попытка, когда я обрабатываю побайтово в отдельных переменных uint8_t (т.е. в частности, беззнаковое int), работает отлично, в отличие от моего «все в одном предложении», где я понятия не имел, что компилятор делает с байтами, смешивая их. вместе... ну да ладно.

И да, я не знал, что удаление байта из строки — это, по сути, байт со знаком, тогда как мне нужно было, чтобы он был без знака.

Престижность Джону и Реми, и я надеюсь, что это поможет будущим читателям.

Всем здоровья! АлексисВанВен