C++ C++；确定哪个子类正在调用父函数

好吧，所以我在任何地方都找不到答案，这是我的第一篇帖子，所以请友好。 基本上，如果某个子类在特定条件下调用父函数，但另一个子类应该始终能够执行该函数，我需要抛出一个异常

--如果您想知道，它是一个用于account类的提款函数，该类包含储蓄和支票子类。储蓄有一个最小余额（如果取款导致其低于最小值，则抛出异常），但支票没有最小余额

class parent {
      public:

      int b;
      void A(){
             //1. Throws exception if b < # ONLY when child1 calls
             //2. Always executes code if child2 calls regardless of condition
      }              
}           


class child1 : public parent {
}

class child2 : public parent {
}


int main(){

    child1 one;
    child2 two;

    one.A();        //This needs to throw exception under certain conditions
    two.A();        //This will always execute
}

类父类{
公众：
int b；
作废{
//1.如果b<#仅当child1调用时引发异常
//2.无论条件如何，如果child2调用，总是执行代码
}              
}           
类别child1：公共父级{
}
第2类：公共家长{
}
int main（）{
儿童1人；
两个孩子；
one.A（）；//在某些情况下需要抛出异常
two.A（）；//这将始终执行
}

---

有人知道如何确定哪个子类正在调用该函数吗？

因为基类中没有任何虚拟函数，所以运气不好。否则，您可以使用：

typeid*this

---

无论如何，您的函数在基类中应该是虚拟的，并在子类中被重写。请记住：继承为is-a关系建模，因此限制特定子类的服务违背了它的预期用途。最好对基类有限制的行为，并在某些子类中允许更多的行为。

因为基类中没有任何虚拟函数，所以您只是运气不好。否则，您可以使用：

typeid*this

---

无论如何，您的函数在基类中应该是虚拟的，并在子类中被重写。请记住：继承为is-a关系建模，因此限制特定子类的服务违背了它的预期用途。最好对基类使用受限行为，并在某些子类中允许更多行为。

您可以尝试使用动态强制转换

void A(){
   if(dynamic_cast<child1>() == 0) {
         //1. Throws exception if b < # ONLY when child1 calls
   }
   else             
        //2. Always executes code if child2 calls regardless of condition
   }  
}

---

您可以尝试使用动态_cast

void A(){
   if(dynamic_cast<child1>() == 0) {
         //1. Throws exception if b < # ONLY when child1 calls
   }
   else             
        //2. Always executes code if child2 calls regardless of condition
   }  
}

---

如果没有循环依赖项，就没有简单的方法可以做到这一点。最简单的方法可能是在每个类中重载函数：

class Child1:公共父级
{
无效A（整数v）
{
如果（此->b>v）
{
投掷1枚；
}
其他的
{
父母：：A（v）；
}
回来
}
}

您还可以在基类中将函数设为纯虚拟函数，以强制所有子函数使用其自己的副本重写该函数

class Parent
{
   virtual void A() =0;
}

class Child1 : public Parent
{
   void A(int v) 
   {
      if (this->b > v)
      {
         throw 1;
      }
      else
      {
         <<do something>>
      }
      return;
   }
}

类父类
{
虚空A（）=0；
}
类别Child1：公共父级
{
无效A（整数v）
{
如果（此->b>v）
{
投掷1枚；
}
其他的
{
}
回来
}
}

---

或者，您可以使用函子，但这些函子可能会变得非常复杂，需要C++11。请在此处查看它们：

如果没有循环依赖项，就不容易做到这一点。最简单的方法可能是在每个类中重载函数：

class Child1:公共父级
{
无效A（整数v）
{
如果（此->b>v）
{
投掷1枚；
}
其他的
{
父母：：A（v）；
}
回来
}
}

您还可以在基类中将函数设为纯虚拟函数，以强制所有子函数使用其自己的副本重写该函数

class Parent
{
   virtual void A() =0;
}

class Child1 : public Parent
{
   void A(int v) 
   {
      if (this->b > v)
      {
         throw 1;
      }
      else
      {
         <<do something>>
      }
      return;
   }
}

类父类
{
虚空A（）=0；
}
类别Child1：公共父级
{
无效A（整数v）
{
如果（此->b>v）
{
投掷1枚；
}
其他的
{
}
回来
}
}

---

或者，您可以使用函子，但这些函子可能会变得非常复杂，需要C++11。在这里查看它们：

如果您不想使用RTIA，通常使用的一种模式是为类提供一个枚举，称之为“typeid”，并为每个函数提供一个返回对象typeid的方法。这将让您知道当前正在处理的类型（通过调用此->类型ID）

但是，如果您不希望给定的类能够调用该函数，那么就更容易了。重写该类中的函数并执行如下操作。然而，我相信，当从通用指针使用时，这需要虚拟函数正常工作

//override
return_type MyClass::MyFunction(ArgType arg)
{
    if ( !condidtionsMet ) {
        throw SomeException;
    } 
    else {
        return MyParentClass::MyFunction(arg);
    }

}

---

在您不想使用RTIA的地方，经常使用的一种模式是让类的枚举称为“typeid”，并为每个函数提供一个返回对象typeid的方法。这将让您知道当前正在处理的类型（通过调用此->类型ID）

但是，如果您不希望给定的类能够调用该函数，那么就更容易了。重写该类中的函数并执行如下操作。然而，我相信，当从通用指针使用时，这需要虚拟函数正常工作

//override
return_type MyClass::MyFunction(ArgType arg)
{
    if ( !condidtionsMet ) {
        throw SomeException;
    } 
    else {
        return MyParentClass::MyFunction(arg);
    }

}

---

啊，你刚才回答了。我都没想到。谢谢啊，你刚才回答了。我都没想到。谢谢与基中的虚拟对象相比，基中的纯虚拟对象不会使所有子对象都继承它。纯虚拟只是强制来自基的第一个继承将其定义为可实例化。为了清晰起见，重新编写了。基中的纯虚拟并不比基中的虚拟更能使所有子级继承它。纯虚拟简单地强制来自基的第一个继承将其定义为可实例化。为了清晰起见，重新编写。