如何更有效地遍历存储{int，short，ushort，...}的字符数组？

Question

I have a char data[len] populated from unzipped data that is read off of a binary file. I know that data can only be of these types: char, uchar, short, ushort, int, uint, float, double for which I know exact number of bits needed to represent ( elesize = {8, 16, 32, 64} ).

I just want to traverse the data list and, say, find the max() , min() or number of occurrences of a given number. and I want to do this without creating another array for memory space concerns.

I have come up with the following but it is slow for example for len == 34560000

So I was wondering if anyone has a 'one-liner' or a more efficient way for doing this (either C or C++).

char data[len];
double mymax = -std::numeric_limits<double>::max()
for (size_t i=0; i<len; i += elesize)
{
    double x;
    char *r = data+i;
    if (elementtype == "char")
        x = static_cast<double>(*r);
    else if (elementtype == "uchar")
        x = static_cast<double>(*((unsigned char *)r));
    else if (elementtype == "short")
        x = static_cast<double>(*((int16_t *)r));
    else if (elementtype == "ushort")
        x = static_cast<double>(*((uint16_t *)r));
    else if (elementtype == "int")
        x = static_cast<double>(*((int32_t *)r));
    else if (elementtype == "uint")
        x = static_cast<double>(*((uint32_t *)r));
    else if (elementtype == "float")
        x = static_cast<double>(*((float *)r));
    else if (elementtype == "double")
        x = *((double *)r);
    if (x > mymax)
        mymax = x;
}

Answer 1

A template should do nicely:

#include <algorithm>

template <typename T>
T read_and_advance(const unsigned char * & p)
{
  T x;
  unsigned char * const px = reinterpret_cast<unsigned char *>(&x);

  std::copy(p, p + sizeof(T), px);
  P += sizeof(T);

  return x;
}

Usage:

const unsigned char * p = the_data;
unsigned int max = 0;

while (p != the_data + data_length)
{
  max = std::max(max, read_and_advance<unsigned int>(p));
}

---

Scrap this, I thought originally the question was for C.

Here's a macro:

 #define READ_TYPE(T, buf, res) do { memcpy(&res, buf, sizeof(T)); buf += sizeof(T); } while (false) 

Usage:

 int max = 0; unsigned char * p = data; while (true) { unsigned int res; READ_TYPE(unsigned int, p, res); if (res > max) max = res; } 

You don't really get around specifying the type , though. In C++ this could be done a bit more elegantly.

Alternatively you can wrap it all in one:

 #define READ_TYPE_AND_MAX(T, buf, max) \\ do { T x; memcpy(&x, buf, sizeof(T)); \\ buf += sizeof(T); \\ if (max < x) max = x; \\ } while (false) // Usage: unsigned int max = 0; unsigned char * p = data; while (true) { READ_TYPE_AND_MAX(unsigned int, p, max); } 

Answer 2

Given that elementtype is loop-invariant, you would better do the comparison only once outside the for . By the way, I hope elementtype is of type std::string or something that meaningfully compares to string literals.

Ultimately, I would write a template function that does the whole processing loop and then call it with the appropiate template argument according to elementtype .

Answer 3

Put the conditional code outside the loop, so the loop runs fast. Try something like this:

char data[len];
double mymax = -std::numeric_limits<double>::max()
double x;
if (elementtype == "char") {
  for (size_t i=0; i<len; i += elesize) {
    char *r = data+i;
    x = static_cast<double>(*r);
    if (x > mymax)  mymax = x;
  }
}else if (elementtype == "uchar") {
  for (size_t i=0; i<len; i += elesize) {
    char *r = data+i;
    x = static_cast<double>(*((unsigned char *)r));
    if (x > mymax)  mymax = x;
  }
}else if (elementtype == "short")

..etc..etc

Answer 4

As others indicated, you should check the type only once. Then you should call appropriate sub-function that only deals with one type. You should also not be casting to doubles for comparing to my_max when the elementtype is not double. Otherwise you are needlessly converting to double and doing comparisons with doubles. If elementtype is uint, then you should never be converting anything to double, just compare with a my_max var that is also uint.