Je suis en train de créer un programme, dans lequel je dois itérer les nombres, en commençant par 1 à num puis mettre la valeur de ce tableau {1. ..num } à une variable qui peut être appelée dans la boucle for .
Voici où j'en suis.
int procnum[num] = {1,2,3...num};
J'ai besoin de procnum [num] pour avoir une valeur comme ...
int main()
{
int num = 0;
cin >> num;
for (int i = 1; i <= num; i++)
{
procnum[i];
}
}
3 Réponses :
vous pouvez utiliser vous ne devez pas std :: vector a > pour créer des tableaux dynamiques: #include <iostream>
#include <vector>
int main() {
int size;
std::cin >> size;
std::vector<int> procnum(size);
for (int i = 0; i < size; ++i) {
procnum[i] = i + 1;
}
}
utiliser namespace std; - lire ici pourquoi.
L'utilisation d'espaces de noms dans les fichiers source n'est pas du tout une mauvaise idée, comme certaines réponses l'indiquent clairement. Cependant, les réponses les plus votées pourraient être mal interprétées ...
pour moi personnellement, j'aime vraiment dire std :: car il dit clairement que j'utilise un utilitaire de la STL. De plus, cela peut être plus rapide que de ne pas taper std :: si c'est quelqu'un qui se dispute.
Si vous pouvez utiliser std :: vector et std :: iota , ce n'est que du code sur deux lignes.
Pas besoin de ( index) boucle le tableau. Voir l'exemple en direct ici
#include <vector> // std::vector #include <numeric> // std::iota std::vector<int> procnum(some_size); std::iota(procnum.begin(), procnum.end(), 1);
Désolé, mais c'est un moyen idéal de confondre les débutants.
@Trantor Si un débutant n'apprend pas quelque chose de nouveau chaque jour, il restera toujours un débutant. Juste pour la remarque. ;)
En C ++ 11, pas besoin même d'écrire une boucle, sauf si vous devez faire une vérification d'erreur (par exemple vérifier que la lecture de l'entrée a réussi, ou que la valeur d'entrée est valide).
#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
int main()
{
int size;
std::cin >> size;
std::vector<int> procnum(size);
std::iota(procnum.begin(), procnum.end(), 1); // starting value is 1
// output vector to demonstrate it is populated
std::copy(procnum.begin(), procnum.end(), std::ostream_iterator<int>(std::cout," ");
std::cout << "\n";
}
Avant C ++ 11, il n'y avait pas d'algorithme std :: iota () , mais il est possible d'utiliser std :: generate () et un simple foncteur pour obtenir le même effet.
pas besoin même d'écrire une boucle : eh bien, les boucles basées sur des plages ne sont pas si mauvaises à utiliser. Au moins, vous êtes sûr qu'aucun UB hors limite ne se produit, comme dans l'itération basée sur un index.
@JeJo - Je ne suggère pas que les boucles sont mauvaises. Juste qu'ils ne sont pas nécessaires dans ce cas. Il y a aussi souvent des avantages à utiliser des algorithmes standard au lieu d'écrire des boucles pour obtenir le même effet.
Pouvez-vous ajouter plus de détails à votre question? Ce n'est pas clair ce que vous demandez
BTW:
pour (int i = 1; i <= num; i ++)->pour (int i = 0; i. Dans les tableaux C ++, les index commencent à 0, pas à 1. Je l'ai trié Merci à la réponse de Trantor pour (int a = 0; a <= nombre; a ++) {proc num [a] = a + 1; }