Czy niestandardowe kontenery powinny mieć darmowe funkcje begin/end?

Istnieje kilka podejść, każdy z własnymi zaletami i wadami. Poniżej trzy podejścia z analizą kosztów i korzyści.

ADL przez Niestandardowy nieczłonek begin() / end()

Pierwsza alternatywa dostarcza szablony funkcji spoza begin() i end() wewnątrz przestrzeni nazw, aby zmodernizować wymaganą funkcjonalność do dowolnej klasy lub szablonu klasy, który może ją dostarczyć, ale ma np. złą konwencję nazewnictwa. Kod wywołujący może wtedy polegać na ADL, aby znaleźć te nowe funkcje. Przykładowy kod (na podstawie komentarzy @Xeo):

// LegacyContainerBeginEnd.h
namespace legacy {

// retro-fitting begin() / end() interface on legacy 
// Container class template with incompatible names         
template<class C> 
auto begin(Container& c) -> decltype(c.legacy_begin())
{ 
    return c.legacy_begin(); 
}

// similarly for begin() taking const&, cbegin(), end(), cend(), etc.

} // namespace legacy

// print.h
template<class C>
void print(C const& c)
{
    // bring into scope to fall back on for types without their own namespace non-member begin()/end()
    using std::begin;
    using std::end;

    // works for Standard Containers, C-style arrays and legacy Containers
    std::copy(begin(c), end(c), std::ostream_iterator<decltype(*begin(c))>(std::cout, " ")); std::cout << "\n";

    // alternative: also works for Standard Containers, C-style arrays and legacy Containers
    for (auto elem: c) std::cout << elem << " "; std::cout << "\n";
}

Plusy: w 2007 roku, po raz pierwszy w Polsce, w Polsce i za granicą, w 2009 roku, w Polsce i za granicą.]}

• działa dla wszystkich standardowych kontenerów i typów użytkowników, które definiują member .begin() i .end()
• działa dla tablic w stylu C
• można doposażyć do pracy (również dla range-dla pętli!) dla dowolnego szablonu klasy legacy::Container<T> który nie ma członu .begin() i end() bez konieczności podawania źródła modyfikacje kodu

// LegacyContainerBeginEnd.h 
// as before...

// ADLBeginEnd.h
namespace adl {

using std::begin; // <-- here, because otherwise decltype() will not find it 

template<class C> 
auto adl_begin(C && c) -> decltype(begin(std::forward<C>(c)))
{ 
    // using std::begin; // in C++14 this might work because decltype() is no longer needed
    return begin(std::forward<C>(c)); // try to find non-member, fall back on std::
}

// similary for cbegin(), end(), cend(), etc.

} // namespace adl

using adl::adl_begin; // will be visible in any compilation unit that includes this header

// print.h
# include "ADLBeginEnd.h" // brings adl_begin() and adl_end() into scope

template<class C>
void print(C const& c)
{
    // works for Standard Containers, C-style arrays and legacy Containers
    std::copy(adl_begin(c), adl_end(c), std::ostream_iterator<decltype(*adl_begin(c))>(std::cout, " ")); std::cout << "\n";

    // alternative: also works for Standard Containers, C-style arrays and legacy Containers
    // does not need adl_begin() / adl_end(), but continues to work
    for (auto elem: c) std::cout << elem << " "; std::cout << "\n";
}

Plusy : spójna konwencja wywołująca, która działa całkowicie generycznie

• te same plusy co za sugestia @Xeo +
• powtarzające się deklaracje użycia zostały zamknięte (suche)

Wady : trochę gadatliwy

• adl_begin() / adl_end() nie jest jak terse as begin() / end()
Nie jest też tak samo idiomatyczny (choć jest jednoznaczny).]}
• W oczekiwaniu na dedukcję typu zwracanego przez C++14, będzie również zanieczyszczać przestrzeń nazw za pomocą std::begin / std::end

Uwaga: Nie jestem pewien, czy to naprawdę poprawia się w stosunku do poprzedniego podejścia.

std::begin() lubstd::end() wszędzie

Raz werbalność begin() / end() została poddana i tak, dlaczego nie wrócić do kwalifikowanych połączeń z std::begin() / std::end()? Przykładowy kod:

// LegacyIntContainerBeginEnd.h
namespace std {

// retro-fitting begin() / end() interface on legacy IntContainer class 
// with incompatible names         
template<> 
auto begin(legacy::IntContainer& c) -> decltype(c.legacy_begin())
{ 
    return c.legacy_begin(); 
}

// similary for begin() taking const&, cbegin(), end(), cend(), etc.

} // namespace std

// LegacyContainer.h
namespace legacy {

template<class T>
class Container
{
public:
    // YES, DOCUMENT REALLY WELL THAT THE EXISTING CODE IS BEING MODIFIED
    auto begin() -> decltype(legacy_begin()) { return legacy_begin(); }
    auto end() -> decltype(legacy_end()) { return legacy_end(); }

    // rest of existing interface
};

} // namespace legacy

// print.h
template<class C>
void print(C const& c)
{
    // works for Standard Containers, C-style arrays as well as 
    // legacy::IntContainer and legacy::Container<T>
    std::copy(std::begin(c), std::end(c), std::ostream_iterator<decltype(*std::begin(c))>(std::cout, " ")); std::cout << "\n";

    // alternative: also works for Standard Containers, C-style arrays and
    // legacy::IntContainer and legacy::Container<T>
    for (auto elem: c) std::cout << elem << " "; std::cout << "\n";
}

Plusy : spójna konwencja wywołująca, która działa prawie generycznie

• działa dla wszystkich standardowych kontenerów i typów użytkowników, które definiują member .begin() i .end()
• działa dla tablic w stylu C

W 2007 roku, w ramach programu "Horyzont 2020", w ramach programu "Horyzont 2020", w ramach programu "Horyzont 2020" - program ramowy]}

• std::begin() / std::end() jest nieco bardziej wyrazisty niż begin() / end()
• można doposażyć tylko do pracy (również for range-for loops !) dla dowolnej klasy LegacyContainer który nie ma member .begin() i end() (i dla którego nie ma kodu źródłowego!) poprzez podanie jawnych specjalizacji nieczłonkowych szablonów funkcji begin() i end() w namespace std
• można doposażyć tylko w szablony klas LegacyContainer<T> poprzez bezpośrednie dodawanie funkcji Członkowskich begin() / end() wewnątrz kodu źródłowego LegacyContainer<T> (który dla szablonów jest dostępny). namespace std sztuczka nie działa tutaj, ponieważ szablony funkcji nie mogą być częściowo wyspecjalizowane.