C++ 运营商>&燃气轮机；及<&书信电报；输出时输出为空

我不明白为什么当我输出两个函数时，它们的输出都被置零：

class uint128_t{

private:
    uint64_t UPPER, LOWER;

public:
    // constructors
    uint128_t(){
        UPPER = 0;
        LOWER = 0;
    }

    template <typename T>
    uint128_t(T rhs){
        UPPER = 0;
        LOWER = (uint64_t) rhs;
    }

    template <typename S, typename T>
    uint128_t(const S upper_rhs, const T lower_rhs){
        UPPER = (uint64_t) upper_rhs;
        LOWER = (uint64_t) lower_rhs;
    }

    uint128_t(const uint128_t & rhs){
        UPPER = rhs.UPPER;
        LOWER = rhs.LOWER;
    }

    //  RHS input args only

    // assignment operator
    template <typename T> uint128_t & operator=(T rhs){
        UPPER = 0;
        LOWER = (uint64_t) rhs;
        return *this;
    }

    uint128_t & operator=(uint128_t & rhs){
        UPPER = rhs.UPPER;
        LOWER = rhs.LOWER;
        return *this;
    }


    uint128_t operator<<(int shift){
        if (shift >= 128)
            return uint128_t(0, 0);
        else if (shift == 64)
            return uint128_t(LOWER, 0);
        else if (shift < 64)
            return uint128_t((UPPER << shift) + (LOWER >> (64 - shift)), LOWER << shift);
        else if ((128 > shift) && (shift > 64)){
            uint128_t a =uint128_t(LOWER << (shift - 64), 0);
            // a will show the correct values 
            std::cout << a.upper() << " " << a.lower() << std::endl;
            return uint128_t(LOWER << (shift - 64), 0);
            // in the program that includes this, printing out the values show 0 0
        }
    }

    uint128_t operator>>(int shift){
        if (shift >= 128)
            return uint128_t(0, 0);
        else if (shift == 64)
            return uint128_t(0, UPPER);
        else if (shift <= 64)
            return uint128_t(UPPER >> shift , ((UPPER << (64 - shift))) + (LOWER >> shift));
        else if ((128 > shift) && (shift > 64))
            return uint128_t(0, (UPPER >> (shift - 64)));
    }

    uint128_t operator<<=(int shift){
        *this = *this << shift;
        return *this;
    }

    uint128_t operator>>=(int shift){
        *this = *this >> shift;
        return *this;
    }

    const uint64_t upper() const {
        return UPPER;
    }

    const uint64_t lower() const {
        return LOWER;
    }

// lots of other stuff

};

int main(){

    uint128_t a(0x123456789abcdef1ULL, 0x123456789abcdef1ULL);

    a>>= 127; // or a <<= 127;
    std::cout <<a.upper() << " " <<a.lower() << std::endl;
    return 0;
}

类uint128\u t{
私人：
uint64_t上部、下部；
公众：
//建设者
uint128_t（）{
上限=0；
下限=0；
}
模板
uint128_t（t右侧）{
上限=0；
下部=（uint64_t）右侧；
}
模板
uint128_t（上横截面右横截面，下横截面右横截面）{
上=（uint64）上右；
下部=（uint64）下部右侧；
}
uint128_t（建筑、uint128_t和rhs）{
上部=右侧上部；
下=右下。下；
}
//仅限RHS输入参数
//赋值运算符
模板uint128\U t和运算符=（t rhs）{
上限=0；
下部=（uint64_t）右侧；
归还*这个；
}
uint128\U t和运算符=（uint128\U t和rhs）{
上部=右侧上部；
下=右下。下；
归还*这个；
}
uint128_t运算符（64移位）），下移）和（移位>64））{
uint128_t a=uint128_t（下移）和&（下移>64））
返回uint128_t（0，（上>>（移位-64））；
}
uint128\u t操作员>班次；
归还*这个；
}
常数uint64\u t上限（）常数{
返回上；
}
常数uint64\u t下限（）常数{
返回较低；
}
//还有很多其他的东西
};
int main（）{
uint128_t a（0x123456789ABCDEF1LL，0x123456789ABCDEF1UL）；
a> >=127；//或a
>127
表示将数字中最右边的127位移出。由于uint128\u t为0x1234….，最高有效位为“0”。在
a>=127
之后，数字变为0，因此输出为预期的
0


至于
<127
意味着将数字中最右边的127位移出。由于uint128\u t是0x1234…，最高有效位是“0”。在
a>=127
之后，数字变为0，因此输出是预期的
0


至于
您的int是128位，您将其向下（右）移动127位，这意味着最高位将移动到最低位，而所有其他位将为0

但是您的示例中的int是
0x1….
，
0x1
（最高半字节）是二进制的
0001
，没有设置高位。因此0是正确的输出

如果您将
0x1…
更改为
0x8…
（或高于0x7的任何值），您很可能会在输出中看到0…1。
您的int为128位，您将其下移（右）127位，这意味着最高位将移动到最低位，所有其他位将为0

但是您的示例中的int是
0x1….
，
0x1
（最高半字节）是二进制的
0001
，没有设置高位。因此0是正确的输出

如果将
0x1…
更改为
0x8…
（或高于0x7的任何值），您很可能会在输出中看到0…1。
原因如下：

UPPER
的类型是64位整数。此外，您正试图将整数移位63位，而在您的情况下，第64位是零。因此，您将丢失所有实际保留数字的63位

PS：你说过你不喜欢使用调试器，但是如果你只是使用了一个调试器，你自己就很容易弄明白了。
原因如下：

UPPER
的类型是64位整数。此外，您正试图将整数移位63位，而在您的情况下，第64位是零。因此，您将丢失所有实际保留数字的63位

PS：你说过你不喜欢使用调试器，但是如果你只是使用了一个调试器，这真的很容易理解。你试过使用调试器吗？我和调试器不会混用。我用
cout
进行调试，正如代码中所示，你不应该接受。学会使用调试器。这会让你安全度过无数个小时的生活。（还有，你的
cout
-技能似乎不足以解决这个问题）。“我和调试器不能混合”好吧，克服它。：）你试过使用调试器吗？我和调试器不能混合。我用
cout
进行调试，如代码所示。你不应该接受这一点。学会使用调试器。它会保护你无数个小时的生命。（另外，你的
能力似乎不足以解决这个问题）。“我和调试器不能混在一起”好吧，克服它。：）但是编译器会选择uint28\u t运算符而不是模板运算符one@calc：否，因为
*这是错误的，但编译器将选择uint28\u t运算符而不是模板化运算符one@calc：否，因为这是
uint128_t & operator=(uint128_t & rhs)

template <typename T> uint128_t & operator=(T rhs)

    *this = *this << shift;

uint128_t& operator=(const uint128_t& rhs)
//                   ^^^^^