Chi phí nào có trong việc thực hiện tăng nhận dạng :: lexical_cast?

Question

Cho một chức năng như:

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

Những loại chi phí phát sinh nếu kiểu truyền cho function1 đã là một std::string?

Chi phí thay đổi, tùy thuộc vào loại tôi là lexical_cast -ing đến?

Có thừa không để thực hiện chức năng quá tải để bỏ qua dàn diễn viên? Ví dụ .:

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

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

Các phiên bản của tăng chưa có liên quan đến câu trả lời của bạn, như tôi hiểu rằng lexical_cast đã nhận được một vài tối ưu hóa trên các phiên bản.

Answer 1

Vì tài liệu không cung cấp bất cứ điều gì về chủ đề này, tôi đào vào nguồn lexical_cast (1.51.0) và thấy rằng nó thực hiện kiểm tra biên dịch trên các loại và quyết định "lớp caster" cụ thể chuyển đổi. Trong trường hợp nguồn và đích là giống nhau, "lớp caster" này sẽ đơn giản trả về đầu vào.

Pseudo-hệ thống hóa và đơn giản hóa từ nguồn (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 */ 
    } 
} 

tôi có thể không trực tiếp nhìn thấy bất kỳ tối ưu hóa cho sắc khác phôi, tuy nhiên, và nhìn qua một cách bình thường được lựa chọn lexical_cast_do_cast "class caster" đang thực hiện tôi đau đầu quá. :(

Answer 2

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

xem xét liên kết này, chuỗi chuỗi rất nhanh

Tất cả các bài kiểm tra đo tốc độ thực hiện trong mili giây cho 10000 lần lặp của các khối mã sau:.

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; 

Trong trường hợp của chúng tôi shall_we_copy_t::value sẽ đúng, vì trường hợp thứ 3 hoạt động cho chúng tôi (Target và src là các loại bằng nhau và Target loại là 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; 

Từ, shall_we_copy_t::value là đúng, caster_type của chúng tôi sẽ lexical_cast_copy

return caster_type::lexical_cast_impl(arg); 

Vì vậy, sẽ được gọi lexical_cast_copy::lexical_cast_impl, mà là rất đơn giản

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