C++11 在C+中使用auto转换数据类型+；

我有两个向量容器，其中包含两种不同类型的值，数据类型为uint32\u t。我想把它们打印在一起。 这就是我所拥有的

vector<uint32_t> data1;
vector<uint32_t> data2;

向量数据1；
矢量数据2；

现在我知道了一种处理单个数据的方法，如下所示

for(auto const& d1: data1)
   cout<< d1 << endl;

for（自动常量&d1:data1）
cout使用Boost，这将使您拥有一个范围的对，而不是两个范围的向量数据类型。大致如下：

#include <boost/iterator/zip_iterator.hpp>
#include <boost/range.hpp>
#include <stdint.h>
#include <vector>
#include <iostream>

template <typename... TContainer>
auto zip(TContainer&... containers) -> boost::iterator_range<boost::zip_iterator<decltype(boost::make_tuple(std::begin(containers)...))>> {
    auto zip_begin = boost::make_zip_iterator(boost::make_tuple(std::begin(containers)...));
    auto zip_end = boost::make_zip_iterator(boost::make_tuple(std::end(containers)...));
    return boost::make_iterator_range(zip_begin, zip_end);
}

int main()
{
        std::vector<uint32_t> data1( { 11, 22, 33 } );
        std::vector<uint32_t> data2( { 44, 55, 66 } );
        for (auto t : zip(data1, data2)) {
                std::cout << boost::get<0>(t) << "\t" << boost::get<1>(t) << "\n";
        }
}

#包括
#包括
#包括
#包括
#包括
模板
自动压缩（TContainer&…containers）->boost:：iterator\u范围{
auto-zip_-begin=boost:：make_-zip_迭代器（boost:：make_-tuple（std:：begin（containers）…）；
auto-zip_-end=boost:：make_-zip_迭代器（boost:：make_-tuple（std:：end（containers）…）；
返回boost：：生成迭代器范围（zip\u开始，zip\u结束）；
}
int main（）
{
std：：向量数据1（{11,22,33}）；
std：：矢量数据2（{44,55,66}）；
用于（自动t:zip（数据1、数据2））{
std:：cout您可以在索引上使用正常for循环：

for (auto i = 0u; i != n; ++i)
    std::cout << data1[i] << "\t" << data2[i] << "\n";

但是由您来确保转换是安全的。也就是说，该值适合目标类型。
如果可能（并且对于您的用例是合理的）：使用成对的容器
如果您的应用程序不在绑定的w.r.t.计算机资源中，并且您知道您将以成对方式使用两个容器的值（假设容器的长度相同，如您的示例中所示），那么实际使用成对容器可能会很有用，这也简化了基于整洁范围的
for
循环的使用（>=C++11）

#包括
#包括
#包括
int main（）
{
向量数据1={1,2,3}；
向量数据2={4,5,6}；
//构造（int，int）对的容器
std：：矢量数据；
data.reserve（data1.size（））；
std:：transform（data1.begin（）、data1.end（）、data2.begin（）、std:：back_插入器（data），
[]（uint32第一，uint32第二）{
return std:：make_pair（静态_cast（第一）、静态_cast（第二））；
})/*正如公认的答案所指出的：你要对
确保此处的转换是安全的*/
//轻松使用基于范围的for循环遍历
//你的两个集装箱
用于（常数自动和配对：数据）{
std：：cout
data1
的类型是什么？
vector data1
哦，所以你得到了
vector data1
和
vector data2
，你想在相应的值旁边显示
data1
中的每个值（相同的索引）从
data2
？很抱歉信息太少。请查看编辑后的问题并给出一些建议。@HarshPatel
auto
不会转换类型。而且也没有任何转换的理由。
std:：cout
可以输出
unint32\u t
很好。我有点假设OP想要更华丽的东西，但是，是的。+1@einpoklum我仍然不确定OP想要什么。@einpoklum很抱歉我对stackoverflow（以及编程）很陌生。那么你能告诉我OP是什么意思吗？它像“原始出版商”？@HarshPatel“原始海报”，即you@HarshPatel很乐意帮忙。
for (auto i = 0u; i != n; ++i)
    std::cout << data1[i] << "\t" << data2[i] << "\n";

auto d1 = static_cast<int>(data1[i]);

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

int main()
{
  std::vector<uint32_t> data1 = {1, 2, 3};
  std::vector<uint32_t> data2 = {4, 5, 6};

  // construct container of (int, int) pairs
  std::vector<std::pair<int, int>> data;
  data.reserve(data1.size());
  std::transform(data1.begin(), data1.end(), data2.begin(), std::back_inserter(data),
                 [](uint32_t first, uint32_t second) {
                   return std::make_pair(static_cast<int>(first), static_cast<int>(second));
                 });   /* as noted in accepted answer: you're responsible for
                          ensuring that the conversion here is safe */

  // easily use range-based for loops to traverse of the
  // pairs of your container
  for(const auto& pair: data) {
    std::cout << pair.first << " " << pair.second << "\n";
  } /* 1 4
       2 5
       3 6 */

  return 0;
}