Comment puis-je déclarer et définir plusieurs variables dans une ligne à l'aide de C++?

J'ai toujours mais que, si je déclare ces trois variables qu'ils auront tous la valeur 0

int column, row, index = 0;

Mais je trouve que le seul indice est égal à zéro & les autres sont ordure comme 844553 & 2423445.

Comment puis-je initialiser toutes ces variables à zéro, sans le déclarer chaque variable sur une nouvelle ligne?

  • Attention à ceux qui, d'une ligne multi-déclarations de variables. Il est plus facile que vous le pensez à déclarer un pointeur de int suivie par une liste des entiers (int* a, b, c; ne pas faire ce à quoi il ressemble).
  • Il y a seulement trois variables, mec, écrire =0 pour chacun dans leurs définitions. Et, si vous voulez vraiment de nombreuses variables, puis essayez un tableau: int a[10]={0} d'initialiser chaque a[i] à 0 pour vous.
  • Le compilateur ne doit pas permettre que de construire si elle va se comporter différemment de ce qu'est un raisonnable programmeur pourrait s'attendre à faire...à mon humble avis
  • Raisonnable programmeur pourrait penser: "hmm, cette syntaxe pourrait signifier un couple de choses différentes en fonction de la façon dont la grammaire lie les choses", de rechercher le Standard pour savoir ce qui est vrai, et de s'en sortir.
InformationsquelleAutor Sam | 2011-07-27
  1. 176
    int column = 0, row = 0, index = 0;
    InformationsquelleAutor Josh
  2. 131

    Lorsque vous déclarez:

    int column, row, index = 0;

    Seulement l'index est mis à zéro.

    Cependant, vous pouvez effectuer les opérations suivantes:

    int column, row, index;
column = index = row = 0;

    Mais personnellement, je préfère le suivant qui a été souligné.

    C'est une forme plus lisible à mon avis.

    int column = 0, row = 0, index = 0;

    ou

    int column = 0;
int row = 0;
int index = 0;
    • Entre les deux derniers j'ai décider si les deux valeurs doivent vraiment être du même type (bool previousInputValue, presentInputValue;) ou si ils ont juste arriver à être le même type maintenant, mais n'ont pas vraiment besoin d'être (uint8_t height, width; pourrait se transformer en uint8_t height; uint16_t width; dans l'avenir et doit avoir été uint8_t height; uint8_t width; pour commencer).
    • Parce que l'écriture de uint8_t height; uint16_t width; au lieu de uint8_t height, width; permet d'économiser de 10 caractères dans le futur. 🙂 vous pouvez bien sûr le faire comme il vous plaît. Assurez-vous de le rendre facile à lire. Ainsi, la dernière forme est la plus explicite.
    • La dernière forme est certainement le plus explicite en précisant le type de chaque variable et de le rendre clair que chacun est initialisé. Cela dit, il n'est pas explicite quant à savoir si ou non de ligne et de colonne sont censés être du même type ou non. Peut-être que nous serions tous deux préfèrent le caractère explicite de int presentValue = 0; typeof(presentValue) previousValue = presentValue;, mais je crois que typeof() est un non-standard GCC extension.
    InformationsquelleAutor Matt
  3. 39

    Comme @Josh dit, la réponse correcte est:

    int column = 0,
    row = 0,
    index = 0;

    Vous aurez besoin pour regarder dehors pour la même chose avec des pointeurs. Ce:

    int* a, b, c;

    Est équivalent à:

    int *a;
int b;
int c;
    • Je déteste que le pointeur de la chose, il ne fait aucun sens. L'astérisque est partie du type, de sorte qu'il devrait s'appliquer à tous. Imaginez si unsigned long x, y; déclaré x comme unsigned long mais y comme juste unsigned, aka unsigned int! C'est exactement la même! </rant>
    • Cela a du sens. "int *a, b, c;"
    • Et bien oui, c'est logique, si vous écrivez votre pointeur astérisques à côté du nom de la variable à la place du type, mais qui en soi n'a aucun sens. Comme je l'ai dit ci-dessus, l'astérisque est une partie de la nature, ne fait pas partie du nom, donc il doit regroupé avec le type!
    • Pas vraiment, vous déclarez b, c et la valeur des points pour que les nombres entiers.
    • OK, je suppose que je vois que la logique, mais il semble encore tout à fait contre-intuitif pour moi. Eh bien, c'est à peine va changer pour moi!
    • Comme un côté pas, en fait, ça a du sens le l' * n'est pas nécessairement partie de la nature, comme le int *a signifie que *a représente un int valeur.
    • Le point a déjà été fait, mais juste pour ajouter à ce vide est essentiellement l'absence d'un type, mais vous pouvez toujours faire des pointeurs vers elle. Donc pourquoi void* a de compiler et void *a, b, c ne sera pas. Cette rationalisation fonctionne pour moi.
    • Je pense qu'il devrait être noté que la même chose est valable pour les références (&). Aussi, si vous les voulez tous être des pointeurs alors vous pourriez écrire int *a, *b;. Je crois que c'est encore une partie de C++ seulement en raison de la compatibilité.

    InformationsquelleAutor Mateen Ulhaq
  4. 22

    Si vous déclarez une variable/objet par ligne non seulement permet-il de résoudre ce problème, mais il rend le code plus clair et évite des erreurs stupides lors de la déclaration de pointeurs.

    Pour répondre à votre question, vous devez l'initialiser chaque variable à 0 explicitement. int a = 0, b = 0, c = 0;.

    InformationsquelleAutor Mark B
  5. 15
    int column(0), row(0), index(0);

    De noter que ce formulaire sera de travailler avec le type personnalisé est trop, surtout quand leurs constructeurs prendre plus d'un argument.

    • et aujourd'hui, avec l'uniforme d'initialisation (en cours C++17 de la résolution de ce pour auto...): int colonne { 0 } , ligne { 0 } index { 0 } ;
    InformationsquelleAutor Michael Kristofik
  6. 4

    Approches possibles:

    • Initialiser toutes les variables locales à zéro.
    • Avez un tableau, memset ou {0} le tableau.
    • Faire globales ou statiques.
    • Les mettre dans struct, et memset ou avoir un constructeur qui serait initialiser
      à zéro.
    • Les index, avoir des tableaux.
    • Je ne sais pas comment c'est pertinent à la mise int index = 0;.
    • #define COLONNE 0 #define LIGNE 1 #define INDICE 2 #define AR_SIZE 3 Données int[AR_SIZE]; // Juste une idée.
    • Désolé, je voulais dire, pourquoi avez-vous d'inclure la ligne "Ont un tableau, memset ou {0} de la matrice." dans votre réponse?
    • memset(Data, 0, sizeof(Data)); // Si cela peut être emballé de façon logique.
    InformationsquelleAutor Ajay
  7. 3

    De 2k18, vous pouvez utiliser Structuré Liaisons:

    #include <iostream>
#include <tuple>

int main () 
{
    auto [hello, world] = std::make_tuple("Hello ", "world!");
    std::cout << hello << world << std::endl;
    return 0;
}

    Démo

    InformationsquelleAutor ivaigult
  8. 1

    Je ne recommanderais pas cela, mais si vous êtes vraiment en étant une ligne et écrit seulement 0 une fois, vous pouvez également le faire:

    int row, column, index = row = column = 0;
    InformationsquelleAutor Levi Uzodike
  9. -11

    Lorsque vous déclarez une variable sans l'initialiser, un nombre aléatoire à partir de la mémoire est sélectionnée et que la variable est initialisée à la valeur.

    • pas vraiment. Le compilateur décide que "cette variable sera à l'adresse xxx', ce qui est arrivé à être à l'adresse xxx sera la valeur initiale, sauf si pour quelque chose explicitement (par initialiser ou de la cession)
    • bien que mieux, et vrai pour n'importe quelle implémentation triviale qui ne veut pas sortir de sa façon de harceler les utilisateurs... c'est encore simplifier à l'excès 😉 que l'utilisation d'une variable non initialisée est UB, donc en théorie tout peut arriver, y compris le code en utilisant cette variable tout simplement être supprimés du programme - ce qui est particulièrement probable lorsque l'optimisation est en jeu.
    • la valeur de cette variable serait tout ce qui était à l'adresse qu'il a obtenu, c'est à dire de la camelote.
    • Il n'a pas d'importance ce qui est arrivé à être à cette même adresse avant la nouvelle variable a été déclarée et qui est arrivé à obtenir la même adresse. Si l'utilisateur déclare une nouvelle variable sans initialiser avec une valeur, puis lit la variable avant de l'avoir attribué une valeur, le programme a un comportement indéterminé. C'est infiniment pire que "aléatoire" et "junk" et tout doit être évité.
    InformationsquelleAutor user3487742