时间戳

首页 > 解决方案 > 独立对象如何从调用者类调用方法？

c++ - 独立对象如何从调用者类调用方法？

问题描述

我有一个带有模板的独立类，它为某些运算符重载，我想把它作为调用者类的触发器。示例代码：

独立班

template <typename DataType>
class IndependentClass{
public:
   DataType _value; 
   IndependentClass(){};
   IndependentClass(DataType val):_value(val){};
   ~IndependentClass(){};
   IndependentClass& operator=(const IndependentClass<DataType>& mu){
      if (this != &mu){
         _value = mu._value;
         //I want to trigger caller method from here
         //But how this class can know the caller class?
         // _caller.callParentMethod();
      }
      return (*this);
   }
   IndependentClass& operator=(int val){
      return (operator=(IndependentClass<DataType>(val)));
   }
   DataType getValue()const{
      return _value;
   }
};

基类

class BaseClass{
public:
   int sum;
   BaseClass(){};
   ~BaseClass(){};
   void setValue(int value){sum+=value;}
   int getValue(){return sum;}
};

派生类

在这个类中将使用 Independent 类。

//Declare Independent Class
typedef IndependentClass<int> I8;
class DerivedClass : public BaseClass{
public:
   I8 sumThisClassValue;
   DerivedClass(){
      methodDerivedClass();
   };
   ~DerivedClass(){};
   void methodDerivedClass(){
      sumThisClassValue = 8;
      Base::setValue(4);
      cout<<"Value = "<<Base::getValue()<<endl; //Output 4
      cout<<sumThisClassValue<<endl;
      cout<<"Value = "<<Base::getValue()<<endl; //Output that I want is 12
   }
   void callParentMethod(int _val){
      Base::setValue(_val);
   }
};

主要的

int main(){
   DerivedClass objectTLM;
   return 0;
}

到目前为止，我正在考虑使用 2 模板template<typename DataType, typename Caller>并在我的独立类中添加另一个构造函数，但我仍然如何传递派生类本身，即(I8 objA = new I8(this))*它也不起作用

在真实的代码场景中，我有多个来自同一个基类的派生类，而基类可以监控每个派生类的每个值。

请帮忙。谢谢。

标签： c++ooptemplatesinheritance

解决方案

IndependentClass需要引用一个实例DerivedClass来调用callParentMethod它。您不能更改 的参数operator =，因此它必须是 的成员IndependentClass。

class DerivedClass;

template <typename DataType>
class IndependentClass{
   DerivedClass & _caller;
public:
   DataType _value; 
   IndependentClass(DerivedClass & caller, DataType val = {}) : _caller(caller), _value(val) {};
   IndependentClass(const IndependentClass &) = delete;
   IndependentClass& operator= (const IndependentClass &) = delete;
   IndependentClass& operator= (int mu) {
      _value = mu;
      _caller.callParentMethod();
      return *this;
   }

   DataType getValue() const {
      return _value;
   }
};

using I8 = IndependentClass<int>;

请注意，如果您这样做，您仍然不会得到您要求的输出，因为您将在向未初始化的BaseClass::sum值添加 4 之前添加 8。

class DerivedClass : public BaseClass{
public:
   I8 sumThisClassValue;

   DerivedClass() : sumThisClassValue(*this) {
      methodDerivedClass();
   };

   void methodDerivedClass(){
      Base::setValue(4);
      std::cout << "Value = " << Base::getValue() << std::endl; //Output 4
      sumThisClassValue = 8;
      std::cout << sumThisClassValue._value << std::endl;
      std::cout << "Value = " << Base::getValue() << std::endl; //Output 12
   }

   void callParentMethod(int _val){
      Base::setValue(_val);
   }
};

推荐阅读