std :: transform이 생성자를 사용하는 이유는 무엇입니까?

Question

std :: transform을 사용하여 목록에있는 기존 값에 일부 값을 추가했습니다. 아래의 코드는 잘 작동하지만 변환을 실행할 때 복사 생성자 (프로그램의 출력 참조)에 대한 모든 호출을 피할 수 있는지 궁금합니다. 방금 코드를 해킹하고 for 루프가 Base의 + = 연산자를 명시 적으로 호출하면 복사 구성이 실행되지 않고 값이 더 효율적으로 변경됩니다.

복사를 구성하는 대신 Base의 + = 연산자를 변형 할 수 있습니까? increment<Type>에 집중해야합니까?

프로그램 :

#include <iostream> 
#include<list> 
#include <algorithm> 
#include <iterator> 

template<class T> 
class Base; 

template<class T> 
std::ostream& operator << (std::ostream& os, const Base<T>& b); 

template<class T> 
class Base 
{ 
    private: 
     T b_; 
    public: 
     typedef T value_type; 

     Base() 
      : 
       b_() 
     { std::cout << "Base::def ctor" << std::endl; } 

     Base (const T& b) 
      : 
       b_(b) 
     { std::cout << "Base::implicit conversion ctor: " << b_ << std::endl; } 

     const T& value() 
     { 
      return b_; 
     } 

     const Base operator+(const Base& b) const 
     { 
      std::cout << "Base operator+ " << std::endl; 
      return Base(b_ + b.b_); 
     } 

     const Base& operator+=(const T& t) 
     { 
      b_ += t; 
      return *this; 
     } 

     friend std::ostream& operator<< <T> (std::ostream& os, const Base<T>& b); 
}; 

template<class T> 
std::ostream& operator<< (std::ostream& os, const Base<T>& b) 
{ 
    os << b.b_; 
    return os; 
} 

template<class Type> 
class increment 
{ 
    typedef typename Type::value_type T; 

    T initial_; 

    public: 

     increment() 
      : 
       initial_() 
     {}; 

     increment(const T& t) 
      : 
       initial_(t) 
     {} 

     T operator()() 
     { 
      return initial_++; 
     } 
}; 

template<class Container> 
void write(const Container& c) 
{ 
    std::cout << "WRITE: " << std::endl; 
    copy(c.begin(), c.end(), 
     std::ostream_iterator<typename Container::value_type > (std::cout, " ")); 
    std::cout << std::endl; 
    std::cout << "END WRITE" << std::endl; 
} 

using namespace std; 

int main(int argc, const char *argv[]) 
{ 
    typedef list<Base<int> > bList; 

    bList baseList(10); 

    cout << "GENERATE" << endl; 
    generate_n (baseList.begin(), 10, increment<Base<int> >(10)); 
    cout << "END GENERATE" << endl; 

    write(baseList); 

    // Let's add some integers to Base<int> 

    cout << "TRANSFORM: " << endl; 

    std::transform(baseList.begin(), baseList.end(), 
        baseList.begin(), 
        bind2nd(std::plus<Base<int> >(), 4)); 
    cout << "END TRANSFORM " << endl; 

    write(baseList); 

    // Hacking the code: 
    cout << "CODE HACKING: " << endl; 
    int counter = 4; 
    for (bList::iterator it = baseList.begin(); 
     it != baseList.end(); 
     ++it) 
    { 
     *it += counter; // Force the call of the operator+= 
     ++counter; 
    } 
    write (baseList); 
    cout << "END CODE HACKING" << endl; 

    return 0; 
} 

Answer 1

Base (const T& b) 그것이 const T& 받아 Base<T>의 생성자입니다, 복사 생성자가 아닙니다. 복사 생성자는 보통, 생성자는 당신이 당신의 덧셈 연산자에 일을 int에서 새로운 Base<int>을 만들 때마다 호출되는 것을 특징으로 서명 Base(const Base&)

있을 것입니다.

마지막으로 std :: transform()은 출력 반복기 할당 연산자를 사용하여 함수의 결과를 출력에 할당합니다. 복사본을 모두 피하려면을 사용하고 std::bind2nd(std::mem_fun_ref(&Base<int>::operator +=), 4))을 사용해야합니다. 이렇게하면 참조에 따라 작동하므로 사본을 만들지 않습니다.