foreach en C++ int tableau

Je suis novice en C++ et je suis en train d'écrire le code suivant.
J'avais besoin de parcourir tous les addons dans ma fonction d'appel - testFunction. Je sais que cela fonctionne en C#, mais ce code ne fonctionne pas. Quelqu'un peut s'il vous plaît signaler la bonne façon de le faire en C++?

#include "stdafx.h"
#include <iostream>
#include "resource.h"

int testFunction(char* tester);
int _tmain()
{
    int mainProd=2;
    int Addons[]={7,8,9,10};

    testFunction(mainProd,Addons);


}
void testFunction(int mainProd,int addons[])
{
    for(int x = 0 ; addons.length;++x) ---- Not working 
    {
        std::cout<< addons[x];
    }
}

J'ai essayé de mettre en œuvre des vecteurs ci-dessous des suggestions par des gars

#include "stdafx.h"
#include <iostream>
#include "resource.h"
#include <vector>

void testFunction(std::vector<int> addons);

int _tmain(int argc, _TCHAR* argv[])
{

    std::vector<int>  Addons ;
    for(int i = 0 ;i<10;++i)
    {
        Addons.push_back(i);
    }
     testFunction(Addons);
}

void testFunction(std::vector<int> addons)
{
    for(int i =0 ; i<addons.size();++i)
    {
        std::cout<<addons.at(i);
    }
}

D'où vous est venue l'idée que .length pourrait fonctionner? Peut-être vous avez besoin de chercher une un meilleur livre?
Quel est votre favori C++ livre dire?
fordward déclarer la version correcte de testFunction trop.
passage par référence le vecteur afin d'éviter d'inutiles copys void testFunction(const std::vector<int> &addons) // note the 'const' and the '&'
for(int i =0 ; i<addons.size();++i) est mauvais style pour une itération sur un vecteur. Utilisation begin et end à la place.

OriginalL'auteur junni lomo | 2013-01-15

c++c++11 visual-c++

15

Un tableau (raw d'un tableau) se désintègre en un pointeur lorsqu'il est passé comme argument à une fonction, de sorte que votre tableau n'a pas d'informations sur la taille.

Vous avez besoin pour passer la longueur du tableau explicitement dans la fonction à le connaître, à l'intérieur de la fonction.

Autrement, et mieux, utiliser un std::vector et ensuite vous aurez la .size() toujours disponible en cas de besoin.

Ou std::array si la taille est fixée à la compilation.
Parce que vous avez une fonction avec un char* paramètre déclaré avant votre principal et défini les corriger après. ideone.com/2H1xX8
ou de passer un tableau par référence

OriginalL'auteur Tony The Lion
7

En dehors de l'utilisation de vecteurs, comme Tony l'indique, vous pouvez utiliser des modèles et de transmettre le tableau par référence, de sorte que le compilateur va en déduire la taille du tableau:
```
template<int N>
void testFunction(int mainProd,int (&addons)[N])
{
    for(int x = 0; x < N; ++x) //---- working 
    {
        std::cout<< addons[x];
    }
}
```
OriginalL'auteur Armen Tsirunyan
3

Vous êtes en utilisant les concepts de C# en C++, mais, même si nous supposons que les deux langues sont similaires, ils ne sont pas égaux.

La syntaxe pour une attaque à distance-pour en C++ est la suite:
```
for (type identifier : container) //note the ':', not ';'
{
    //do stuff
}
```
Vous pouvez l'utiliser pour saveur si vous avez un C++11 compilateur.

Btw, il semble que vous êtes en utilisant les propriétés de votre code:
```
for(int x = 0 ; addons.length;++x) //what is lenght?
{
    std::cout<< addons[x];
}
```
Il n'y a pas une telle chose en C++, si vous souhaitez appeler une méthode de l'objet, vous devez l'appeler comme une fonction:
```
//assuming that the object 'addons' have a method
//named 'length'  that takes no parameters
addons.length();
```
Mais la addons variable n'est pas un objet, c'est un tableau (jetez un oeil à ce tutoriel), donc il n'a pas une méthode ou une propriété nommée length; si vous avez besoin de savoir sa longueur afin de le parcourir, vous pouvez utiliser dans certains contextes, la sizeof opérateur (voir le tutoriel pour plus d'informations).

Supposons que addons ont été un conteneur:
```
typedef std::vector<addon> Addons;
Addons addons;
```
Si vous souhaitez effectuer une itération à l'aide de C++11 de la gamme, vous pouvez l'écrire comme suit:
```
for (addon a : addons)
{
    //do stuff with a.
}
```
Espère que cela aide.

Il y a beaucoup de fautes de frappe dans cette réponse.
pourriez-vous m'aider à résoudre ce problème? je n'ai pas trouvé toutes les fautes d'orthographe, peut-être que vous faites allusion à mon manque de compétences en anglais?

OriginalL'auteur PaperBirdMaster
2

Si vous utilisez un std::vector ou std::array, vous pouvez utiliser std::foreach,
```
std::vector<int> addons = {7,8,9,10};
std::array<int, 4> addons = {7,8,9,10}; //Only use one of these...
std::foreach(addons.begin(), addon.end(), [](int i) {
    std::cout << i
});
```
Le lambda devrait prendre des int, pas un itérateur
Mon erreur, désolé.
Pourrait tout aussi bien utiliser la nouvelle gamme-pour puis.
Vous pourriez, mais je n'aime pas la syntaxe; pas aussi lisible.
std::foreach vs range-for peut être une question de goût?

OriginalL'auteur Alex Chamberlain
1

Code est de travailler avec cette

for (int i = 0; i < (la fin(array) - commencer(array)); i++)

Retour taille maximale

Tester si le tableau est vide
```
array::empty
```
Élément du tableau
```
array::size
```
Taille de la matrice
```
sizeof()
```
OriginalL'auteur Vivek Malik

Vous devez vous connecter pour publier un commentaire.