¿Es posible declarar dos variables de diferentes tipos en el cuerpo de inicialización de un bucle for en C ++?

Por ejemplo:

for(int i=0,j=0 ...

define dos enteros. ¿Puedo definir una inty a charen el cuerpo de inicialización? ¿Cómo se haría esto?

C ++ 17 : ¡Sí! Debe usar una declaración vinculante estructurada . La sintaxis ha sido compatible con gcc y clang durante años (desde gcc-7 y clang-4.0) ( ejemplo de clang live ). Esto nos permite descomprimir una tupla así:

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

Lo anterior te dará:

• int i ajustado a 1
• double f ajustado a 1.0
• std::string s ajustado a "ab"

Asegúrese de que #include <tuple>para este tipo de declaración.

Puede especificar los tipos exactos dentro tuplede, escribiéndolos todos como tengo con el std::string, si desea nombrar un tipo. Por ejemplo:

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

Una aplicación específica de esto es iterar sobre un mapa, obtener la clave y el valor,

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

Vea un ejemplo en vivo aquí

C ++ 14 : puede hacer lo mismo que C ++ 11 (a continuación) con la adición de tipo basado std::get. Entonces, en lugar del std::get<0>(t)ejemplo a continuación, puede tener std::get<int>(t).

C ++ 11 : le std::make_pairpermite hacer esto, así como std::make_tuplepara más de dos objetos.

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

std::make_pairdevolverá los dos argumentos en a std::pair. Se puede acceder a los elementos con .firsty .second.

Para más de dos objetos, deberá usar un 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) << std::endl; // cout Hello world
    std::get<2>(t).push_back(std::get<0>(t)); // add counter value to the vector
}

std::make_tuplees una plantilla variada que construirá una tupla de cualquier número de argumentos (con algunas limitaciones técnicas, por supuesto). Se puede acceder a los elementos por índice constd::get<INDEX>(tuple_object)

Dentro de los cuerpos del bucle for puede alias fácilmente los objetos, aunque todavía necesita usar .firsto std::getpara la condición del bucle for y actualizar la expresión

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 << std::endl; // cout Hello world
    v.push_back(i); // add counter value to the vector
}

C ++ 98 y C ++ 03 Puede nombrar explícitamente los tipos de a std::pair. Sin embargo, no hay una forma estándar de generalizar esto a más de dos tipos:

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

No, pero técnicamente hay una solución alternativa (no es que realmente lo use a menos que me obligue):

for(struct { int a; char b; } s = { 0, 'a' } ; s.a < 5 ; ++s.a) 
{
    std::cout << s.a << " " << s.b << std::endl;
}

No es posible, pero puedes hacer:

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

O limite explícitamente el alcance fy el iuso de corchetes adicionales:

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

No puede declarar varios tipos en la inicialización, pero puede asignar a varios tipos EG

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

Simplemente declararlos en su propio alcance.

Creo que el mejor enfoque es la respuesta de xian .

pero...

# Anidado para bucle

Este enfoque es sucio, pero puede resolverse en todas las versiones.

entonces, a menudo lo uso en funciones macro.

for(int _int=0, /* make local variable */ \
    loopOnce=true; loopOnce==true; loopOnce=false)

    for(char _char=0; _char<3; _char++)
    {
        // do anything with
        // _int, _char
    }

Adicional 1.

También se puede usar para declare local variablesy initialize global variables.

float globalFloat;

for(int localInt=0, /* decalre local variable */ \
    _=1;_;_=0)

    for(globalFloat=2.f; localInt<3; localInt++) /* initialize global variable */
    {
        // do.
    }

Adicional 2.

Buen ejemplo: con función macro.

(Si el mejor enfoque no se puede usar porque es una macro para bucle for)

#define for_two_decl(_decl_1, _decl_2, cond, incr) \
for(_decl_1, _=1;_;_=0)\
    for(_decl_2; (cond); (incr))


    for_two_decl(int i=0, char c=0, i<3, i++)
    {
        // your body with
        // i, c
    }

# Truco de declaración if

if (A* a=nullptr);
else
    for(...) // a is visible

Si desea inicializar a 0o nullptr, puede utilizar este truco.

pero no recomiendo esto debido a la lectura difícil.

y parece un error

Consulte " ¿Hay alguna forma de definir variables de dos tipos en for loop? " Para conocer otra forma de anidar múltiples for loops. La ventaja de la otra manera sobre el "truco de estructura" de Georg es que (1) le permite tener una mezcla de variables locales estáticas y no estáticas y (2) le permite tener variables no copiables. La desventaja es que es mucho menos legible y puede ser menos eficiente.

Definir una macro:

#define FOR( typeX,x,valueX,  typeY,y,valueY,  condition, increments) typeX x; typeY y; for(x=valueX,y=valueY;condition;increments)

FOR(int,i,0,  int,f,0.0,  i < 5, i++)
{
  //...
}

Solo recuerde, sus ámbitos variables tampoco estarán dentro del ciclo for de esta manera.

También podría usar como a continuación en C ++.

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