C++ unsigned char* 转 int*,操作符重载,隐式类型转换

unsigned char * data;
data是内存连续的数组，size很长，需要转换成 int * ints;
其中 每三个char组合一个int
比如

ints[0] = (data[0]<< 16) | (data[1]<< 8 ) | data[2] ;

我不希望用for循环遍历算出来,以及频繁的内存拷贝操作，效率太低

下面是我没走通的路子：

typedef struct int24 {
    uchar r, g, b;
    operator int() {
            return b | (g << 8) | (r << 16);
    }
}

unsigned char * data = ...
int24 * tmp = (int24 * ) data;
int *  ints = (int * ) tmp;

使用int * ints = (int * ) tmp毫无意义，还是指针转换，没能应用到重载操作符类型转换

最终结果是得到int * ，是否有别的方法？望指教。

 typedef struct int24 {
    unsigned char start;

    const int operator[](int index) const 
    {
        const unsigned char* pStart = &start;
        return pStart[2 + index * 3] | (pStart[1 + index * 3] << 8) | (pStart[0 + index * 3] << 16);
    }
}int24;

int main(int argc, char* argv[])
{
    unsigned char data[1024] = {0,1,1, 0,0,1, 0,1,0, 0};
    int24* tmp = (int24 *) data;
    int24& int24Object = *tmp;

    printf("front three num %d, %d, %d", int24Object[0], int24Object[1], int24Object[2]);

    return 0;
}

也可以这样，输出结果为：front three num 257, 1, 256

24bit写来写去效率都不可能高，因为数据不对齐。底层硬件就决定了这一点，在c++层面折腾只是徒劳。
数据不对齐意味着产生的机器指令的load/store都是交错的，完全浪费了cpu的fetch
需要搞清楚你的上层需求，然后完整地考虑这个问题。

直接把
operator int() {
return b | (g << 8) | (r << 16);
}
写成一个普通方法，比如
int result() {
return b | (g << 8) | (r << 16);
}
然后直接用指针调用可以吗？
int ints = tmp->result();

试试这样写呢？

 typedef struct int24 {
    unsigned char start;
    int operator[](int index) {
        unsigned char* pStart = &start;
        return pStart[2 + index * 3] | (pStart[1 + index * 3] << 8) | (pStart[0 + index * 3] << 16);
    }
}int24;

int main(int argc, char* argv[])
{
    unsigned char data[1024] = {0,1,1, 0,0,1, 0,1,0, 0};
    int24* tmp = (int24 *) data;

    printf("front three num %d, %d, %d", tmp->operator[](0), tmp->operator[](1), tmp->operator[](2));

    return 0;
}