Welchen Overhead gibt es bei der Durchführung eines Identity Boost :: lexical_cast?

Question

eine Funktion wie Gegeben:

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

Welche Art von Overhead entstehen, wenn der Typ function1 geben wird, ist bereits ein std::string?

Ändert sich der Overhead, je nach Typ ich bin lexical_cast -ing zu?

Ist es überflüssig, eine überladene Funktion zu machen, um den Cast zu umgehen? Z.B .:

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

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

Die Version von Boost kann auf Ihre Antwort relevent werden, wie ich sie verstehe, dass lexical_cast einige Optimierungen für Revisionen erhalten hat.

Answer 1

Da die Dokumentation nichts zu diesem Thema bietet, habe ich in die Quelle lexical_cast (1.51.0) gegraben und festgestellt, dass es eine Kompilierzeitüberprüfung der Typen durchführt und eine bestimmte "Casterklasse" entscheidet die Umwandlung. Falls Quelle und Ziel gleich sind, gibt diese "Caster-Klasse" einfach die Eingabe zurück.

Pseudo-kodifiziert und von der Quelle vereinfacht (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 */ 
    } 
} 

ich nicht direkt keine Optimierungen für andere Identität sehen wirft, obwohl, und auf der Suche durch die normalerweise ausgewählt lexical_cast_do_cast „Caster Klasse“ macht mein Kopf tut weh. :(

Answer 2

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

Betrachten Sie diesen Link, Saite zu Saite sehr schnell

die Tests messen Alle Ausführungsgeschwindigkeit in Millisekunden für 10000 Iterationen der folgenden Codeblöcke.

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; 

In unserem Fall wird shall_we_copy_t::value wahr sein, da 3. Fall für uns arbeiten (Target und src sind gleiche Typen und Target Typ ist 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; 

Da shall_we_copy_t::value wahr ist, wird unser caster_type lexical_cast_copy

return caster_type::lexical_cast_impl(arg); 

Also wird lexical_cast_copy::lexical_cast_impl genannt werden, was sehr einfach ist

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