Question

例如，我有四个类，如：

class A;

class B{
protected:
    void check(const A &a); 
};

class C : public A, public B;
class D : public B;

现在我想编写一个check函数，如果调用者和参数相同则不执行任何操作：

void B::check(const A &a){
   if(*this != a){
      //do something
   }
   else{
      //do nothing
   }
}

但是这不会编译，因为B类对C类一无所知，有一天会调用B的函数检查。将this转换为A很容易，但是如果有一天D类会调用该检查，那将会产生错误，因为它与A无关。那么这样做是怎么回事？

编辑：我可能不得不提一下，C和D类将具有调用该检查的接口，这些接口在这些类之外是不可用的，但它只会将参数传递给内部函数

Answer 1

如果您向A：

添加虚拟析构函数，这将有效

void B::check(const A &a)
{
    if (dynamic_cast<const B*>(&a) == this)
    {
        std::cout << "same object" << std::endl;
    }
}

Answer 2

if(*this != a)

检查没有意义，因为这（B类）永远不会与A类的类型相同，因为两者都是不相关的类。

目前尚不清楚您想要做什么，但如果您希望Base类指针指向派生类对象，则它们之间必定存在继承（is-a）关系。

Answer 3

这里只有一个可能的逃生舱。如果 A和B都具有虚拟功能，则dynamic_cast和this &a void B::check(const A &a){ if(dynamic_cast<void const*>(const_cast<B const>(this) != dynamic_cast<void const*>(&a)) { //do something } ...。并且根据5.2.7 / 7“如果T是指向cv void的指针”，则结果是指向v所指向的最派生对象的指针。“

因此，此代码有效：

{{1}}

在不知道该类型的情况下，没有其他任何东西可以为您提供指向最派生对象的指针。

Answer 4

您可能想要检查实例是否相同：

void B::check(const A &a){
   if(this != &a){
      //do something
   }
   else{
      //do nothing
   }
}

比较不同课程的内容对我来说没有多大意义。

Answer 5

您可以这样做：

void check(const A &a){
   if((void*)this != (void*)&a){
      //do something
   }
   else{
      //do nothing
   }
}

Answer 6

这是您要查找的内容 - 检查this和a是否属于C类型的同一对象的一部分？

void B::check(A &a)
{
    std::cout << (static_cast<C*>(this) != static_cast<C*>(&a)) << std::endl;
}

int main()
{
    C c;
    D d;
    A& a1 = c;
    A a2;
    boolalpha(std::cout);
    c.check(a1); // false
    c.check(a2); // true
    d.check(a1); // true
}

检查调用者和参数是否相同

6 个答案: