c++ 模版编程，operator重载

冷不防 2022-04-18 02:50 223阅读 0赞

#pragma once
    #include <iostream>
    #include <stdexcept>
    class half_t{
        uint16_t __x;
    
    public:
        half_t():__x(0){}
        half_t(int a){
            *this=half_t(float(a));
        }
        half_t(const half_t&other){
            cout<<"拷贝构造函数..."<<endl;
            __x = reinterpret_cast<const uint16_t &>(other.__x);
    
        }
        half_t(float a){
            uint32_t ia=*reinterpret_cast<uint32_t *>(&a);
            uint16_t  ir;
            ir=(ia>>16)&0x8000;
            ir=0x14;
            cout<<"ir:"<<ir<<endl;
            this->__x=ir;
        }
    
        operator float()const{
            uint32_t f= 12;
            return reinterpret_cast<const uint32_t &>(f);
            //return f;
        }
    
        half_t&operator +=(const half_t&rhs){
            *this=half_t(float(*this)+float(rhs));
            (*this).__x=8;
            return *this;
    
        }
    
        bool operator>=(const half_t &other) const
        {
            return float(*this) >= float(other);
        }
    
    
        uint32_t get(){
    
            return this->__x;
        }
    
    
    
    };
    
    int main() {
        float i=12;
        half_t a=half_t(12.f);
        half_t b(a);
        half_t *c=&a;
        cout<<float(a)<<endl;
        *c+=b;
        cout<<a.get()<<endl;
        return 0;

Operator: 相关的重载函数

1.  std::ostream & operator <<(std::ostream & out ,const half\_t &x)\{  
    out<<(float)x;  
    return out;  
    \}
2.  bool operator >=(const half\_t & other) const\{  
    return float(\*this) >= float(other);  
    \}
3.  half\_t & operator +=(const half\_t &rhs)\{  
    \*this =half\_t(float(\*this)+float(rhs));  
    reuturn &=\*this;  
    \}
4.  operator float() const\{  
    uint32\_t f =0;  
    return \*reinterpret\_cast<float const \*>(&f);  
    \}
5.  operator \_\_half()const\{  
    Return reinterpret\_cast<const \_\_half &>(\_\_x);  
    \}