【问题标题】:Convert a vector<unsigned char> to vector<unsigned short>将向量<unsigned char> 转换为向量<unsigned short>
【发布时间】:2009-12-13 23:34:05
【问题描述】:

我正在从二进制文件中获取数据,从文件中读取数据并写入无符号字符向量。我无法编辑它,因为我使用的是外部库。

但我从文件中读取的数据是 16 位图像,我想将数据放入无符号短向量中

也许我可以为它做一个演员表?

Rgds.

【问题讨论】:

标签: c++


【解决方案1】:

通用方法(非防弹):

#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>

typedef unsigned char u8;
typedef unsigned short u16;

u16 combine_two_bytes(u8 a, u8 b) {
    return a | (b << 8);
}

template<typename InIter, typename OutIter, typename InT, typename OutT>
void combine_pairs(InIter in, InIter in_end, OutIter out, OutT (*func)(InT, InT)) {
    while(1) {
        if(in == in_end) {
            break;
        }

        InT &left = *in++;

        if(in == in_end) {
            break;
        }

        InT &right = *in++;

        *out++ = func(left, right);
    }
}

int main() {
    using namespace std;    // lazy

    u8 input[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    const size_t in_size = sizeof(input) / sizeof(*input);
    u16 output[in_size / 2];

    cout << "Original: ";
    copy(input, input + in_size, ostream_iterator<int>(cout, " "));
    cout << endl;

    combine_pairs(input, input + in_size, output, combine_two_bytes);

    cout << "Transformed: ";
    copy(output, output + in_size / 2, ostream_iterator<int>(cout, " "));
    cout << endl;

    return 0;
}

【讨论】:

  • 非常好。一个小的批评是,由于 for 循环中的语句“i += 2”,您的代码仅限于随机访问容器。如果将其更改为“std::advance(i, 2)”,它将适用于所有容器(并且对于随机访问迭代器将继续保持恒定时间)。
  • @Klatchko,感谢您的评论。你是对的,代码仅限于随机访问迭代器。然而,即使使用std::advance,我也检查了i + 1,这不能使用所有容器来完成。我重新编写了代码,希望它现在可以更好地工作(并且更安全)。
【解决方案2】:

如果您只想从一种类型转换为另一种类型,请使用标准构造函数。只要迭代器值类型可自动转换为目标向量值类型,编译器就会在两种类型之间进行自动转换。只需使用标准构造函数

#include <vector>
#include <algorithm>
#include <iterator>

int main()
{
    std::vector<unsigned char>      a;
    a.push_back((unsigned char)12);
    a.push_back((unsigned char)13);
    a.push_back((unsigned char)14);

    std::vector<unsigned short>     b(a.begin(),a.end());

    // Print out the vector
    std::copy(b.begin(),b.end(),std::ostream_iterator<unsigned short>(std::cout,"\t"));
}

> g++ t.cpp
> ./a.out
12  13 14

如果您真的想将两个字节转换为一个,则需要做一些工作。但这取决于输入数据是否实际上与您所在的机器相同。如果你知道它是相同的字节序,你只需要转换输入类型。

#include <vector>
#include <algorithm>
#include <iterator>

int main()
{
    std::vector<unsigned char>      a;

    // Make sure that the size is correct.
    // ie. An Odd number indicates that something is not quite correct.
    //
    std::vector<unsigned short>     b(static_cast<unsigned short*>(&a[0]),
                                      static_cast<unsigned short*>(&a[a.size()]));

    // Print out the vector
    std::copy(b.begin(),b.end(),std::ostream_iterator<unsigned short>(std::cout,"\t"));
}

或者,如果您确实需要将两个值组合成一个字节序与目标架构不同的单个值,您可以编写一个特殊的迭代器。像这样的:

#include <Converter.h>

int main()
{
    std::vector<unsigned char>      a;

    // Make sure that the size is correct.
    // ie. An Odd number indicates that something is not quite correct.
    //
    std::vector<unsigned short>     b(make_Converter(a.begin()),make_Converter(a.end()));

    // Print out the vector
    std::copy(b.begin(),b.end(),std::ostream_iterator<unsigned short>(std::cout,"\t"));
}

转换器.h

#include <vector>
#include <iostream>
#include <iterator>

template<typename I>
struct Converter
{
    I   iterator;

    typedef typename std::input_iterator_tag                    iterator_category;
    typedef typename std::iterator_traits<I>::value_type        value_type;
    typedef typename std::iterator_traits<I>::difference_type   difference_type;
    typedef typename std::iterator_traits<I>::pointer           pointer;
    typedef typename std::iterator_traits<I>::reference         reference;

    Converter(I iter)
        :iterator(iter)
    {}

    Converter& operator++()
    {
        iterator++;
        return *this;
    }

    Converter operator++(int)
    {
        Converter   tmp(*this);
        this->operator++();

        return (tmp);
    }

    value_type operator*()
    {
        /*
         * The actual calculation done here will depend on the underlying hardware.
         */
        typename std::iterator_traits<I>::value_type val(*iterator);
        val << 8;
        iterator++;
        val |= (*iterator);

        return val;
    }

    bool operator!=(Converter const& rhs)
    {
        return iterator != rhs.iterator;
    }
};

template<typename I>
Converter<I> make_Converter(I iter)
{
    return Converter<I>(iter);
}

【讨论】:

    【解决方案3】:
    vector<unsigned char> a = ...;
    vector<unsigned short> b(a.begin(), a.end());
    

    但您希望 valarrays 用于简单的数据向量。

    【讨论】:

    • 我不知道他是否希望他的 n 个无符号字符向量变成 n 个无符号短裤或 n/2 个无符号短裤的向量。如果他想要 n/2 个元素,看起来他假设 unsigned short 是 2 个字节。但上述问题尚不清楚。
    【解决方案4】:

    假设您文件中的二进制数据是小端顺序,我会以简单的方式做到这一点:

    vector<unsigned char> a = ...;
    
    std::vector<unsigned short> b;
    b.reserve( a.size() / sizeof(unsigned short) );
    
    for( std::vector<unsigned char>::const_iterator i=a.begin(); i!=a.end(); i+=2 )
    {
        unsigned short shortValue = *(i+1);
        shortValue <<= 8;
        shortValue |= *i;
        b.push_back( shortValue );
    }
    

    如果文件中的数据是大端数据,则需要以相反的方式组合短值。您还应该注意“a”中的条目数不是 2 的倍数。

    【讨论】:

      【解决方案5】:

      免责声明:我现在没有编译器:

      vector<unsigned char> vec = getVector();
      vector<unsigned short> sv(reinterpret_cast<unsigned short*>(&vec[0]), 
                                reinterpret_cast<unsigned short*>(&vec[vec.size()]));
      

      【讨论】:

      • 不需要做演员表。 Vector 有一个带有两个迭代器的构造函数。只要迭代器的值类型可以转换为目标容器的值类型,编译器就会做正确的事情。
      • @Martin York:除了他不想将chars 转换为shorts,他希望将它们重新解释为短裤。
      • @rlbond:这值得商榷。这取决于您如何阅读问题。由于问题下的评论,它会这样倾斜。
      • 实际上没有争议:数据代表“16位图像”,即取回每个单词的唯一方法是组合2个字节。将每个字节扩大到 16 位将无济于事。
      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2016-05-30
      • 2012-12-22
      • 2015-01-20
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多