继承类层次结构中的 C++ 虚拟变量

Question

我有一个模板类层次结构，

                   ___ Class (ClassA)
                  |
AbstractClass_____

                  |___ Class (ClassB)

在 classA 和 ClassB 中，我有一个模板化类型的 const NullPosition，这在 ClassA 和 ClassB 中是不同的。在 classA 和 ClassB 类中，我必须执行一些依赖于 NullPosition 值的操作。

现在我需要根据 NullPosition 上的值做一些操作，但我遇到了困难，因为变量是不同的类型和值。更具体地说，classA 中的 NullPosition 标识无效的数组索引，因此等于 -1；在 classB 中，它标识一个 NULL 指针，因此它等于 0。

请在下面找到一个示例。

#ifndef ABSTRACTCLASS_H
#define  ABSTRACTCLASS_H

template <class T, class P>
class AbstractClass
{
      public: 

      typedef T Type;
      typedef P Position;

      void MethodX() const;
      virtual Position Method() const = 0; 


};

template <class T, class P>
void AbstractClass<T,P>::MethodX() const
{
     Position p=Method();

     /*
     what I am trying to achieve is being able to use the constant NullPosition in abstract class.

     if (p==NullPosition)
     cout<<"p is equal NULLPOSITION";
     else
     cout<<"p is not equal NULLPOSITION";  
     */
}

#endif



#ifndef CLASS_A_H
#define  CLASS_A_H
#include "../AbstractClass.h"

template <class T>
class Class:public AbstractClass<T,unsigned int>
{
      public:

      typedef T Type;
      typedef typename AbstractClass<T,unsigned int>::Position Position;

      Class();

      Position Method() const;  

      static const Position NullPosition=-1;

      private:
              Type* TypeArray;
              unsigned int nElements;

};

      template <class T>
      Class<T>::Class()
      {
       nElements=0;
       TypeArray=new Type[128];
      }

      template <class T>
      typename Class<T>::Position Class<T>::Method() const 
      {

       return NullPosition;

      }

#endif




#ifndef CLASS_B_H
#define CLASS_B_H

#include "../AbstractClass.h"

template <class T>
struct elementNode
{
    typedef T Type;
    typedef elementNode* Position;

    Type element;
    Position nextNode;
};

template <class T>
class Class:public AbstractClass<T, typename elementNode<T>::Position>
{
      public:

      typedef T Type;
      typedef typename AbstractClass<T, typename elementNode<T>::Position>::Position Position;

      Class();
      Position Method() const; 

      static const Position NullPosition;

      private:
              Position root;
              Position lastElement;

};

      template <class T>
      const typename Class<T>::Position Class<T>::NullPosition=0;

      template <class T>
      Class<T>::Class()
      {
       lastElement=root=NullPosition; 
      }

      template <class T>
      typename Class<T>::Position Class<T>::Method() const 
      {

       return NullPosition;

      }

#endif


#include <cstdlib>
#include <iostream>

using namespace std;


#include "Class/ClassA/Class.h" 

int main(int argc, char *argv[])
{
    Class<int> classA;

    classA.MethodX();

    system("PAUSE");
    return EXIT_SUCCESS;
}

请注意 ClassA 和 ClassB 共享相同的名称 Class，这样我就可以在我的代码中互换使用它们，只需更改包含路径 - #include "Class/ClassA/Class.h"for classA 和 #include "ClassB 的 Class/ClassB/Class.h"。

Answer 1

我没有看到问题。您有很多选择:

• 将 NullPosition 作为非类型模板参数传递给基类。
• 创建一个 traits 类来确定某些类型的 null 位置。在定义子类之前对其进行专门化。
• 向子类覆盖的基类添加一个抽象函数以返回空位置。
• 在基类中添加一个抽象函数，子类会覆盖该抽象函数来判断某个位置是否为 NullPosition。