C++11 auto itérateur de type std::begin(), std::end() question

J'ai quelques privée de la classe membre, représentant de l'accès aléatoire tableau de std::deque contenant quelques données:

std::vector<std::deque<SomeDataClass> > someMember;

Je tiens à fournir une méthode de classe qui retourne itérable structure de données, contenant tous les éléments de données à partir de mon tableau de deques:

std::deque<SomeDataClass> someMethod();

Je voudrais que cette méthode de passer par tous les deques dans le vecteur et la copie de chaque élément sur un chemin local std::deque, finalement de retourner ce local std::deque en valeur.
Je suis en train de mettre en œuvre cette méthode à l'aide de C++11 auto et std::begin(), std::end():

std::deque<SomeDataClass> MyClassName::someMethod(){
    std::deque<DirectedEdge> allDataItems;
    std::deque<DirectedEdge>::iterator deqIter = allDataItems.begin();
    for(auto it = std::begin(someMember); it != std::end(someMember); ++it){
        std::copy(std::begin(*it), std::end(*it), deqIter);
    }

    return allDataItems;
}

- Je recevoir des données, violation d'accès exception non gérée d'erreur sur l'exécution dans deque en-tête. Ce qui est une erreur?

Vous devriez toujours utiliser != pour mettre fin à l'état lors de l'utilisation d'itérateurs. Rien ne dit que le prochain est le plus avancé dans la mémoire.
Ouais, bien sûr, merci. Je vais modifier ma question, erreur stupide. J'ai encore de violation d'accès.
Rien ne dit donc, en dehors de la norme, tant que le conteneur est un vecteur. Et de toute façon, pour un accès aléatoire itérateurs, operator< ne vous dit pas l'ordre dans la mémoire, mais l'ordre dans la séquence logique (pour d'autres itérateur catégories, il n'est pas du tout défini). Étant donné que seul les récipients utilisés pour le vard du code de vecteur et deque, qui ont tous deux des itérateurs à accès aléatoire, à l'aide de operator< est parfaitement bien (tant que les deux itérateurs appartiennent à la même conteneur, bien sûr).
Je savais que quelqu'un aurait des commentaires sur ce point. Oui, vive les itérateurs fonctionnera très bien avec operator<, mais j'apprécie le fait de pouvoir changer quelque chose sans casser tout le reste. À l'aide de operator!= fonctionne avec tous les itérateur de type. J'aurais fait un peu plus clair, mais mon cinq minutes, il était jusqu'au moment où j'ai pensé à elle.

OriginalL'auteur vard | 2013-07-16

  1. 13

    std::copy() nécessite la plage de destination pour être assez grand pour contenir la copie, mais allDataItems est vide. Vous devez réserver de l'espace dans allDataItems à l'avance (mais ce n'est pas possible avec std::deque). Vous devez utiliser un std::back_inserter (défini dans <iterator>) au lieu de:

    std::deque<SomeDataClass> MyClassName::someMethod(){
    std::deque<DirectedEdge> allDataItems;
    for(auto it = std::begin(someMember); it < std::end(someMember); ++it){
        std::copy(std::begin(*it), std::end(*it), std::back_inserter(allDataItems));
    }

    return allDataItems;
}
    Pensez à faire allDataItems.insert(std::end(allDataItems), ...); à la place. Je dirais qu'il est généralement préférable d'utiliser des membres lorsque cela est possible.
    Vous pouvez faire une réponse distincte, de sorte que les OP peuvent décider ce qui leur convient le mieux.
    Il suffit de l'ajouter à la vôtre et puis, il y a une encore meilleure réponse 🙂
    != œuvres au lieu de < et signifie que si someMember n'était pas un accès aléatoire conteneur, le code fonctionne encore. Et si vous n'avez pas besoin de l'itérateur, for( auto const& x : someMember ) est plus clair et plus court.

    OriginalL'auteur Angew

  2. 4

    Voici un idomatic C+11 façon de le faire:

    std::deque<SomeDataClass> MyClassName::someMethod() {
  std::deque<DirectedEdge> allDataItems;

  for( auto const& dq : someMember ) {
    allDataItems.insert( allDataItems.end(), std::begin(dq), std::end(dq) );
  }
  return allDataItems;
}

    une autre façon serait d'écrire un concatinate fonction:

    struct concatenate {
  template<typename Dest, typename Src>
  Dest&& operator()( Dest&& d, Src const& s ) const {
    using std::begin; using std::end;
    typename std::decay<Dest>::type retval = std::forward<Dest>(d);
    retval.insert( end(retval), begin(s), end(s) );
    return std::move(retval);
  }
};
std::deque<SomeDataClass> MyClassName::someMethod() {
  using std::begin; using std::end; //enable ADL
  return std::accumulate(
    begin(someMember), end(someMember),
    std::deque<DirectedEdge>(), concatenate()
  );
}

    qui est assez mignon. Si vous n'aimez pas std::accumulate,

    std::deque<SomeDataClass> MyClassName::someMethod() {
  std::deque<DirectedEdge> allDataItems;

  for( auto const& dq : someMember ) {
    allDataItems = concatenate( std::move(allDataItems), dq );
  }
  return allDataItems;
}

    qui sont tous les deux à peu près équivalente efficace.

    renommé fonction de merriam_webster comme demandé.
    lol, mais vous avez manqué l'un dans le texte

    OriginalL'auteur Yakk - Adam Nevraumont