c++ 17:是的!您应该使用结构化的绑定声明。gcc和clang从gcc-7和clang-4.0 (clang live示例)开始支持该语法。这允许我们像这样解包元组:

for (auto [i, f, s] = std::tuple{1, 1.0, std::string{"ab"}}; i < N; ++i, f += 1.5) {
    // ...
}

以上会给你:

Int I设置为1 双f设置为1.0 Std::字符串设置为“ab”

对于这种声明，请确保使用#include <tuple>。

如果你想要命名一个类型，你可以在元组中指定准确的类型，就像我用std::string一样。例如:

auto [vec, i32] = std::tuple{std::vector<int>{3, 4, 5}, std::int32_t{12}}

它的一个具体应用是遍历一个map，获取键和值，

std::unordered_map<K, V> m = { /*...*/ };
for (auto& [key, value] : m) {
   // ...
}

这里有一个生动的例子

c++ 14:你可以像c++ 11(如下)一样，添加基于类型的std::get。因此，你可以使用std::get<int>(t)而不是下面例子中的std::get<0>(t)。

c++ 11: std::make_pair允许你这样做，std::make_tuple也可以用于两个以上的对象。

for (auto p = std::make_pair(5, std::string("Hello World")); p.first < 10; ++p.first) {
    std::cout << p.second << '\n';
}

Std::make_pair将返回Std::pair中的两个参数。元素可以通过.first和.second访问。

对于两个以上的对象，您将需要使用std::tuple

for (auto t = std::make_tuple(0, std::string("Hello world"), std::vector<int>{});
        std::get<0>(t) < 10;
        ++std::get<0>(t)) {
    std::cout << std::get<1>(t) << '\n'; // cout Hello world
    std::get<2>(t).push_back(std::get<0>(t)); // add counter value to the vector
}

make_tuple是一个可变参数模板，它将构造一个包含任意数量参数的元组(当然有一些技术限制)。元素可以通过std::get< index的索引访问>(tuple_object)

在for循环体中，你可以很容易地将对象别名化，尽管你仍然需要为for循环条件和更新表达式使用.first或std::get

for (auto t = std::make_tuple(0, std::string("Hello world"), std::vector<int>{});
        std::get<0>(t) < 10;
        ++std::get<0>(t)) {
    auto& i = std::get<0>(t);
    auto& s = std::get<1>(t);
    auto& v = std::get<2>(t);
    std::cout << s << '\n'; // cout Hello world
    v.push_back(i); // add counter value to the vector
}

可以显式地命名std::pair的类型。但是，没有标准的方法可以将其概括为两种以上的类型:

for (std::pair<int, std::string> p(5, "Hello World"); p.first < 10; ++p.first) {
    std::cout << p.second << '\n';
}

c++ 17:是的!您应该使用结构化的绑定声明。gcc和clang从gcc-7和clang-4.0 (clang live示例)开始支持该语法。这允许我们像这样解包元组:

for (auto [i, f, s] = std::tuple{1, 1.0, std::string{"ab"}}; i < N; ++i, f += 1.5) {
    // ...
}

以上会给你:

Int I设置为1 双f设置为1.0 Std::字符串设置为“ab”

对于这种声明，请确保使用#include <tuple>。

如果你想要命名一个类型，你可以在元组中指定准确的类型，就像我用std::string一样。例如:

auto [vec, i32] = std::tuple{std::vector<int>{3, 4, 5}, std::int32_t{12}}

它的一个具体应用是遍历一个map，获取键和值，

std::unordered_map<K, V> m = { /*...*/ };
for (auto& [key, value] : m) {
   // ...
}

这里有一个生动的例子

c++ 14:你可以像c++ 11(如下)一样，添加基于类型的std::get。因此，你可以使用std::get<int>(t)而不是下面例子中的std::get<0>(t)。

c++ 11: std::make_pair允许你这样做，std::make_tuple也可以用于两个以上的对象。

for (auto p = std::make_pair(5, std::string("Hello World")); p.first < 10; ++p.first) {
    std::cout << p.second << '\n';
}

Std::make_pair将返回Std::pair中的两个参数。元素可以通过.first和.second访问。

对于两个以上的对象，您将需要使用std::tuple

for (auto t = std::make_tuple(0, std::string("Hello world"), std::vector<int>{});
        std::get<0>(t) < 10;
        ++std::get<0>(t)) {
    std::cout << std::get<1>(t) << '\n'; // cout Hello world
    std::get<2>(t).push_back(std::get<0>(t)); // add counter value to the vector
}

make_tuple是一个可变参数模板，它将构造一个包含任意数量参数的元组(当然有一些技术限制)。元素可以通过std::get< index的索引访问>(tuple_object)

在for循环体中，你可以很容易地将对象别名化，尽管你仍然需要为for循环条件和更新表达式使用.first或std::get

for (auto t = std::make_tuple(0, std::string("Hello world"), std::vector<int>{});
        std::get<0>(t) < 10;
        ++std::get<0>(t)) {
    auto& i = std::get<0>(t);
    auto& s = std::get<1>(t);
    auto& v = std::get<2>(t);
    std::cout << s << '\n'; // cout Hello world
    v.push_back(i); // add counter value to the vector
}

可以显式地命名std::pair的类型。但是，没有标准的方法可以将其概括为两种以上的类型:

for (std::pair<int, std::string> p(5, "Hello World"); p.first < 10; ++p.first) {
    std::cout << p.second << '\n';
}

你也可以像下面这样在c++中使用。

int j=3;
int i=2;
for (; i<n && j<n ; j=j+2, i=i+2){
  // your code
}

不可能，但你可以:

float f;
int i;
for (i = 0,f = 0.0; i < 5; i++)
{
  //...
}

或者，使用额外的括号显式限制f和i的范围:

{
    float f; 
    int i;
    for (i = 0,f = 0.0; i < 5; i++)
    {
       //...
    }
}

参见“是否有方法在for循环中定义两种类型的变量?”了解另一种涉及嵌套多个for循环的方法。与Georg的“结构技巧”相比，另一种方法的优势在于:(1)允许你混合使用静态和非静态局部变量;(2)允许你使用不可复制的变量。缺点是可读性差得多，效率也可能较低。

你不能在初始化时声明多个类型，但是你可以赋值给多个类型

{
   int i;
   char x;
   for(i = 0, x = 'p'; ...){
      ...
   }
}

只是在它们自己的范围内声明它们。