Чтение “целочисленных” байтов размера от символа* массив.

Вы имеете в виду что-то как этот?:

char* a;
int i;
memcpy(&i, a, sizeof(i));

только необходимо волноваться о порядке байтов, если источник данных с другой платформы, как устройство.

Зависит от того, как Вы хотите считать их, я получаю чувство, что Вы хотеть бросить 4 байта в целое число, делая так по переданным потоком данным сети будете обычно заканчивать в чем-то вроде этого:

int foo = *(int*)(stream+offset_in_stream);

a), который только необходимо взволновать по поводу "порядка байтов" (т.е. свопинг байта), если бы данные были созданы на машине с обратным порядком байтов и обрабатываются на машине с прямым порядком байтов, или наоборот. Существует много способов, которыми это может произойти, но здесь является несколькими примерами.

1. Вы получаете данные по машине Windows через сокет. Windows использует архитектуру с прямым порядком байтов, в то время как сетевые данные, как "предполагается", находятся в формате с обратным порядком байтов.
2. Вы обрабатываете файл данных, который был создан в системе с другим "порядком байтов".

В любом из этих случаев, Вам будут нужны к подкачке байта все числа, которые больше, чем 1 байт, например, короткие замыкания, ints, longs, удваивается, и т.д. Однако, если Вы всегда имеете дело с данными из той же платформы, проблемы порядка байтов не вызывают беспокойства.

b) На основе Вашего вопроса, это кажется, что Вы имеете символьный указатель и хотите извлечь первые 4 байта как интервал и затем заниматься любыми проблемами порядка байтов. Чтобы сделать извлечение, используйте это:

int n = *(reinterpret_cast<int *>(myArray)); // where myArray is your data

, Очевидно, это предполагает, что myArray не является нулевым указателем; иначе это откажет, так как это разыменовывает указатель, поэтому используйте хорошую схему безопасного программирования.

Для свопинга байтов в Windows можно использовать ntohs ()/ntohl () и/или htons ()/htonl () функции, определяемые в winsock2.h. Или можно записать некоторые простые стандартные программы, чтобы сделать это в C++, например:

inline unsigned short swap_16bit(unsigned short us)
{
    return (unsigned short)(((us & 0xFF00) >> 8) |
                            ((us & 0x00FF) << 8));
}

inline unsigned long swap_32bit(unsigned long ul)
{
    return (unsigned long)(((ul & 0xFF000000) >> 24) |
                           ((ul & 0x00FF0000) >>  8) |
                           ((ul & 0x0000FF00) <<  8) |
                           ((ul & 0x000000FF) << 24));
}

Простой способ решить это состоит в том, чтобы удостовериться, что генерирует байты, делает так в последовательном порядке байтов. Обычно "сетевой порядок байтов", используемый различным материалом TCP/IP, является лучшим: библиотечные подпрограммы htonl и ntohl работает очень хорошо с этим, и они обычно довольно хорошо оптимизируются.

Однако, если сетевой порядок байтов не используется, Вы, возможно, должны сделать вещи другими способами. Необходимо знать две вещи: размер целого числа и порядок байтов. После того как Вы знаете, что, знаете, сколько байтов для извлечения и в котором порядке соединить их в интервал

Некоторый пример кода, который принимает sizeof (интервал), является правильным числом байтов:

#include <limits.h>

int bytes_to_int_big_endian(const char *bytes)
{
    int i;
    int result;

    result = 0;
    for (i = 0; i < sizeof(int); ++i)
        result = (result << CHAR_BIT) + bytes[i];
    return result;
}

int bytes_to_int_little_endian(const char *bytes)
{
    int i;
    int result;

    result = 0;
    for (i = 0; i < sizeof(int); ++i)
        result += bytes[i] << (i * CHAR_BIT);
    return result;
}


#ifdef TEST

#include <stdio.h>

int main(void)
{
    const int correct = 0x01020304;
    const char little[] = "\x04\x03\x02\x01";
    const char big[] = "\x01\x02\x03\x04";

    printf("correct: %0x\n", correct);
    printf("from big-endian: %0x\n", bytes_to_int_big_endian(big));
    printf("from-little-endian: %0x\n", bytes_to_int_little_endian(little));
    return 0;
}

#endif

Как насчет

int int_from_bytes(const char * bytes, _Bool reverse)
{
    if(!reverse)
        return *(int *)(void *)bytes;

    char tmp[sizeof(int)];

    for(size_t i = sizeof(tmp); i--; ++bytes)
        tmp[i] = *bytes;

    return *(int *)(void *)tmp;
}

Вы использовали бы его как это:

int i = int_from_bytes(bytes, SYSTEM_ENDIANNESS != ARRAY_ENDIANNESS);

, Если Вы находитесь в системе, где кастинг void * к int * может привести к конфликтам выравнивания, можно использовать

int int_from_bytes(const char * bytes, _Bool reverse)
{
    int tmp;

    if(reverse)
    {
        for(size_t i = sizeof(tmp); i--; ++bytes)
            ((char *)&tmp)[i] = *bytes;
    }
    else memcpy(&tmp, bytes, sizeof(tmp));

    return tmp;
}

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

Почему считанный, когда можно просто выдержать сравнение?

bool AreEqual(int i, char *data)
{
   return memcmp(&i, data, sizeof(int)) == 0;
}

, Если Вы волнуетесь о порядке байтов, когда необходимо преобразовать все целые числа к некоторой инвариантной форме. htonl и ntohl являются хорошими примерами.

Просто используйте для цикла, который отодвигается массив в sizeof (международные) блоки.
Использование функция ntohl (найденный в заголовке <arpa/inet.h>, по крайней мере, на Linux) для преобразования из байтов в сетевом порядке (сетевой порядок определяется как обратный порядок байтов) к локальному порядку байтов. Та библиотечная функция реализована для выполнения преобразования нужной сети к хосту для любого процессора, на котором Вы работаете.

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

, Учитывая, что, Вы не можете только использовать для цикла?

void ReadBytes(char * stream) {
    for (int i = 0; i < sizeof(int); i++) {
        char foo = stream[i];
        }
    }
 }

Вы просящий что-то более сложное, чем это?