address=NULL; } 模板对象(常量和值):d(新数据(\u值)) { d->address=重新解释类型(\u值); } 对象(object&_-Rhs):d(_-Rhs.d->duplicate()){ ~object() { if(具有_值()) { d->~dummy(); } } 常量std::type_info&type()常量 { 返回d->type(); } 模板\u Ty cast()常量 { if(typeid(_Ty)!=type()) { 抛出std::异常(“”); } 返回reinterpret\u cast(d)->\u内部; } 常量对象和运算符=(对象和运算符) { d=_Rhs.d->duplicate(); 归还*这个; } 模板常量对象和运算符=(常量和值)常量 { d=新数据(_值); d->address=重新解释类型(\u值); 归还*这个; } 模板bool运算符==(常量和值)常量 { 返回(type()!=typeid(\u Ty)?false:cast()=\u值); } 布尔运算符==(对象和右)常量 { return(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address); //上面测试的断点^^^ } 模板bool运算符!=(常量和值)常量 { 返回(type()==typeid(\u Ty)?false:cast()!=\u值); } 布尔运算符!=(对象和右)常量 { 返回!(*此==\u Rhs); } 布尔值为常量 { 返回!!d; } bool empty()常量 { 返回!d; } }; intmain() { 对象a=5,b=5; std::cout,c++,C++" /> address=NULL; } 模板对象(常量和值):d(新数据(\u值)) { d->address=重新解释类型(\u值); } 对象(object&_-Rhs):d(_-Rhs.d->duplicate()){ ~object() { if(具有_值()) { d->~dummy(); } } 常量std::type_info&type()常量 { 返回d->type(); } 模板\u Ty cast()常量 { if(typeid(_Ty)!=type()) { 抛出std::异常(“”); } 返回reinterpret\u cast(d)->\u内部; } 常量对象和运算符=(对象和运算符) { d=_Rhs.d->duplicate(); 归还*这个; } 模板常量对象和运算符=(常量和值)常量 { d=新数据(_值); d->address=重新解释类型(\u值); 归还*这个; } 模板bool运算符==(常量和值)常量 { 返回(type()!=typeid(\u Ty)?false:cast()=\u值); } 布尔运算符==(对象和右)常量 { return(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address); //上面测试的断点^^^ } 模板bool运算符!=(常量和值)常量 { 返回(type()==typeid(\u Ty)?false:cast()!=\u值); } 布尔运算符!=(对象和右)常量 { 返回!(*此==\u Rhs); } 布尔值为常量 { 返回!!d; } bool empty()常量 { 返回!d; } }; intmain() { 对象a=5,b=5; std::cout,c++,C++" />

C++;对象[实现]运算符==错误 我在C++中编写了对象< /Cuff>类,它工作良好,除了1/2个部分——布尔 = = < /COD>和!代码>运算符。我尝试了两个对象,都初始化为5,如下所示。但是,当使用=操作符时,它返回false(和truewith!=),尽管我在测试=操作符的行上设置了断点,但它们都包含0x00000005(5)。我不确定我的代码有什么问题: class object { private: class dummy { public: dummy(){} virtual ~dummy(){} virtual dummy *duplicate() const = 0; virtual const std::type_info &type() const = 0; void *address; }; template < typename _Ty > class data : public dummy { friend class object; public: data(const _Ty &_Value) : __inner(_Value){} ~data(){} const std::type_info &type() const { return typeid(_Ty); } data *duplicate() const { return new data<_Ty>(__inner); } private: _Ty __inner; }; dummy *d; public: object() { d->address = NULL; } template < typename _Ty > object(const _Ty &_Value) : d(new data<_Ty>(_Value)) { d->address = reinterpret_cast<void *>(_Value); } object(object &_Rhs) : d(_Rhs.d->duplicate()){} ~object() { if (has_value()) { d->~dummy(); } } const std::type_info &type() const { return d->type(); } template < typename _Ty > _Ty cast() const { if (typeid(_Ty) != type()) { throw std::exception(""); } return reinterpret_cast< data<_Ty> *>(d)->__inner; } const object &operator=(object &_Rhs) { d = _Rhs.d->duplicate(); return *this; } template < typename _Ty > const object &operator=(const _Ty &_Value) const { d = new data<_Ty>(_Value); d->address = reinterpret_cast<void *>(_Value); return *this; } template < typename _Ty > bool operator==(const _Ty &_Value) const { return (type() != typeid(_Ty) ? false : cast<_Ty>() == _Value); } bool operator==(object &_Rhs) const { return (type() != typeid(_Rhs.type()) ? false : d->address == _Rhs.d->address); // Breakpoint tested above ^^^ } template < typename _Ty > bool operator!=(const _Ty &_Value) const { return (type() == typeid(_Ty) ? false : cast<_Ty>() != _Value); } bool operator!=(object &_Rhs) const { return !(*this == _Rhs); } bool has_value() const { return !!d; } bool empty() const { return !d; } }; 类对象 { 私人: 类虚拟 { 公众: dummy(){} 虚拟~dummy(){} 虚拟虚拟*duplicate()常量=0; 虚拟常量std::type_info&type()常量=0; 无效*地址; }; 模板类数据:公共虚拟 { 友元类对象; 公众: 数据(常数和值):\uuuuuu内部(\u值){ ~data(){} 常量std::type_info&type()常量 { 返回类型ID(_Ty); } 数据*重复()常量 { 返回新数据(内部); } 私人: _蒂尤内; }; 虚拟*d; 公众: 对象() { d->address=NULL; } 模板对象(常量和值):d(新数据(\u值)) { d->address=重新解释类型(\u值); } 对象(object&_-Rhs):d(_-Rhs.d->duplicate()){ ~object() { if(具有_值()) { d->~dummy(); } } 常量std::type_info&type()常量 { 返回d->type(); } 模板\u Ty cast()常量 { if(typeid(_Ty)!=type()) { 抛出std::异常(“”); } 返回reinterpret\u cast(d)->\u内部; } 常量对象和运算符=(对象和运算符) { d=_Rhs.d->duplicate(); 归还*这个; } 模板常量对象和运算符=(常量和值)常量 { d=新数据(_值); d->address=重新解释类型(\u值); 归还*这个; } 模板bool运算符==(常量和值)常量 { 返回(type()!=typeid(\u Ty)?false:cast()=\u值); } 布尔运算符==(对象和右)常量 { return(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address); //上面测试的断点^^^ } 模板bool运算符!=(常量和值)常量 { 返回(type()==typeid(\u Ty)?false:cast()!=\u值); } 布尔运算符!=(对象和右)常量 { 返回!(*此==\u Rhs); } 布尔值为常量 { 返回!!d; } bool empty()常量 { 返回!d; } }; intmain() { 对象a=5,b=5; std::cout

C++;对象[实现]运算符==错误 我在C++中编写了对象< /Cuff>类,它工作良好,除了1/2个部分——布尔 = = < /COD>和!代码>运算符。我尝试了两个对象,都初始化为5,如下所示。但是,当使用=操作符时,它返回false(和truewith!=),尽管我在测试=操作符的行上设置了断点,但它们都包含0x00000005(5)。我不确定我的代码有什么问题: class object { private: class dummy { public: dummy(){} virtual ~dummy(){} virtual dummy *duplicate() const = 0; virtual const std::type_info &type() const = 0; void *address; }; template < typename _Ty > class data : public dummy { friend class object; public: data(const _Ty &_Value) : __inner(_Value){} ~data(){} const std::type_info &type() const { return typeid(_Ty); } data *duplicate() const { return new data<_Ty>(__inner); } private: _Ty __inner; }; dummy *d; public: object() { d->address = NULL; } template < typename _Ty > object(const _Ty &_Value) : d(new data<_Ty>(_Value)) { d->address = reinterpret_cast<void *>(_Value); } object(object &_Rhs) : d(_Rhs.d->duplicate()){} ~object() { if (has_value()) { d->~dummy(); } } const std::type_info &type() const { return d->type(); } template < typename _Ty > _Ty cast() const { if (typeid(_Ty) != type()) { throw std::exception(""); } return reinterpret_cast< data<_Ty> *>(d)->__inner; } const object &operator=(object &_Rhs) { d = _Rhs.d->duplicate(); return *this; } template < typename _Ty > const object &operator=(const _Ty &_Value) const { d = new data<_Ty>(_Value); d->address = reinterpret_cast<void *>(_Value); return *this; } template < typename _Ty > bool operator==(const _Ty &_Value) const { return (type() != typeid(_Ty) ? false : cast<_Ty>() == _Value); } bool operator==(object &_Rhs) const { return (type() != typeid(_Rhs.type()) ? false : d->address == _Rhs.d->address); // Breakpoint tested above ^^^ } template < typename _Ty > bool operator!=(const _Ty &_Value) const { return (type() == typeid(_Ty) ? false : cast<_Ty>() != _Value); } bool operator!=(object &_Rhs) const { return !(*this == _Rhs); } bool has_value() const { return !!d; } bool empty() const { return !d; } }; 类对象 { 私人: 类虚拟 { 公众: dummy(){} 虚拟~dummy(){} 虚拟虚拟*duplicate()常量=0; 虚拟常量std::type_info&type()常量=0; 无效*地址; }; 模板类数据:公共虚拟 { 友元类对象; 公众: 数据(常数和值):\uuuuuu内部(\u值){ ~data(){} 常量std::type_info&type()常量 { 返回类型ID(_Ty); } 数据*重复()常量 { 返回新数据(内部); } 私人: _蒂尤内; }; 虚拟*d; 公众: 对象() { d->address=NULL; } 模板对象(常量和值):d(新数据(\u值)) { d->address=重新解释类型(\u值); } 对象(object&_-Rhs):d(_-Rhs.d->duplicate()){ ~object() { if(具有_值()) { d->~dummy(); } } 常量std::type_info&type()常量 { 返回d->type(); } 模板\u Ty cast()常量 { if(typeid(_Ty)!=type()) { 抛出std::异常(“”); } 返回reinterpret\u cast(d)->\u内部; } 常量对象和运算符=(对象和运算符) { d=_Rhs.d->duplicate(); 归还*这个; } 模板常量对象和运算符=(常量和值)常量 { d=新数据(_值); d->address=重新解释类型(\u值); 归还*这个; } 模板bool运算符==(常量和值)常量 { 返回(type()!=typeid(\u Ty)?false:cast()=\u值); } 布尔运算符==(对象和右)常量 { return(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address); //上面测试的断点^^^ } 模板bool运算符!=(常量和值)常量 { 返回(type()==typeid(\u Ty)?false:cast()!=\u值); } 布尔运算符!=(对象和右)常量 { 返回!(*此==\u Rhs); } 布尔值为常量 { 返回!!d; } bool empty()常量 { 返回!d; } }; intmain() { 对象a=5,b=5; std::cout,c++,C++,您正在比较'd'成员的地址成员,而不是它们的值。您需要有某种方法来获取它们的值。也许可以创建一个虚拟方法来获取值,而'data'派生类可以返回该值。您正在比较'd'成员的地址成员,而不是它们的值。您需要d以某种方式获取它们的值。可以创建一个虚拟方法来获取值,“data”派生类可以返回的值。您正在比较“d”成员的地址成员,而不是它们的值。您需要某种方式来获取它们的值。可以创建一个虚拟方法来获取值,而“dat”可以“派生类”可以返回。您正在比较“d”成员的地址成员,而不是它们的值。您需要有某种方法来

您正在比较'd'成员的地址成员,而不是它们的值。您需要有某种方法来获取它们的值。也许可以创建一个虚拟方法来获取值,而'data'派生类可以返回该值。

您正在比较'd'成员的地址成员,而不是它们的值。您需要d以某种方式获取它们的值。可以创建一个虚拟方法来获取值,“data”派生类可以返回的值。

您正在比较“d”成员的地址成员,而不是它们的值。您需要某种方式来获取它们的值。可以创建一个虚拟方法来获取值,而“dat”可以“派生类”可以返回。

您正在比较“d”成员的地址成员,而不是它们的值。您需要有某种方法来获取它们的值。可以创建一个虚拟方法来获取“数据”派生类可以返回的值。

这部分代码
type()!=typeid(\u Rhs.type())
返回true。因此,此三元运算符的false部分

(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address);
返回

我认为问题出在这里
(typeid(type())!=typeid(_Rhs.type())

您应该将此->type()的typeid检查为_Rhs.type()的typeid

编辑:我查看了类型方法。它返回类型id,所以我认为您应该检查一下
this->type()!=\u Rhs.type()

这部分代码
type()!=typeid(\u Rhs.type())
返回true。因此,此三元运算符的false部分

(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address);
返回

我认为问题出在这里
(typeid(type())!=typeid(_Rhs.type())

您应该将此->type()的typeid检查为_Rhs.type()的typeid

编辑:我查看了类型方法。它返回类型id,所以我认为您应该检查一下
this->type()!=\u Rhs.type()

这部分代码
type()!=typeid(\u Rhs.type())
返回true。因此,此三元运算符的false部分

(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address);
返回

我认为问题出在这里
(typeid(type())!=typeid(_Rhs.type())

您应该将此->type()的typeid检查为_Rhs.type()的typeid

编辑:我查看了类型方法。它返回类型id,所以我认为您应该检查一下
this->type()!=\u Rhs.type()

这部分代码
type()!=typeid(\u Rhs.type())
返回true。因此,此三元运算符的false部分

(type()!=typeid(_Rhs.type())?false:d->address==_Rhs.d->address);
返回

我认为问题出在这里
(typeid(type())!=typeid(_Rhs.type())

您应该将此->type()的typeid检查为_Rhs.type()的typeid

Edit:我查看了type方法。它返回t
int main()
{
    object a = 5, b = 5;
    std::cout << std::boolalpha
        << (a == b);
    getchar();
}