[STL] utility : minmax, move, forward, swap

 

 

# std::minmax

std::min과 std::max는 많이 써봤지만 std::minmax는 써보지 않았다. 사용 방법은 심플하다. std::minmax는 std::pair를 반환하는데, 첫 번째가 최솟값, 두 번째가 최댓값이다.

min, max, minmax 모두 디폴트 연산자는 '<'이지만 predicate를 활용해서 다른 비교 연산자를 지정할 수도 있다.

#include <algorithm>
#include <cmath>
#include <iostream>
#include <string>

int main(){

  std::cout << std::endl;

  std::string first{"first"};
  std::string second{"second"};

  auto minInt= std::min({3, 1, 2011, 2014, -5});

  std::cout << "std::min(2011, 2014): " << std::min(2011, 2014) << std::endl;
  std::cout << "std::min(first, second): " << std::min(first, second) << std::endl;
  std::cout << "std::min({3, 1, 2011, 2014, -5}): " << std::min({3, 1, 2011, 2014, -5}) << std::endl;
  std::cout << "std::min(-10, -5, [](int a, int b){return std::abs(a) < std::abs(b);}): "  <<
                std::min(-10, -5, [](int a, int b){return std::abs(a) < std::abs(b);}) << std::endl;


  std::cout << std::endl;

  std::cout << "std::max(2011, 2014): " << std::max(2011, 2014) << std::endl;
  std::cout << "std::max(first, second): " << std::max(first, second) << std::endl;
  std::cout << "std::max({3, 1, 2011, 2014, -5}): " << std::max({3, 1, 2011, 2014, -5}) << std::endl;
  std::cout << "std::max(-10, -5, [](int a, int b){return std::abs(a) < std::abs(b);}): "  <<
                std::max(-10, -5, [](int a, int b){return std::abs(a) < std::abs(b);}) << std::endl;


  std::cout << std::endl;

  auto pairInt= std::minmax(2011, 2014);
  auto pairStr= std::minmax(first, second);
  auto pairSeq= std::minmax({3, 1, 2011, 2014, -5});
  auto pairAbs= std::minmax({3, 1, 2011, 2014, -5}, [](int a, int b){return std::abs(a) < std::abs(b);});

  std::cout << "(pairInt.first, pairInt.second): (" << pairInt.first << ", " << pairInt.second << ")" << std::endl;
  std::cout << "(pairStr.first, pairStr.second): (" << pairStr.first << ", " << pairStr.second << ")" << std::endl;
  std::cout << "(pairSeq.first, pairSeq.second): (" << pairSeq.first << ", " << pairSeq.second << ")" << std::endl;
  std::cout << "(pairAbs.first, pairAbs.second): (" << pairAbs.first << ", " << pairAbs.second << ")" << std::endl;

  std::cout << std::endl;


}

 

 

# std::move

<utility>에 정의된 std::move는 리소스를 이동할 수 있게 해주는 강력한 기능이다. std::move를 사용하면 소스(arg)를 우측값 참조로 변환한다.

std::move와 우측값 참조에 대해서는 C++기초 시리즈에서 다룰 예정이다. 자세한 사항은 모두의코드를 참조하자.

https://modoocode.com/301

C++ 레퍼런스 - std::move 함수

 

 

 

# std::forward

std::forward는 주어진 인수를 그대로 전달하는 함수 템플릿을 작성할 수 있다. std::forward는 팩토리 함수나 생성자를 만드는 데 주로 활용한다. 

#include <initializer_list>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

struct MyData{
  MyData(){};
  MyData(int, double, char){};
};

template <typename T,  typename ... Args>
T createT(Args&&...args){
  return T(std::forward<Args>(args)...);
}

int main(){

  int a= createT<int>();
  int b= createT<int>(1);

  std::string s= createT<std::string>("Only for testing purpose.");

  MyData myData= createT<MyData>();
  MyData myData2= createT<MyData>(1, 3.19, 'a');

  typedef std::vector<int> IntVec;
  IntVec intVec= createT<IntVec>(std::initializer_list<int>({1, 2, 3, 4, 5}));

}

함수 템플릿인 createT는 인수를 보편 참조 형식인 'Arg&&...args'로 받아야 한다. 보편 참조란 타입 추론에서 우측값 참조인 것을 말하며 전달 참조라고도 부른다. std::forward와 가변 인수 템플릿을 조합하면 완벽한 제네릭 함수를 만들 수 있다.

 

# std::swap

두 오브젝트를 맞바꾸는 작업을 std::swap을 통해 손 쉽게 처리할 수 있다. 내부적으로는 std::move를 활용하고 있다.

#include <algorithm>
#include <iostream>
#include <vector>


template <typename T>
void swap(T& a, T& b){
    T tmp(std::move(a));
    a = std::move(b);
    b = std::move(tmp);
}

struct MyData{
  std::vector<int> myData;

  MyData():myData({1, 2, 3, 4, 5}){}

  // copy semantic
  MyData(const MyData& m):myData(m.myData){
    std::cout << "copy constructor"  << std::endl;
  }

  MyData& operator=(const MyData& m){
    myData= m.myData;
    std::cout << "copy assignment operator"  << std::endl;
    return *this;
  }

};

int main(){

  std::cout << std::endl;

  MyData a, b;
  swap(a, b);

  std::cout << std::endl;

};

 

cppreference의 예제를 보자.

#include <algorithm>
#include <iostream>
 
namespace Ns
{
    class A
    {
        int id {};
 
        friend void swap(A& lhs, A& rhs)
        {
            std::cout << "swap(" << lhs << ", " << rhs << ")\n";
            std::swap(lhs.id, rhs.id);
        }
 
        friend std::ostream& operator<<(std::ostream& os, A const& a)
        {
            return os << "A::id=" << a.id;
        }
 
    public:
        A(int i) : id {i} {}
        A(A const&) = delete;
        A& operator = (A const&) = delete;
    };
}
 
int main()
{
    int a = 5, b = 3;
    std::cout << a << ' ' << b << '\n';
    std::swap(a, b);
    std::cout << a << ' ' << b << '\n';
 
    Ns::A p {6}, q {9};
    std::cout << p << ' ' << q << '\n';
//  std::swap(p, q); // error, type requirements are not satisfied
    swap(p, q);      // OK, ADL finds the appropriate friend `swap`
    std::cout << p << ' ' << q << '\n';
}

// Output
5 3
3 5
A::id=6 A::id=9
swap(A::id=6, A::id=9)
A::id=9 A::id=6