¿Es posible declarar dos variables de diferentes tipos en un ciclo for?

¿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 un int y un char en el cuerpo de inicialización? ¿Cómo se haría esto?

No es posible, pero puedes hacer:

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

O bien, limite explícitamente el scope de f usando paréntesis adicionales:

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

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

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

C ++ 17 : debe usar una statement de enlace estructurado . La syntax es compatible con gcc-7 y clang-4.0 ( ejemplo vivo de clang ). Esto nos permite desempaquetar una tupla como esta:

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

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


C ++ 11 : std::make_pair permite hacer esto, así como std::make_tuple para 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_pair devolverá los dos argumentos en un std::pair . Se puede acceder a los elementos con .second y .second .

Para más de dos objetos, necesitarás usar un std::tuple

 for (auto t = std::make_tuple(0, std::string("Hello world"), std::vector{}); 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_tuple es una plantilla variadica que construirá una tupla de cualquier cantidad de argumentos (con algunas limitaciones técnicas, por supuesto). Se puede acceder a los elementos por índice con std::get(tuple_object)

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

 for (auto t = std::make_tuple(0, std::string("Hello world"), std::vector{}); 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 un std::pair . Sin embargo, no hay una forma estándar de generalizar esto en más de dos tipos:

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

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

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

Simplemente declare en su propio scope.

Consulte ” ¿Hay alguna forma de definir variables de dos tipos en for loop? ” Para otra forma de anidar múltiples bucles for. La ventaja de la otra manera sobre el “truco de estructuras” 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 que no se pueden copiar. 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 bucle for de esta manera.