は私が成功したGCC 4.6.1でコンパイルすることができます定義されたオペレータ

Question

持つクラスのInt（以下コード）と（下）演算子+を見つけることができません：

template<class Int_T> 
    class Int 
    { 
    }; 

template<class A,class B> 
A operator+(const Int<A>& left, const Int<B>& right) 

{ 
    return -1;///this is dummy 
} 



int main() 
{ 
    Int<int> a(5); 
    Int<int> b(6);//BUT IF I CHANGE TO OTHER TYPE THAN int I'M GETTING ERROR 
    auto c = a + b; 
    return 0; 
} 

エラーを私は取得しています：
... \ main.cpp | 10 | error： 'a + b'の 'operator +'に一致しません
誰かが私に間違っていることを教えてもらえますか？私はこの答えに開始して以来
EDIT（実際の例）

#ifndef IF__H_INCLUDED 
#define IF__H_INCLUDED 

template<bool Cond, class First, class Second> 
struct if_ 
{ 
    typedef typename First::type type; 
}; 

template<class First, class Second> 
struct if_<false,First,Second> 
{ 
    typedef typename Second::type type; 
}; 

#endif // IF__H_INCLUDED 
#ifndef CHOOSE_LARGER_H_INCLUDED 
#define CHOOSE_LARGER_H_INCLUDED 
#include <type_traits> 
template<class A,class B> 
struct Choose_Larger 
{ 
    typedef typename std::conditional<(sizeof(A) > sizeof(B)),A,B>::type type; 
}; 
#ifndef IS_CHAR_H_INCLUDED 
#define IS_CHAR_H_INCLUDED 
#include <type_traits> 

template<class Int_T> 
struct Is_Char_ 
{ 
    enum {value = false}; 
}; 

template<> 
struct Is_Char_<char> 
{ 
    enum {value = true}; 
}; 

template<> 
struct Is_Char_<unsigned char> 
{ 
    enum {value = true}; 
}; 

template<> 
struct Is_Char_<signed char> 
{ 
    enum {value = true}; 
}; 

template<class Int_T> 
struct Is_Char : Is_Char_<typename std::remove_cv<Int_T>::type> 
{ 

}; 

#endif // IS_CHAR_H_INCLUDED 

#endif // CHOOSE_LARGER_H_INCLUDED 
#ifndef PROMOTE_H_INCLUDED 
#define PROMOTE_H_INCLUDED 
#include <type_traits> 
#include <boost/mpl/vector.hpp> 
#include <boost/mpl/find.hpp> 
#include <boost/mpl/next.hpp> 
#include <boost/mpl/deref.hpp> 
#include <boost/mpl/end.hpp> 
#include "Is_Char.h" 

/** 
Created by Art 10/2011 
*/ 
/*Promotes Integer type to one up in size range*/ 
template<class Integer> 
struct Promote 
{ 
    static_assert(std::is_integral<Integer>::value,"Non Integer type is not allowed."); 
    /*Check correct type - depending on Integer being signed or unsigned*/ 
    typedef typename std::conditional<std::is_signed<Integer>::value, 
           boost::mpl::vector<signed char,short,int,long,long long>, 
    boost::mpl::vector<unsigned char,unsigned short,unsigned int,long,long long> 
            >::type types; 
    /* 
    Find this type from the list above - substituting Integer for signed or unsigned char iff Integer is of type char 
    */ 
    typedef typename boost::mpl::find<types, 
    typename std::conditional<Is_Char<Integer>::value, 
    typename std::conditional<std::is_signed<Integer>::value,signed char,unsigned char>::type, Integer>::type>::type this_type; 

    /*If Integer is int and if size of it is == to long promote int to long long (iterate to next element twice)*/ 
    typedef typename boost::mpl::eval_if<boost::mpl::bool_<((std::is_same<Integer,int>::value || std::is_same<Integer,unsigned int>::value) 
                   && (sizeof(int) == sizeof(long)))>, 
             boost::mpl::next<typename boost::mpl::next<this_type>::type>, 
             boost::mpl::next<this_type> 
             >::type next_type; 
    /*Check if iterator points within range or if one pass end which means that Integer was u/long long*/ 
    typedef typename std::conditional<std::is_same<typename boost::mpl::end<types>::type,next_type>::value,Integer,typename boost::mpl::deref<next_type>::type>::type type; 
}; 

#endif // PROMOTE_H_INCLUDED 

/*Add two Int types*/ 
template<class A,class B,class R = Int<typename if_<!std::is_same<Int<A>,Int<B>>::value, 
                Choose_Larger<Int<A>,Int<B>>, 
                Promote<A> 
                >::type 
             > 
     > 
R operator+(const Int<A>& left, const Int<B>& right) 

{ 
    return add<R>(left,right); 
} 

Answer 1

はまあ質問が変更されました。

これは本当にもう存在しない質問に対する答えです。

とにかく、以下の代替的なアプローチのため、残念ながらのVisual C++ 10.0はまだ新しいC++ 11関数宣言の構文をサポートしていませんが、少なくともこれはMSVCとg ++の両方でコンパイル：

#include <iostream> 

template< class IntType > 
struct Int 
{ 
    IntType value_; 
    explicit Int(IntType v = 0): value_(v) {} 
}; 

template< class IntA, class IntB > 
Int< decltype(IntA() + IntB()) > operator+(Int<IntA> a, Int<IntB> b) 
{ 
    typedef decltype(IntA() + IntB()) R; 
    return Int<R>(a.value_ + b.value_); 
} 

int main() 
{ 
    Int<int> a(5); 
    Int<long> b(6); 
    auto c = a + b; 

    std::cout << c.value_ << std::endl; 
} 

乾杯を& hth。、