массив char в long приводит к неожиданному значению

Это из-за продвижения типа и расширения знака. Каждое значение в вашем массиве char подписано, а битовый сдвиг — это целочисленная операция. Когда вы используете оператор сдвига, он оценивается как int, а поскольку ваши char являются знаковыми, их сдвиг приведет к созданию подписанных int.

Последний (самый правый) байт имеет 1 в качестве бита знака. При повышении до int его значение становится -104 по расширению знака. Поскольку вы объединили остальные числа с помощью операции ИЛИ, все 1 битов остались неизменными.

Чтобы избежать этой проблемы, вы можете преобразовать каждые chars в unsigned long перед сдвигом и операцией ИЛИ.

Еще одна вещь, которую вы можете сделать, это выполнить побитовое И для каждого char с 0xff, например ((b[i] & 0xff) << 24). Выполнение И с 0xff даст int, сохраняя младшие значащие 8 бит без изменений и нули слева, без расширения знака.

2 вещи:

1. char может быть подписанным или неподписанным, поэтому его не следует использовать для хранения типов данных, отличных от символов.

   В C, C++ и большинстве C-подобных языков любые типы, более узкие, чем int, должны повышаться до int в выражении, и ваше заявление будет обработано так

    unsigned long ret = ((int)b[0] << 56) | ((int)b[1] << 48)
                      | ((int)b[2] << 40) | ((int)b[3] << 32)
                      | ((int)b[4] << 24) | ((int)b[5] << 16)
                      | ((int)b[6] <<  8) | ((int)b[7]);
   

   Если char подписано, оно будет повышено до int с помощью расширения подписи. В результате верхние биты будут заполнены единицами, если значение байта отрицательное.

   В MSVC char по умолчанию подписано. Вы можете использовать /J, чтобы сделать char беззнаковым, что решит часть вашей проблемы. Но тогда возникает другая проблема:

2. В Windows long является 32-разрядным типом, поэтому вы не можете упаковать 8 байт в него. Кроме того, int также является 32-разрядным в большинстве современных систем, и после повышения b[i] до int сдвиг более чем на 31 является неопределенным поведением, которое это то, что делает ваша программа.

Итак, чтобы исправить все проблемы портативно, вам нужно:

• Приведите все b[i] к unsigned char или uint8_t или маскируйте старшие биты, объединив их с 0xFF, как предложено 0605002. Или просто измените тип b на unsigned char&* вместо char&*
• Измените тип возвращаемого значения на тип шириной не менее 64 бит, например (unsigned) long long, (u)int64_t или (u)int_least64_t.

Результат может выглядеть так

uint64_t readAndSkipLong(unsigned char*& b)
{
    return ((uint64_t)b[0] << 56) | ((uint64_t)b[1] << 48)
         | ((uint64_t)b[2] << 40) | ((uint64_t)b[3] << 32)
         | ((uint64_t)b[4] << 24) | ((uint64_t)b[5] << 16)
         | ((uint64_t)b[6] <<  8) | ((uint64_t)b[7]);
}

or

uint64_t readAndSkipLong(char*& b)
{
    return ((uint64_t)(uint8_t)b[0] << 56) | ((uint64_t)(uint8_t)b[1] << 48)
         | ((uint64_t)(uint8_t)b[2] << 40) | ((uint64_t)(uint8_t)b[3] << 32)
         | ((uint64_t)(uint8_t)b[4] << 24) | ((uint64_t)(uint8_t)b[5] << 16)
         | ((uint64_t)(uint8_t)b[6] <<  8) | ((uint64_t)(uint8_t)b[7]);
}

Однако на самом деле вам не нужно писать функцию для обратного порядка байтов. Для этого уже есть ntohll() и htonll()

reversedEndian = ntohll(originalValue);

Если ввод должен быть массивом char, просто скопируйте значение в массив uint64_t

memcpy(&originalValue, &b, sizeof originalValue);
reversedEndian = ntohll(originalValue);

Вы можете еще больше уменьшить все это до reversedEndian = ntohll(*(int64_t*)&b);, если строгий псевдоним разрешен, потому что на x86 невыровненный доступ обычно разрешен

Пара вещей для размышления

1. включите cstdint и используйте std::uint64_t и std::uint8_t для ваших типов, чтобы не было проблем со знаком.
2. Логика также зависит от того, является ли ваша машина прямым порядком байтов или обратным порядком байтов. Для машин с прямым порядком байтов вам нужно сначала поместить младший значащий байт, а затем перейти к более высокому. Ваша логика для Big Endian.
3. Возможно, у вас переполнение счетчика. Лучшим способом было бы явно объявить uint64_t и использовать его.

Вот небольшой код, который я написал для байтов до uint64_t на машине с прямым порядком байтов.

std::uint64_t bytesToUint64(std::uint8_t* b) {
    std::uint64_t msb = 0x0u;
    for (int i(0); i < 7; i++) {
        msb |= b[i];
        msb <<= 8;
    }
    msb |= b[7];

    return msb;
}

EDIT by OP (реализован совет 1):

long readAndSkipLong(char*& b)
{
    std::uint64_t ret = 
        ((std::uint8_t)b[0] << 56) | 
        ((std::uint8_t)b[1] << 48) | 
        ((std::uint8_t)b[2] << 40) | 
        ((std::uint8_t)b[3] << 32) | 
        ((std::uint8_t)b[4] << 24) | 
        ((std::uint8_t)b[5] << 16) | 
        ((std::uint8_t)b[6] <<  8) | 
        ((std::uint8_t)b[7]);
    b+=8;

    return ret;
}