C++ C++；如何检查两个CLS是否来自同一对象

在准备考试时遇到此问题，请简要解释。
如果我有一个

类对象

和另一个：

类点：公共对象

现在，如果我得到

Object&O1

和

Object&O2

，但是

Object

也可以是

点

所以我的主要问题是如何检查它们是否都是

点

，因为我需要访问

对象

没有的字段

以下是两个类：

类对象{
公众：
一些功能
};

类点：公共对象{
双x；
双y；
公众：
相同的功能不同的实现
};

我想访问x，y，但我需要首先确保它是一个

点

提前感谢
您可以使用dynamic\u cast

Object &o = ...;
if(Point *p = dynamic_cast<Point*>(&o)) {
  // ...
}

要使其工作，必须在
对象
中至少有一个
虚拟
函数（如果只有析构函数）
 您可以使用动态投影

Object &o = ...;
if(Point *p = dynamic_cast<Point*>(&o)) {
  // ...
}

要使其工作，必须在
对象
中至少有一个
虚拟
函数（如果只有析构函数）
 它可能是草率的，但是如果你有一个指向某个对象的指针或引用，你总是可以调用动态的\u cast。如果指针返回为null ptr，那么您就知道您的对象不是所需对象的派生类

class CBase { 
      virtual void dummy(){}
};
class CDerived: public CBase {
    int a;
};

int main () {
  try {
    CBase * pba = new CDerived;
    CBase * pbb = new CBase;
    CDerived * pd;

    pd = dynamic_cast<CDerived*>(pba);
    if (pd==0) cout << "Null pointer on first type-cast" << endl;

    pd = dynamic_cast<CDerived*>(pbb);
    if (pd==0) cout << "Null pointer on second type-cast" << endl;

  } catch (exception& e) {cout << "Exception: " << e.what();}
  return 0;
}

类CBase{
虚拟空虚拟对象（）{}
};
类别C派生：公共CBase{
INTA；
};
int main（）{
试一试{
CBase*pba=新的CDerived；
CBase*pbb=新的CBase；
CDerived*pd；
pd=动态浇铸（pba）；
如果（pd==0）cout，它可能会很松散，但如果您有一个指向某个对象的指针或引用，则始终可以调用动态转换。如果指针返回为nullptr，则您知道您的对象不是所需对象的派生类

class CBase { 
      virtual void dummy(){}
};
class CDerived: public CBase {
    int a;
};

int main () {
  try {
    CBase * pba = new CDerived;
    CBase * pbb = new CBase;
    CDerived * pd;

    pd = dynamic_cast<CDerived*>(pba);
    if (pd==0) cout << "Null pointer on first type-cast" << endl;

    pd = dynamic_cast<CDerived*>(pbb);
    if (pd==0) cout << "Null pointer on second type-cast" << endl;

  } catch (exception& e) {cout << "Exception: " << e.what();}
  return 0;
}

类CBase{
虚拟空虚拟对象（）{}
};
类别C派生：公共CBase{
INTA；
};
int main（）{
试一试{
CBase*pba=新的CDerived；
CBase*pbb=新的CBase；
CDerived*pd；
pd=动态浇铸（pba）；
如果（pd==0）不能一般来说，如果你“需要”知道这一点，你就做错了。有一些例外，但作为一个规则，你不需要知道你“使用”的对象类型。不同的函数应声明为
虚拟
，以便使用
对象
执行操作的代码可以调用
点
中的相关函数（如果对象是
点
类型对象）

如果你想访问
x
和
y
，你应该通过一个虚拟函数来间接地访问它，这个虚拟函数执行需要在
x
和
y
上执行的任何操作。如果你真的需要在你只有（一个指向的引用或指针）的情况下触摸
x
和
y
一个
对象
，你只是处于错误的级别。
一般来说，如果你“需要”知道这一点，你就错了。有一些例外，但作为一项规则，你不需要知道你“使用”的对象类型。不同的函数应声明为
虚拟
，以便使用
对象
执行操作的代码可以调用
点
中的相关函数（如果对象是
点
类型对象）

如果你想访问
x
和
y
，你应该通过一个虚拟函数来间接地访问它，这个虚拟函数执行需要在
x
和
y
上执行的任何操作。如果你真的需要在你只有（一个指向的引用或指针）的情况下触摸
x
和
y
一个<代码>对象< /> >，您的位置不正确。
 您可以依赖C++标准库提供的类型信息。
#include <iostream>
#include <typeinfo>
#include <string>
#include <utility>

class person
{
  public:

   person(std::string&& n) : _name(n) {}
   virtual const std::string& name() const{ return _name; }

  private:

    std::string _name;
};

class employee : public person
{
   public:

     employee(std::string&& n, std::string&& p) :
         person(std::move(n)), _profession(std::move(p)) {}

     const std::string& profession() const { return _profession; }

   private:

     std::string _profession;
};

void somefunc(const person& p)
{
   if(typeid(employee) == typeid(p))
   {
      std::cout << p.name() << " is an employee ";
      auto& emp = dynamic_cast<const employee&>(p);
      std::cout << "who works in " << emp.profession() << '\n';
   }
}

int main()
{
   employee paul("Paul","Economics");
   somefunc(paul);
}

#包括
#包括
#包括
#包括
班主任
{
公众：
person（std:：string&&n）：\u name（n）{}
虚拟常量std:：string&name（）常量{return\u name；}
私人：
std:：string _name；
};
类别雇员：公众人士
{
公众：
员工（std:：string&&n，std:：string&&p）：
人（std：：move（n）），_职业（std：：move（p））{}
常量std:：string&profession（）常量{return\u profession；}
私人：
std:：string\u profession；
};
void somefunc（const person&p）
{
如果（类型ID（员工）=类型ID（p））
{
STD::CUT
您可以依赖C++标准库提供的类型信息。
#include <iostream>
#include <typeinfo>
#include <string>
#include <utility>

class person
{
  public:

   person(std::string&& n) : _name(n) {}
   virtual const std::string& name() const{ return _name; }

  private:

    std::string _name;
};

class employee : public person
{
   public:

     employee(std::string&& n, std::string&& p) :
         person(std::move(n)), _profession(std::move(p)) {}

     const std::string& profession() const { return _profession; }

   private:

     std::string _profession;
};

void somefunc(const person& p)
{
   if(typeid(employee) == typeid(p))
   {
      std::cout << p.name() << " is an employee ";
      auto& emp = dynamic_cast<const employee&>(p);
      std::cout << "who works in " << emp.profession() << '\n';
   }
}

int main()
{
   employee paul("Paul","Economics");
   somefunc(paul);
}

#包括
#包括
#包括
#包括
班主任
{
公众：
person（std:：string&&n）：\u name（n）{}
虚拟常量std:：string&name（）常量{return\u name；}
私人：
std:：string _name；
};
类别雇员：公众人士
{
公众：
员工（std:：string&&n，std:：string&&p）：
人（std：：move（n）），_职业（std：：move（p））{}
常量std:：string&profession（）常量{return\u profession；}
私人：
std:：string\u profession；
};
void somefunc（const person&p）
{
如果（类型ID（员工）=类型ID（p））
{
std：：cout
Object
永远不能是
Point
对象&
可以是
点&
（和（智能）指针一样）。有没有办法确保我在处理点而不是对象？我编辑了一个问题，我得到了Object&O1…
动态投影（ptr）
你在寻找什么…通常你不需要也不应该这样做。你可能需要在
对象中使用虚拟方法。找出你为什么需要x，y并给它命名。相关。
对象永远不能是
点
对象&
可以是
点&
（智能）也可以是
点&
指针）。有没有办法确保我在处理点而不是对象？我编辑了一个问题，得到了对象&O1…
dynami