BOOST_FOREACH utilisation implicite de référence?

Question

Je me demande s'il y a un avantage à obtenir une référence à un vecteur avant d'appeler BOOST_FOREACH ou si un appel de méthode qui renvoie une référence sera automatiquement utilisé? Par exemple, laquelle des deux boucles suivantes sera équivalente à la troisième boucle?

vector<float>& my_method(); 

void main() 
{ 
    // LOOP 1 ------------------------------- 
    vector<float>& temp_vector = my_method(); 
    BOOST_FOREACH(float element, temp_vector) 
     cout << element << endl; 

    // LOOP 2 ------------------------------- 
    vector<float> temp_vector = my_method(); 
    BOOST_FOREACH(float element, temp_vector) 
     cout << element << endl; 

    // Which loop is this one most like? ---- 
    BOOST_FOREACH(float element, my_method()) 
     cout << element << endl; 
} 

Answer 1

En regardant à travers BOOST_FOREACH folie metaprogramming Je vois que la collection est copiée si elle est

1. rvalue,
2. un "proxy léger", que vous pouvez définir pour vos types en se spécialisant boost::foreach::is_lightweight_proxy.

Par conséquent, lvalue est pas copié. Au lieu de cela, son pointeur est considéré comme temporaire.

bit Crucial est la suivante:

# define BOOST_FOREACH_SHOULD_COPY(COL)    \ 
    (true ? 0 : boost::foreach_detail_::or_(  \ 
     BOOST_FOREACH_IS_RVALUE(COL)    \ 
     , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))) 

Ensuite, il est utilisé comme l'un des arguments à la fonction qui est utilisée pour évaluer un récipient dans une variable temporaire:

template<typename T> 
inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue 
{ 
    return t; 
} 

template<typename T> 
inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue 
{ 
    // Cannot seem to get sunpro to handle addressof() with array types. 
    #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570)) 
    return &t; 
    #else 
    return boost::addressof(t); 
    #endif 
} 

Je Boost v1 .38 installé dans mon système.

Answer 2

And although BOOST_FOREACH is a macro, it is a remarkably well-behaved one. It evaluates its arguments exactly once, leading to no nasty surprises

donc my_method() ne sera pas appelé plus d'une fois

Références se comporte comme "normaux" variables du point de vue de l'utilisateur, vous pouvez traiter la référence exactement comme si c'était la variable d'origine. Cela ne fait aucune différence pour la boucle foreach.

Les deux boucles sont donc équivalentes.

Answer 3

Un test rapide montre que la fonction est appelée une fois et qu'aucune copie n'est effectuée en relation avec BOOST_FOREACH.

#include <vector> 
#include <iostream> 
#include <boost/foreach.hpp> 

struct X 
{ 
    X() {} 
    X(const X&) { std::cout << "copied\n"; } 
}; 

std::vector<X> vec(2); 

//std::vector<X> method() 
std::vector<X>& method() 
{ 
    std::cout << "returning from method\n"; 
    return vec; 
} 

int main() 
{ 
    BOOST_FOREACH(const X& x, method()) {} 
}