Pourquoi utiliser des non-membre de début et de fin de fonctions en C++11?

Considérer le cas où vous avez de la bibliothèque qui contiennent de la classe:

class SpecialArray;

il dispose de 2 méthodes:

int SpecialArray::arraySize();
int SpecialArray::valueAt(int);

pour effectuer une itération sur les valeurs que vous devez hériter de cette classe et de définir begin() et end() méthodes pour les cas de

auto i = v.begin();
auto e = v.end();

Mais si vous utilisez toujours la

auto i = begin(v);
auto e = end(v);

vous pouvez faire ceci:

template <>
SpecialArrayIterator begin(SpecialArray & arr)
{
  return SpecialArrayIterator(&arr, 0);
}

template <>
SpecialArrayIterator end(SpecialArray & arr)
{
  return SpecialArrayIterator(&arr, arr.arraySize());
}

où SpecialArrayIterator est quelque chose comme:

class SpecialArrayIterator
{
   SpecialArrayIterator(SpecialArray * p, int i)
    :index(i), parray(p)
   {
   }
   SpecialArrayIterator operator ++();
   SpecialArrayIterator operator --();
   SpecialArrayIterator operator ++(int);
   SpecialArrayIterator operator --(int);
   int operator *()
   {
     return parray->valueAt(index);
   }
   bool operator ==(SpecialArray &);
   //etc
private:
   SpecialArray *parray;
   int index;
   //etc
};

maintenant i et e peut être légalement utilisé pour l'itération et d'accéder à des valeurs de SpecialArray

Pour répondre à votre question, la gratuit des fonctions begin() et end() par défaut ne rien faire d'autre que d'appeler les conteneur des membres .begin() et .fin de fonctions (). De <iterator>, inclus automatiquement lorsque vous utilisez l'un des conteneurs standard comme <vector>, <list>, etc., vous obtenez:

template< class C > 
auto begin( C& c ) -> decltype(c.begin());
template< class C > 
auto begin( const C& c ) -> decltype(c.begin()); 

La deuxième partie de votre question est pourquoi préférer les fonctions libres si elles ne font appeler les fonctions de membre de toute façon. Cela dépend vraiment de ce genre d'objet v est dans votre code d'exemple. Si le type de v est un conteneur standard de type, comme vector<T> v; alors il n'a pas d'importance si vous utilisez la gratuit ou des fonctions membres, ils font la même chose. Si votre objet v est plus générique, comme dans le code suivant:

template <class T>
void foo(T& v) {
  auto i = v.begin();     
  auto e = v.end(); 
  for(; i != e; i++) { /* .. do something with i .. */ } 
}

Puis en utilisant les fonctions de membre des sauts de votre code pour T = C des tableaux, chaînes C, les énumérations, etc. À l'aide de la non-membre de fonctions, de vous faire de la publicité plus générique de l'interface que les gens peuvent facilement étendre. En utilisant la fonction d'interface:

template <class T>
void foo(T& v) {
  auto i = begin(v);     
  auto e = end(v); 
  for(; i != e; i++) { /* .. do something with i .. */ } 
}

Le code fonctionne maintenant avec T = C des tableaux et chaînes C. En train d'écrire une petite quantité de code d'adaptateur:

enum class color { RED, GREEN, BLUE };
static color colors[]  = { color::RED, color::GREEN, color::BLUE };
color* begin(const color& c) { return begin(colors); }
color* end(const color& c)   { return end(colors); }

Nous pouvons obtenir votre code doit être compatible avec l'objet iterable les énumérations trop. Je pense que l'Herbe du point principal est que l'utilisation de la gratuit des fonctions est tout aussi simple que d'utiliser les fonctions de membre, et il donne à votre code de compatibilité descendante avec C des types de séquence et en avant la compatibilité avec les non-stl types de séquence (et futur-types stl!), avec un faible coût à d'autres développeurs.

Un des avantages de std::begin et std::end est qu'ils servent de points d'extension
pour la mise en œuvre de la norme d'interface pour des classes externes.

Si vous souhaitez utiliser CustomContainer classe avec la gamme à base de boucle ou d'un modèle
fonction qui attend .begin() et .end() méthodes, vous feriez bien évidemment
mettre en œuvre ces méthodes.

Si la classe ne fournir ces méthodes, ce n'est pas un problème. Quand ça ne marche pas,
vous auriez à le modifier*.

Ce n'est pas toujours possible, par exemple lors de l'utilisation d'une bibliothèque externe, avec
commerciale et fermé source.

Dans de telles situations, std::begin et std::end venir dans maniable, puisque l'on peut offrir
itérateur de l'API sans modifier la classe elle-même, mais plutôt la surcharge de fonctions libres.

Exemple: supposons que vous souhaitez mettre en œuvre count_if fonction qui prend un conteneur
au lieu d'une paire d'itérateurs. Un tel code pourrait ressembler à ceci:

template<typename ContainerType, typename PredicateType>
std::size_t count_if(const ContainerType& container, PredicateType&& predicate)
{
    using std::begin;
    using std::end;

    return std::count_if(begin(container), end(container),
                         std::forward<PredicateType&&>(predicate));
}

Maintenant, quelle que soit la classe que vous souhaitez utiliser avec cette coutume count_if, vous n'avez
pour ajouter gratuitement deux fonctions, au lieu de modifier ces classes.

Maintenant, C++ dispose d'un méchanisme d'identification appelé Argument Dépendante De Recherche
(ADL), ce qui rend cette approche plus souple.

En bref, l'ADL signifie, que lorsqu'un compilateur résout un franc fonction (j'. e.
fonction sans espace de noms, comme begin au lieu de std::begin), il sera également
considérer que les fonctions déclarées dans les espaces de noms de ses arguments. Par exemple:

namesapce some_lib
{
    //let's assume that CustomContainer stores elements sequentially,
    //and has data() and size() methods, but not begin() and end() methods:

    class CustomContainer
    {
        ...
    };
}

namespace some_lib
{    
    const Element* begin(const CustomContainer& c)
    {
        return c.data();
    }

    const Element* end(const CustomContainer& c)
    {
        return c.data() + c.size();
    }
}

//somewhere else:
CustomContainer c;
std::size_t n = count_if(c, somePredicate);

Dans ce cas, il n'est pas question que les noms qualifiés sont some_lib::begin et some_lib::end
- depuis CustomContainer est dans some_lib:: trop, le compilateur va utiliser ces surcharges dans count_if.

C'est également la raison pour avoir using std::begin; et using std::end; dans count_if.
Cela nous permet d'utiliser sans réserve begin et end, ce qui permet donc à l'ADL et
permettant compilateur de choisir std::begin et std::end lorsque aucune autre solution n'est trouvée.

On peut manger le biscuit et ont le cookie - je. e. avoir un moyen de fournir une implémentation personnalisée
de begin/end tandis que le compilateur peut revenir à des standards.

Quelques remarques:

• Pour la même raison, il ya d'autres fonctions similaires: std::rbegin/rend,
  std::size et std::data.

• Comme d'autres réponses mentionne, std:: versions ont des surcharges pour nu tableaux. C'est utile,
  mais est simplement un cas particulier de ce que j'ai décrit ci-dessus.

• À l'aide de std::begin et les amis est particulièrement bonne idée lors de l'écriture de code de modèle,
  ce qui rend ces modèles plus génériques. Pour les non-modèle, vous pourriez juste
  ainsi les méthodes d'utilisation, le cas échéant.

P. S. je suis conscient que ce post est près de 7 ans. Je suis tombé sur ça parce que je voulais
répondre à une question qui a été marqué comme un doublon et découvert que pas de réponse ici, mentionne l'ADL.