Question

我有一个带有模板的独立类，该模板对某些操作符会重载，我想将其作为调用方类的触发器。示例代码：

独立类

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)) *这也不起作用

在实际代码方案中，我有多个来自同一基类的派生类，并且该基类可以监视每个派生类的每个值。

请帮助。谢谢。

Answer 1

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值上加上8，然后再向其添加4。

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);
   }
};

一个独立的对象如何从调用者类中调用方法？

1 个答案: