nlogn's log :: 천천히 달리기

#include <iostream>
#include <list>

using namespace std;

// 아이템 구조체
struct Item
{
  Item( int itemCd, int buyMoney )
  {
    ItemCd = itemCd;
    BuyMoney = buyMoney;
  }

  int ItemCd;  // 아이템코드
  int BuyMoney;  // 판매금액
};

void main()
{
  list< Item > Itemlist;

  // 앞에 데이터 추가
  Item item1( 1, 2000 );
  Itemlist.push_front( item1 );

  Item item2( 2, 1000 );
  Itemlist.push_front( item2 );

  // 뒤에 데이터 추가
  Item item3( 3, 3000 );
  Itemlist.push_back( item3 );

  Item item4( 4, 4500 );
  Itemlist.push_back( item4 );

  // 아이템 코드 번호가 2, 1, 3, 4의 순서로 출력된다.
  list< Item >::iterator iterEnd = Itemlist.end();
  for(list< Item >::iterator iterPos = Itemlist.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "아이템 코드 : " << iterPos->ItemCd << endl;
  }

  // 앞에 있는 데이터를 삭제한다.
  Itemlist.pop_front();

  // 앞에 있는 데이터의 참조를 반환한다.
  Item front_item = Itemlist.front(); 
  // 아이템 코드 1이 출력된다.
  cout << "아이템 코드 : " << front_item.ItemCd << endl;


  // 마지막에 있는 데이터를 삭제한다.
  Itemlist.pop_back();

  // 마지막에 있는 데이터의 참조를 반환한다.
  Item back_item = Itemlist.back();
  // 아이템 코드 3이 출력된다.
  cout << "아이템 코드 : " << back_item.ItemCd << endl;

  // 저장된 데이터가 있는가?
  if( false == Itemlist.empty() )
  {
    list< Item >::size_type Count = Itemlist.size();
    cout << "남아 있는 아이템 개수: " << Count << endl;
  }

  // 모든 데이터를 지운다.
  Itemlist.clear();
  list< Item >::size_type Count = Itemlist.size();
  cout << "남아 있는 아이템 개수: " << Count << endl;
}

원형 : iterator insert( iterator _Where, const Type& _Val );
       void insert( iterator _Where, size_type _Count, const Type& _Val );
       template void insert( iterator _Where, 
          InputIterator _First, InputIterator _Last );

list< int >::iterator iterInsertPos = list1.begin();
list1.insert( iterInsertPos, 100 );

iterInsertPos = list1.begin();
++iterInsertPos;
list1.insert( iterInsertPos, 2, 200 );

list< int > list2;
list2.push_back( 1000 );
list2.push_back( 2000 );
list2.push_back( 3000 );

iterInsertPos = list1.begin();
list1.insert( ++iterInsertPos, list2.begin(), list2.end() );

#include <iostream>
#include <list>

using namespace std;


void main()
{
  list< int > list1;

  list1.push_back(20);
  list1.push_back(30);


  cout << "삽입 테스트 1" << endl;

  // 첫 번째 위치에 삽입한다.
  list< int >::iterator iterInsertPos = list1.begin();
  list1.insert( iterInsertPos, 100 );
  
  // 100, 20, 30 순으로 출력된다.
  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }


  cout << endl << "삽입 테스트 2" << endl;

  // 두 번째 위치에 200을 2개 삽입한다.
  iterInsertPos = list1.begin();
  ++iterInsertPos;
  list1.insert( iterInsertPos, 2, 200 );
  
  // 100, 200, 200, 20, 30 순으로출력된다.
  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }


  cout << endl << "삽입 테스트 3" << endl;

  list< int > list2;
  list2.push_back( 1000 );
  list2.push_back( 2000 );
  list2.push_back( 3000 );

  // 두 번째 위치에 list2의 모든 데이터를 삽입한다.
  iterInsertPos = list1.begin();
  list1.insert( ++iterInsertPos, list2.begin(), list2.end() );
  
  // 100, 1000, 2000, 3000, 200, 200, 20, 30 순으로출력된다.
  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
}

결과



erase

erase는 지정된 범위에 있는 데이터 삭제하며, 두 가지 방식이 있습니다. 하나는 지정된 위치의 데이터를 삭제하고, 다른 하나는 지정된 범위의 데이터를 삭제합니다.

원형 : iterator erase( iterator _Where );
       iterator erase( iterator _First, iterator _Last );

그림 9. erase의 두 가지 방법

첫 번째 erase는 지정한 위치의 요소를 삭제합니다. 다음은 첫 번째 요소를 삭제하는 코드입니다.

list1.erase( list1.begin() );

두 번째 erase는 지정한 반복자 요소만큼 삭제합니다. 다음 코드는 list1의 두 번째 요소에서 마지막까지 모두 삭제합니다.

list< int >::iterator iterPos = list1.begin();
++iterPos;
list1.erase( iterPos, list1.end() );

아래는 erase의 두 가지 사용 방법을 보여주는 전체 코드입니다.

void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(30);
  list1.push_back(40);
  list1.push_back(50);

  cout << "erase 테스트 1" << endl;

  // 첫 번째 데이터 삭제
  list1.erase( list1.begin() );

  // 20, 30, 40, 50 출력
  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "erase 테스트2" << endl;

  // 두 번째 데이터에서 마지막까지 삭제한다.
  list< int >::iterator iterPos = list1.begin();
  ++iterPos;
  list1.erase( iterPos, list1.end() );
  
  // 20 출력
  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
}

결과

list 반복자의 랜덤 접근
위 에서 두 번째 위치에 접근하기 위해 ++iterPos를 사용했습니다. 만약 세 번째 위치로 이동하려면 한 번 더 ++iterPos를 해야 합니다. list는 랜덤 접근이 안 되므로 원하는 위치까지 하나씩 이동해야 합니다. 그러나 vector와 같이 랜덤 접근이 가능한 컨테이너는 다음 코드처럼 바로 접근할 수 있습니다.

iterPos = vector.begin() + 3;

반복문에서 list의 데이터를 삭제하면서 반복하는 경우 조심하지 않으면 버그가 발생합니다. 아래의 코드를 잘 봐주세요.

#include <iostream>
#include <list>

using namespace std;

void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(30);
  list1.push_back(40);
  list1.push_back(50);
  
  list< int >::iterator iterPos = list1.begin();
  while( iterPos != list1.end() )
  {
    // 3으로 나누어지는 것은 제거한다.
    if( 0 == (*iterPos % 3) )
    {
      // 삭제 되는 것의 다음 반복자를 저장하고 또 이동하지 않게 한다.
      iterPos = list1.erase( iterPos );
      continue;
    }
    cout << "list1 : " << *iterPos << endl;
    ++iterPos;
  }
}

remove

list에서 지정한 값과 일치하는 모든 데이터 삭제. erase와 다른 점은 erase는 반복자를 통해서 삭제하지만 remove는 값을 통해서 삭제합니다.

원형 : void remove( const Type& _Val );

list1에 담겨 있는 요소 중 특정 값과 일치하는 것을 모두 삭제하고 싶을 때는 아래와 같이 합니다.

// 20을 삭제한다.
list1.remove( 20 );

위에서는 값 삭제를 했지만 list가 구조체(클래스)의 포인터를 담고 있다면 삭제를 원하는 구조체의 포인터를 통해서 삭제가 가능합니다. 아래는 pitem2 구조체의 포인터를 삭제합니다.

// Item 포인터를 담아야한다.
list< Item* > Itemlist;

Item* pitem1 = new Item( 10, 100 );  Itemlist.push_back( pitem1 );
Item* pitem2 = new Item( 20, 200 );  Itemlist.push_back( pitem2 );
Item* pitem3 = new Item( 30, 300 );  Itemlist.push_back( pitem3 );

// pitem2를 삭제한다.
Itemlist.remove( pitem2 );

remove의 사용법에 대한 전체 코드입니다.

#include <iostream>
#include <list>

using namespace std;

// 아이템 구조체
struct Item
{
  Item( int itemCd, int buyMoney )
  {
    ItemCd = itemCd;
    BuyMoney = buyMoney;
  }

  int ItemCd;  // 아이템 코드
  int BuyMoney;  // 판매 금액
};


void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(20);
  list1.push_back(30);

  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "remove  테스트 1" << endl;

  // 20을 삭제한다.
  list1.remove( 20 );

  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
  

  cout << endl << "remove  테스트 2 - 구조체를 삭제" << endl;

  // Item 포인터를 담아야한다.
  list< Item* > Itemlist;
  
  Item* pitem1 = new Item( 10, 100 );  Itemlist.push_back( pitem1 );
  Item* pitem2 = new Item( 20, 200 );  Itemlist.push_back( pitem2 );
  Item* pitem3 = new Item( 30, 300 );  Itemlist.push_back( pitem3 );
  
  // pitem2를 삭제한다.
  Itemlist.remove( pitem2 );
  
  list< Item* >::iterator iterEnd2 = Itemlist.end();
  for(list< Item* >::iterator iterPos = Itemlist.begin(); 
    iterPos != iterEnd2; 
    ++iterPos )
  {
    cout << "Itemlist : " << (*iterPos)->ItemCd << endl;
  }
}

결과



에서 구조체의 포인터를 담아서 삭제하는 것을 잘 보시기를 바랍니다. 보통 책에서는 이미 정의된 자료 타입만을 삭제하는 것을 보여주는데 사용자 정의 타입이라도 포인터로 담으면 해당 포인터로 삭제가 가능합니다.

remove_if

predicate을 만족하는 모든 데이터 삭제.
remove와 다른 점은 함수 객체를 사용하여 매개 변수로 전달된 인자를 조사하여 true라면 삭제하는 것입니다.
참고로 함수 객체라는 것은 괄호 연산자를 멤버함수로 가지는 클래스(또는 구조체) 객체입니다.
일반적으로 많이 사용되는 함수 객체는 STL에 정의 되어 있습니다.

원형 : template<class Predicate> void remove_if( Predicate _Pred );

remove_if에 사용할 함수 객체를 먼저 선언합니다.

// 20 이상 30 미만이면 true
template <typename T> class Is_Over20_Under30 : public std::unary_function 
{
public:
  bool operator( ) ( T& val ) 
  {
    return ( val >= 20 && val < 30 );
  }
};

list에서 remove_if에 함수 객체를 사용하여 list의 요소를 삭제하는 방법입니다.

  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(25);
  list1.push_back(30);
  list1.push_back(34);

  // 20 이상 30 미만은 삭제한다.
  list1.remove_if( Is_Over20_Under30< int >() );

list1의 요소 중 20 이상 30 미만은 모두 삭제합니다.

아래는 remove_if 사용 예입니다.

#include <iostream>
#include <list>

using namespace std;

// 20 이상 30 미만이면 true
template <typename T> class Is_Over20_Under30 : public std::unary_function 
{
public:
   bool operator( ) ( T& val ) 
   {
      return ( val >= 20 && val < 30 );
   }
};

void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(25);
  list1.push_back(30);
  list1.push_back(34);

  // 20 이상 30 미만은 삭제한다.
  list1.remove_if( Is_Over20_Under30< int >() );

  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
}

결과



sort

데이터들을 정렬합니다. STL에 정의된 방식으로 정렬하거나 사용자가 정의한 방식으로 정렬할 수 있습니다.

원형 : template<class Traits> void sort( Traits _Comp );

sort 멤버를 사용하면 list1에 있는 요소들이 올림차순으로 정렬합니다.

// 올림 차순으로 정렬한다.
list1.sort();

내림차순으로 정렬한다면 greater를 사용합니다.

list1.sort( greater< int >() );

greater< int >는 greater< T > 라는 이미 정의되어 있는 함수 객체를 사용한 것입니다.
greater< int >는 int 형 x, y를 비교해서 x > y이면 true를 반환합니다.
그리고 greater외에 >=의 greater_equal, <=의 less_equal를 사용할 수 있습니다.
greater 이외의 것도 사용해 보기를 바랍니다.
사용자 정의 함수로 정렬하려면 함수 객체를 만들어야 합니다.
아래 함수 객체는 T의 멤버 중 ItemCd를 서로 비교하여 정렬을 합니다.

// 함수 객체 정의
template <typename T> struct COMPARE_ITEM
{
  bool operator()( const T l, const T r ) const
  {
    // 정렬 시에는 올림 차순으로된다. 내림 차순으로 하고 싶으면 < 에서 > 로
    // 변경하면 된다.
    return l.ItemCd < r.ItemCd;
  }
};

정의가 끝나면 아래와 같이 사용하면 됩니다.

Itemlist.sort( COMPARE_ITEM< Item >() );

Itemlist가 담고 있는 Item은 ItemCd를 기준으로 올림 차순으로 정렬한다.
아래 list의 sort 및 유저가 정의한 함수 객체를 사용한 sort에 대한 코드입니다.

#include <iostream>
#include <list>

using namespace std;


// 함수 객체 정의
template <typename T> struct COMPARE_ITEM
{
    bool operator()( const T l, const T r ) const
    {
    // 정렬 시에는 올림 차순으로된다. 내림 차순으로 하고 싶으면 < 에서 > 로
    // 변경하면 된다.
      return l.ItemCd < r.ItemCd;
    }
};

void main()
{
  list< int > list1;

  list1.push_back(20);
  list1.push_back(10);
  list1.push_back(35);
  list1.push_back(15);
  list1.push_back(12);

  cout << "sort 올림차순" << endl;
  // 올림 차순으로 정렬한다.
  list1.sort();

  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "sort 내림차순" << endl;
  // 내림 차순으로 정렬한다.
  list1.sort( greater< int >() );

  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "sort - 유저가 정의한 방식으로 정렬" << endl;

  list< Item > Itemlist;
  
  Item item1( 20, 100 );  Itemlist.push_back( item1 );
  Item item2( 10, 200 );  Itemlist.push_back( item2 );
  Item item3( 7, 300 );  Itemlist.push_back( item3 );
  
  // 정렬한다.
  Itemlist.sort( COMPARE_ITEM< Item >() );
  
  list< Item >::iterator iterEnd2 = Itemlist.end();
  for(list< Item >::iterator iterPos = Itemlist.begin(); 
    iterPos != iterEnd2; 
    ++iterPos )
  {
    cout << "Itemlist : " << iterPos->ItemCd << endl;
  }
}

결과



보통 책에서는 list에서 제공하는 sort를 사용하는 설명이 일반적입니다. 그러나 현실에서는 유저정의 형의 데이터를 list에 담아서 사용하므로 유저가 정의한 함수 객체를 사용하여 정렬하는 경우가 많습니다.
이것으로 list에서 일반적으로 가장 자주 사용하는 멤버들에 대해서 알아 보았습니다.
아직 소개하지 않은 멤버들도 더 있습니다. 그러나 보통 현재까지 설명한 것들만 알고 있으면 list를 사용하는데 별 어려움이 없습니다. 소개하지 않은 멤버는 뒤에 표로 정리하겠습니다.
그럼 지금까지 배운 것을 토대로 list를 사용하여 이전 회에서 만들었던 스택을 개선해 보겠습니다.

list를 사용한 스택

이전 회에 설명한 template로 만들었던 스택에 대해서 잘 기억이 나지 않는 분들은 다시 한번 봐 주세요.

http://network.hanb.co.kr/view.php?bi_id=1572

이전 회에 만들었던 스택은 유연성이 부족합니다. 저장 공간의 크기가 고정적이고, LIFO(후입선출. 마지막에 들어간 것이 먼저 나온다) 방식으로만 작동합니다. 이것을 저장 공간의 크기가 가변적이고, FIFO(선입선출. 먼저 들어간 것이 먼저 나온다) 방식으로도 저장이 가능하도록 합니다.

#include <iostream>
#include <list>

using namespace std;

template<typename T> 
class Stack
{
public:
  Stack() { Clear(); }

  // 저장 방식을 설정한다.
  void SetInOutType( bool bLIFO ) { m_bLIFO = bLIFO; }

  // 초기화 한다.
  void Clear()
  {
    if( false == m_Datas.empty() )
      m_Datas.clear();
  }

  // 스택에 저장된 개수
  int Count() { return static_cast( m_Datas.size() ); }

  // 저장된 데이터가 없는가?
  bool IsEmpty() { return m_Datas.empty(); }

  
  // 데이터를 저장한다.
  void push( T data )
  {
    m_Datas.push_back( data ); 
  }

  // 스택에서 빼낸다.
  bool pop( T* data )
  {
    if( IsEmpty() )
    {
      return false;
    }


    if( m_bLIFO )
    {
      memcpy( data, &m_Datas.back(), sizeof(T) );
      m_Datas.pop_back();
    }
    else
    {
      memcpy( data, &m_Datas.front(), sizeof(T) );
      m_Datas.pop_front();
    }

    return true;
  }

private:
  list m_Datas;
  bool  m_bLIFO; // true 이면 후입선출, false 이면 선입선출
};



void main()
{
  Stack< int > Int_Stack;

  // LIFO로 설정
  Int_Stack.SetInOutType( true );

  Int_Stack.push( 10 );
  Int_Stack.push( 20 );
  Int_Stack.push( 30 );

  int Value = 0;
  Int_Stack.pop( &Value );
  cout << "LIFO pop : " << Value << endl << endl;

  Int_Stack.Clear();


  // FIFO로 설정
  Int_Stack.SetInOutType( false );

  Int_Stack.push( 10 );
  Int_Stack.push( 20 );
  Int_Stack.push( 30 );

  Int_Stack.pop( &Value );
  cout << "FIFO pop : " << Value << endl << endl;
}

결과



List에 대해서 가장 많이 사용하는 것을 기준으로 설명했는데 그림과 예제 코드를 보면서 이해가 잘 되었는지 모르겠네요.

보통 STL 관련 글을 보면 int나 float과 같은 기본 자료 타입을 사용하는 것에 대해서는 잘 나오지만, 유저 정의 자료 형을 사용하는 것에 대해서는 잘 나오지 않습니다. 그러니 예제 코드 중 유저 정의 자료 형을 사용한 부분을 특히 잘 보시기를 바랍니다. 다만, 유저 정의 자료 형을 사용하는 경우 함수 객체라는 것을 알아야 정확하게 이해가 될 테니 함수 객체 부분에 대해서는 아직 설명을 제대로 하지 않아서 잘 이해가 되지 않을까 걱정이 됩니다. 이 부분에 대해서는 다음에 함수 객체에 대해서 설명할 때 다시 언급 하겠습니다.

list의 멤버는 제가 설명한 것 이외에도 더 있으니 좀 더 알고 싶은 분들은 http://msdn.microsoft.com/en-us/library/00k1x78a.aspx를 참고해 주세요.


표 3. 설명하지 않은 list의 멤버들

과제

이번 회부터는 STL 라이브러리를 설명하고 있으므로 배운 것을 활용하여 프로그램을 만들어 볼 수가 있습니다. 일방적으로 저의 글만 보는 것은 심심할 테니 제가 내는 문제를 풀어 보시기를 바랍니다.^^


[과제 그림 1] 점 5개로 이루어진 도형

위 그림은 순서대로 A, B, C, D, E 점을 찍은 후 서로 연결하여 도형이 만들어진 것입니다.

과제 1) 이것을 list를 사용하여 만들어 보세요

꼭 그림을 그리지 않아도 됩니다. A, B, C, D, E의 값을 순서대로 넣고 순서대로 출력하면 됩니다.


[과제 그림 2] 새로운 점 F 추가

과제 2) 점 F가 새로 추가 되었습니다. A, B, C, D, F, E 순으로 선이 연결 되도록 해 보세요.

과제 3) 점 D의 값을 (200, 100)으로 변경해 보세요.

과제 4) 점 C를 삭제해 보세요.

아주 간단하게 list 조작을 테스트 해 볼 수 있는 간단한 과제라고 생각합니다. 꼭 프로그램을 만들어 보세요.


[츨처 : http://www.hanb.co.kr/network/view.html?bi_id=1585]

__int64 Max(__int64 a, __int64 b )
{
  return a > b ? a : b;
}

Max 함수를 하나로 만들고 싶습니다. 어떻게 해야 될까요?

#include 
using namespace std;

// 템플릿으로 만든 값을 비교하는 Max 함수
template 
T Max(T a, T b )
{
  return a > b ? a : b;
}


void main()
{
  int Char1_HP = 300;
  int Char2_HP = 400;
  int MaxCharHP = Max( Char1_HP, Char2_HP );
  cout << "HP 중 가장 큰 값은" << MaxCharHP << "입니다." << endl << endl;
  
  float Char1_Exp = 250.0f;
  float Char2_Exp = 250.57f;
  float MaxCharExp = Max( Char1_Exp, Char2_Exp );
  cout << "경험치 중 가장 큰 값은" << MaxCharExp << "입니다." << endl << endl;
}

함수 템플릿과 컴파일

int MaxCharHP = Max( Char1_HP, Char2_HP );

float MaxCharExp = Max( Char1_Exp, Char2_Exp );

Max 함수 템플릿에 개선점이 없을까요?

template 
const T& Max(const T& a, const T& b )
{
  return a > b ? a : b;
}

class T 라는 것을 본적이 있나요?

template 
const T& Max(const T& a, const T& b )
{
  return a > b ? a : b;
}

이제 Max 함수 템플릿에는 문제가 없을까요?

// List3의 Max 함수 템플릿을 사용합니다.
void main()
{
  int Char1_MP = 300;
  double Char1_SP = 400.25;
  double MaxValue1 = Max( Char1_MP, Char1_SP );
  cout << "MP와 SP 중 가장 큰값은" << MaxValue1 << "입니다." << endl << endl;
  
  double MaxValue2 = Max( Char1_SP, Char1_MP );
  cout << "MP와 SP 중 가장 큰값은" << MaxValue2 << "입니다." << endl << endl;
}

max.cpp
max.cpp(16) : error C2782: 'const T &Max(const T &,const T &)' 
        : 템플릿 매개 변수 'T'이(가) 모호합니다.
        max.cpp(6) : 'Max' 선언을 참조하십시오.
        'double'일 수 있습니다.
        또는      'int'
max.cpp(19) : error C2782: 'const T &Max(const T &,const T &)' 
        : 템플릿 매개 변수 'T'이(가) 모호합니다.
        max.cpp(6) : 'Max' 선언을 참조하십시오.
        'int'일 수 있습니다.
        또는      'double'

typename을 하나가 아닌 복수 개 사용하면 됩니다.

template 
const T1& Max(const T1& a, const T2& b )
{
  return a > b ? a : b;
}

int Char1_MP = 300;
double Char1_SP = 400.25;
double MaxValue1 = Max( Char1_MP, Char1_SP );

Max( int, double);

함수 템플릿의 전문화 라는 것이 있습니다.

#include 
using namespace std;

// 템플릿으로만든값을비교하는Max 함수
template 
const T1& Max(const T1& a, const T2& b )
{
  cout << "Max(const T& a, const T& b) 템플릿 버전 사용" << endl;
  return a > b ? a : b;
}

// 전문화시킨Max 함수
template <> 
const double& Max(const double& a, const double& b)
{
  cout << "Max(const double& a, const double& b) 전문화 버전 사용" << endl;
  return a > b ? a : b;
}

void main()
{
  double Char1_MP = 300;
  double Char1_SP = 400.25;
  double MaxValue1 = Max( Char1_MP, Char1_SP );
  cout << "MP와 SP 중 가장 큰 값은" << MaxValue1 << "입니다." << endl << endl;
  
  int Char2_MP = 300;
  double Char2_SP = 400.25; 
  double MaxValue2 = Max( Char2_MP, Char2_SP );
  cout << "MP와 SP 중 가장 큰 값은" << MaxValue2 << "입니다." << endl << endl;
}

1. 전문화된 함수와 맞는지 검사한다.
2. 템플릿 함수와 맞는지 검사한다.
3. 일반 함수와 맞는지 검사한다.

난-타입(non-type) 함수 템플릿

#include <iostream>
using namespace std;

// 지정된 값만큼 더해준다.
template <typename T, int VAL>
T AddValue( T const& CurValue)
{
  return CurValue + VAL;
}

const int EVENT_ADD_HP_VALUE  = 50;    // 이벤트에 의해 추가 될 HP 값
const int EVENT_ADD_EXP_VALUE  = 30;    // 이벤트에 의해 추가 될 경험치
const int EVENT_ADD_MONEY_VALUE  = 10000;    // 이벤트에 의해 추가 될 돈

void main()
{
  int Char_HP = 250;
  cout << Char_HP <<"에서 이벤트에 의해" << AddValue<int, 
       EVENT_ADD_HP_VALUE>(Char_HP) << " 로 변경" <<endl;

  float Char_EXP = 378.89f;
  cout << Char_EXP <<"에서 이벤트에 의해" << AddValue<float, 
       EVENT_ADD_EXP_VALUE>(Char_EXP) << " 로 변경" <<endl;

  __int64 Char_MONEY = 34567890;
  cout << Char_MONEY <<"에서 이벤트에 의해" << AddValue<__int64,   
       EVENT_ADD_MONEY_VALUE>(Char_MONEY) << " 로 변경" <<endl;
}