숫자 값 래퍼

Question

숫자 값을 래핑하는 C++ 프로그램을 작성하려고합니다. 두 개의 간단한 함수와 연산자 오버로딩 함수를 처리 할 수퍼 클래스를 작성하여이 작업을 수행하고 있습니다.

주요 기능에

#include <iostream> 
#include <string> 
#include <sstream> 
using namespace std; 



template <class T> 
class Number { 
protected: 
    T number; 

public: 
    Number(T num) { 
     number = num; 
    } 

    string mytype() { 
     return typeid(number).name(); 
    } 

    string what_am_i() { 
     ostringstream oss; 
     oss << "I am " << Number<T>::mytype() << " and my value is " << number; 
     return oss.str(); 
    } 

    Number operator+ (Number an) { 
     Number brandNew = NULL; 
     brandNew.number = number + an.number; 
     return brandNew; 
    } 
}; 


class MyInt : public Number<int> { 
public: 
    MyInt() : Number<int>(0) {}; 
    MyInt(int num) : Number<int>(num) {} 
    MyInt(const Number<int> &x) : Number<int>(x) {} 
}; 



class MyFloat : public Number<float> { 
public: 
    MyFloat() : Number<float>(0){}; 
    MyFloat(float num) : Number(num){} 
    MyFloat(const Number<float> &x) : Number<float>(x) {} 
}; 

class MyDouble : public Number<double> { 
public: 
    MyDouble() : Number<double>(0){}; 
    MyDouble(double num) : Number(num){} 
    MyDouble(const Number<double> &x) : Number<double>(x) {}  
}; 

내가 좋아하는 뭔가를하고 싶으면 : 이것은 내가 지금까지 가지고있는 코드입니다

void main() {  
    MyInt two = 2;  
    MyFloat flo = 5.0f; 
    MyDouble md3 = flo + two; 
} 

을 그리고, 15.00000가 될 MD3 기원이의 지금 또한 최대 같은 유형의 객체는 훌륭하게 작동하지만 MyInt와 MyFloat를 추가하려고 할 때 컴파일러는 그것을 좋아하지 않습니다. 아무도 내가 이것을 구현할 수있는 아이디어가 있습니까?

Answer 1

당신은 템플릿 클래스의 타입 연산자를 추가해야합니다 : 나는 그것이 작동하는 이유를 잘 설명하려고

template <class T> 
class Number { 
protected: 
    T number; 

public: 
    Number(T num) { 
     number = num; 
    } 

    string mytype() { 
     return typeid(number).name(); 
    } 

    string what_am_i() { 
     ostringstream oss; 
     oss << "I am " << Number<T>::mytype() << " and my value is " << number; 
     return oss.str(); 
    } 

    Number operator+ (Number an) { 
     Number brandNew = NULL; 
     brandNew.number = number + an.number; 
     return brandNew; 
    } 

    operator T() 
    { 
     return number; 
    } 
}; 

:

operator T() 
{ 
    return number; 
} 

이것은 내가 테스트 작업 그 complate 코드입니다. 더하기 연산자의 오버로드를 만들 때, left_value + right_value과 같은 것을하고 싶습니다. 여기서 right_value는 더하기 연산자의 "an"인수입니다.

개체 "an"의 올바른 값을 얻으려면 "type 연산자"를 오버로드해야합니다. Number 클래스에서이 연산자가 오버로드되지 않으면 올바른 값으로 읽을 수 없습니다 . 다음의 예) (= 오퍼레이터위한,뿐만 아니라 운영자 +()에 대한 유효 :

template<typename T> 
class Number 
{ 
    T value; 

    public: 

    T operator=(T arg) // Assignment, your class is seen as left operand 
    { 
    value = arg; 
    } 

    operator T() // Getting, your class is seen as right operand 
    { 
    return value; 
    } 
} 

Number<int>  A; // define a new class Number as int 
Number<double> B; // define a new class Number as double 

A = B; // is same to A.operator=(B.double()); 

A와 좌측 값을 할당이 호출 연산자 "연산자 =()"클래스 번호 됨과

지금이로 번역 올바른 값이 불리는 클래스 번호의 "연산자 T()"B를 얻을 :

// instance of the operator = of the class Number<int> 
int operator=(int arg) 
{ 
} 


// instance of the Operator T of the class Number<double> 
operator double() 
{ 
} 

이 traslation A와 B 개체에 대한 때라도 의미는 에뮬레이트 :

int A; 
double B; 

A = B; 

챠오 안젤로는

Answer 2

당신은 이항 연산의 결과를 지정하고 독립형 연산자를 사용할 수 있습니다 : 헤더에 피하십시오 using namespace std;을 :

#include <iostream> 
#include <typeinfo> 

template <class T> 
class Number { 
template <typename> 
friend class Number; 

protected: 
    T number; 

public: 
    Number(const T& num) 
    : number(num) 
    {} 

    template <typename U> 
    Number(const Number<U>& num) 
    : number(num.number) 
    {} 

    // ... 

    const T& value() const { return number; } 
}; 

typedef Number<int> MyInt; 
typedef Number<float> MyFloat; 
typedef Number<double> MyDouble; 

template <typename A, typename B> 
struct NumberResult; 

template <typename X> 
struct NumberResult<X, X> { 
    typedef X type; 
}; 

template <> struct NumberResult<int, float> { typedef float type; }; 
template <> struct NumberResult<float, int> { typedef float type; }; 
// ... 

template <typename A, typename B> 
inline Number<typename NumberResult<A, B>::type> 
operator + (const Number<A>& a, const Number<B>& b) { 
    return Number<typename NumberResult<A, B>::type>(a.value() + b.value()); 
} 

참고.