Est-il possible de déclarer deux variables de types différents dans le corps d'initialisation d'une boucle for en C ++?

Par exemple:

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

définit deux entiers. Puis-je définir un intet un chardans le corps d'initialisation? Comment cela se ferait-il?

C ++ 17 : Oui! Vous devez utiliser une déclaration contraignante structurée . La syntaxe est prise en charge dans gcc et clang depuis des années (depuis gcc-7 et clang-4.0) ( exemple live clang ). Cela nous permet de décompresser un tuple comme ceci:

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

Ce qui précède vous donnera:

• int i mis à 1
• double f mis à 1.0
• std::string s mis à "ab"

Assurez-vous de #include <tuple>ce type de déclaration.

Vous pouvez spécifier les types exacts à l'intérieur du tupleen les tapant tous comme je l'ai fait avec le std::string, si vous voulez nommer un type. Par exemple:

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

Une application spécifique de cela est l'itération sur une carte, l'obtention de la clé et de la valeur,

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

Voir un exemple en direct ici

C ++ 14 : vous pouvez faire la même chose que C ++ 11 (ci-dessous) avec l'ajout de type std::get. Donc, au lieu de std::get<0>(t)dans l'exemple ci-dessous, vous pouvez avoir std::get<int>(t).

C ++ 11 : std::make_pairvous permet de le faire, ainsi que std::make_tuplepour plus de deux objets.

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

std::make_pairrenverra les deux arguments dans un std::pair. Les éléments sont accessibles avec .firstet .second.

Pour plus de deux objets, vous devrez utiliser 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_tupleest un modèle variadique qui va construire un tuple de n'importe quel nombre d'arguments (avec quelques limitations techniques bien sûr). Les éléments sont accessibles par index avecstd::get<INDEX>(tuple_object)

Dans les corps de boucle for, vous pouvez facilement aliaser les objets, même si vous devez toujours utiliser .firstou std::getpour la condition de boucle for et l'expression de mise à jour

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 et C ++ 03 Vous pouvez nommer explicitement les types de a std::pair. Il n'y a pas de moyen standard de généraliser cela à plus de deux types:

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

Non - mais techniquement, il existe une solution de contournement (pas que je l'utilise en fait à moins d'y être forcé):

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

Pas possible, mais vous pouvez faire:

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

Ou, limitez explicitement la portée fet l' iutilisation de supports supplémentaires:

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

Vous ne pouvez pas déclarer plusieurs types dans l'initialisation, mais vous pouvez attribuer à plusieurs types EG

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

Déclarez-les simplement dans leur propre champ d'application.

Je pense que la meilleure approche est la réponse de xian .

mais...

# Imbriqué pour la boucle

Cette approche est sale, mais peut résoudre toutes les versions.

donc je l'utilise souvent dans les fonctions 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
    }

Supplémentaire 1.

Il peut également être utilisé pour declare local variableset 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.
    }

Supplémentaire 2.

Bon exemple: avec fonction macro.

(Si la meilleure approche ne peut pas être utilisée car il s'agit d'une macro for-loop)

#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
    }

# Astuce if-statement

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

Si vous souhaitez initialiser à 0ou nullptr, vous pouvez utiliser cette astuce.

mais je ne le recommande pas à cause d'une lecture difficile.

et cela ressemble à un bug.

Voir « Existe-t-il un moyen de définir des variables de deux types dans la boucle for? » Pour une autre méthode impliquant l'imbrication de plusieurs boucles. L'avantage de l'autre sens par rapport au "struct trick" de Georg est qu'il (1) vous permet d'avoir un mélange de variables locales statiques et non statiques et (2) il vous permet d'avoir des variables non copiables. L'inconvénient est qu'il est beaucoup moins lisible et peut être moins efficace.

Définissez une 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++)
{
  //...
}

N'oubliez pas que vos étendues variables ne seront pas non plus dans la boucle for de cette façon.

Vous pouvez également utiliser comme ci-dessous en C ++.

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