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＆＃34; Class / ClassA / Class.h＆＃34;对于classA和#include＆＃34; Class / ClassB / Class.h＆＃34;对于classB。

Answer 1

我没有看到问题。你有很多选择：

将NullPosition作为非类型模板参数传递给基类。
创建一个traits类，用于确定某种类型的null位置。在定义子类之前将其专门化。
将抽象函数添加到子类重写的基类以返回空位置。
将抽象函数添加到子类重写的基类，以确定位置是否为NullPosition。

Answer 2

我不确定我是否理解了整个要求，但看起来你正在尝试根据P的类型在MethodX上做一些不同的事情。

您可以在MethodX函数等上使用模板特化，因为第二个参数P对于两个派生类是不同的。

这样的事情：

template<class T> void MethodX<T,NullPosition>
{
    // Do NullPosition stuff here
}

Answer 3

也许有一些我不理解的东西，但如果你需要一个父类的成员，那么为什么要把它放在子类而不是父类？

哦，如果你有两个名字相同但方法实现不同的类，链接后只有一个方法存在。如果要使用不同源文件中的公用名访问这两个类，请使用typedef：

class foo1 {.....};
class foo2 {.....};

typedef foo foo1;
// or typedef foo foo2;

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

3 个答案: