Jakie są dodatkowe obciążenia związane z wykonywaniem podwyższenia tożsamości :: leksykalny_krok?

Question

Biorąc pod uwagę funkcje, takie jak:

template< typename T > 
void function1(const T &t) 
{ 
    function2(boost::lexical_cast<std::string>(t)); 
} 

Jakie napowietrznej powstaje wtedy, gdy typ przekazane function1 jest już std::string?

Czy narzut jest różny, w zależności od typu Jestem lexical_cast -ing na?

Czy pominięcie obsady jest zbyteczne, aby wykonać przeciążoną funkcję? Np .:

void function1(const std::string &t) 
{ 
    function2(t); 
} 

template< typename T > 
void function1(const T &t) 
{ 
    function1(boost::lexical_cast<std::string>(t)); 
} 

Wersja doładowania można dowiemy się z na odpowiedź, jak rozumiem, że lexical_cast otrzymał kilka optymalizacji drugiej wersji.

Answer 1

Ponieważ dokumentacja nie oferuje niczego na ten temat, wykopałem się w źródle lexical_cast (1.51.0) i odkryłem, że robi pewne sprawdzanie w czasie kompilacji typów i decyduje o konkretnej "klasie rzucającej", która ma konwersja. Jeśli źródło i cel są takie same, ta "klasa kółka" po prostu zwróci dane wejściowe.

Pseudo-ujednolicone i uproszczone ze źródła (boost/lexical_cast.hpp:2268):

template <typename Target, typename Source> 
Target lexical_cast(const Source &arg) 
{ 
    static if(is_character_type_to_character_type<Target, src> || 
       is_char_array_to_stdstring<Target, src> || 
       is_same_and_stdstring<Target, src>) 
    //   ^-- optimization for std::string to std::string and similar stuff 
    { 
     return arg; 
    } 
    else 
    { 
     /* some complicated stuff */ 
    } 
} 

nie mogę bezpośrednio zobaczyć jakieś optymalizacje dla innej tożsamości rzuca, choć i pominie normalnie wybranej „klasy rzucającego” lexical_cast_do_cast czyni boli mnie głowa. :(

Answer 2

http://www.boost.org/doc/libs/1_51_0/doc/html/boost_lexical_cast/performance.html

Rozważmy ten link, ciąg ciąg jest bardzo szybki

wszystkie testy pomiaru prędkości wykonanie w milisekundach 10000 iteracji bloków następujący kod:.

typedef BOOST_DEDUCED_TYPENAME ::boost::type_traits::ice_or< 
      ::boost::detail::is_xchar_to_xchar<Target, src >::value, 
      ::boost::detail::is_char_array_to_stdstring<Target, src >::value, 
      ::boost::type_traits::ice_and< 
       ::boost::is_same<Target, src >::value, 
       ::boost::detail::is_stdstring<Target >::value 
      >::value 
    > shall_we_copy_t; 

W naszym przypadku shall_we_copy_t::value będzie prawdą, ponieważ trzecia sprawa dotyczy nas (Target i src są równe typy iTypto std::basic_string).

typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c< 
     shall_we_copy_t::value, 
     ::boost::detail::lexical_cast_copy<src >, 
     BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c< 
      shall_we_copy_with_dynamic_check_t::value, 
      ::boost::detail::lexical_cast_dynamic_num<Target, src >, 
      ::boost::detail::lexical_cast_do_cast<Target, src > 
     >::type 
    >::type caster_type; 

Ponieważ shall_we_copy_t::value prawda, nasza caster_type będzie lexical_cast_copy

return caster_type::lexical_cast_impl(arg); 

Tak, będzie nazwane lexical_cast_copy::lexical_cast_impl, który jest bardzo prosty

template <typename Source> 
    struct lexical_cast_copy 
    { 
     static inline Source lexical_cast_impl(const Source &arg) 
     { 
      return arg; 
     } 
    };