fonction retournant itérateur en C++

Qui suit est une méthode Java qui renvoie un itérateur

vector<string> types;

//some code here

Iterator Union::types() 
{
    return types.iterator();
}

Je veux traduire ce code en C++. Comment puis-je retourner un itérateur de vecteur à partir de cette méthode?

Java et C++ comprendre fondamentalement différente des choses par le terme “itérateur” ainsi donc, votre question n'a pas de sens (ou plutôt, la réponse n'est pas ce que vous attendez).
Ce n'est pas vraiment significatif - quel est votre problème? Êtes-vous enveloppant d'un conteneur et que vous voulez revenir les itérateurs d'éléments spécifiques ou des plages?
la façon dont ils sont mis en œuvre est tout à fait différent, mais la plupart sont tout à fait semblables.
Pas de. Un itérateur en Java sait que son conteneur de façon plus étroite correspond à un (ou paire) de itérateurs en C++, tout en C++ itérateur correspond à l'itérateur valeur en cours en Java.
Merci pour votre réponse. J'ai eu ma réponse

OriginalL'auteur sufyan siddique | 2012-01-11

c++iterator

Ceci renvoie un itérateur sur le début de types:

std::vector<string>::iterator Union::types() 
{
    return types.begin();
}

Toutefois, l'appelant a besoin de connaître le end() de vecteur types.
Java est Iterator a une méthode hasNext(): cela n'existe pas en C++.

Vous pouviez changer Union::types() pour retourner une plage:

std::pair<std::vector<std::string>::iterator, 
          std::vector<std::string>::iterator> Union::types()
{
    return std::make_pair(types.begin(), types.end());
}

std::pair<std::vector<std::string>::iterator, 
          std::vector<std::string>::iterator> p =  Union::types();

for (; p.first != p.second; p.first++)
{
}

En effet, si vous devez retourner une paire de (begin,end) ou ne vous embêtez pas à tous.
a été de montage pour illustrer ce que vous avez dit.

OriginalL'auteur hmjd

Vous aurez envie d'avoir une begin et end méthode:

std::vector<string>::iterator Union::begin()
{
  return types.begin();
}

std::vector<string>::iterator Union::end()
{
  return types.end();
}

Pour être complet, vous pouvez également avoir const versions

std::vector<string>::const_iterator Union::begin()const
{
  return types.begin();
}

std::vector<string>::const_iterator Union::end()const
{
  return types.end();
}

merci pour votre réponse

OriginalL'auteur Sean

3

Une union est un conteneur de ses membres. Je voudrais utiliser begin et end de donner en retour des itérateurs pour la première et après la dernière membres, respectivement.

La liste des types n'est pas de l'OMI, le principal objet iterable propriété d'un syndicat. Donc je n'utilise moi-même la suivante, et la réserve de la plaine begin et end pour les données du membre lui-même.
```
std::vector<string>::const_iterator Union::types_begin() const {
  return types.begin();
}

std::vector<string>::const_iterator Union::types_end() const {
  return types.end();
}
```
OriginalL'auteur Johannes Schaub - litb
3

Retour d'un itérateur est facile. Par exemple, vous pouvez retourner le premier itérateur dans les types de vecteurs:
```
std::vector<std::string> types;

//some code here

std::vector<std::string>::iterator Union::returnTheBeginIterator() 
{
    return types.begin();
}
```
Java vs C++

Mais le C++ itérateurs sont pas Java itérateurs: Ils ne sont pas utilisés de la même manière.

En Java (IIRC), vous avez plus comme un agent recenseur, qui est, vous utilisez la méthode "suivant" pour effectuer une itération à partir d'un élément à l'autre. Ainsi, le retour à la Java itérateur est suffisant pour effectuer une itération à partir du début à la fin.

En C++, l'itérateur est conçu pour se comporter comme un super-pointeur. Ainsi, il habituellement des "points" sur la valeur, et à l'aide de l'opérateur ++, --, etc. (selon le type exact de l'itérateur), vous pouvez déplacer l'itérateur qui pointe sur le suivant, précédent, etc. valeur dans le conteneur.

Nous allons effectuer une itération!

Habituellement, vous voulez effectuer une itération du début à la fin.

Cela, vous devez retourner la totalité de la collection (comme "const", si vous voulez qu'il soit en lecture seule), et permettent à l'utilisateur d'effectuer une itération de la façon dont il/elle veut.

Ou vous pouvez revenir deux itérateurs, l'un pour le début, et un pour la fin. Vous pouvez donc avoir:
```
std::vector<std::string>::iterator Union::typesBegin() 
{
    return types.begin();
}

std::vector<std::string>::iterator Union::typesEnd() 
{
    return types.end();
}
```
Et l', vous pouvez parcourir du début à la fin, en C++03:
```
//alias, because the full declaration is too long
typedef std::vector<std::string> VecStr ;

void foo(Union & p_union)
{
   VecStr::iterator it = p_union.typesBegin() ;
   VecStr::iterator itEnd = p_union.typesEnd() ;

   for(; it != itEnd; ++it)
   {
       //here, "*it" is the current string item
       std::cout << "The current value is " << *it << ".\n" ;
   }
}
```
C++11 version

Si vous fournissez le conteneur plein plutôt que sa itérateurs, en C++11, il devient plus facile, vous pouvez utiliser la gamme-pour la boucle (la boucle foreach en Java et C#):
```
void foo(std::vector<std::string> & p_types)
{
   for(std::string & item : p_types)
   {
       //here, "item " is the current string item
       std::cout << "The current value is " << item  << ".\n" ;
   }
}
```
P. S.: Johannes Schaub - litb est droit en utilisant le "const" qualifier chaque fois que possible. Je n'ai pas parce que je voulais éviter de diluer le code, mais à la fin, "const" est votre ami.

OriginalL'auteur paercebal
2

En supposant que les types est un attribut de la classe de l'Union, une belle, STL conforme, façon de gérer cela est:
```
class Union
{
std::vector< std::string > types
public:
typedef std::vector< std::string >::iterator iterator;
iterator begin() { return types.begin(); }
iterator end() { return types.end(); }

};
```
Votre code est faux: Soit "itérateur" est un "vecteur de la chaîne", ou "itérateur" est un "itérateur d'un vecteur de chaîne". Pas les deux.
Je vous remercie. J'ai corrigé.

OriginalL'auteur ravenspoint

Vous pouvez le faire ci-dessous

std::vector<std::string> types

std::vector<std::string>::iterator Union::types(){
    return types.begin();
}

merci pour votre réponse

OriginalL'auteur Chethan Ravindranath

Vous devez vous connecter pour publier un commentaire.

Java vs C++

Nous allons effectuer une itération!

C++11 version