0

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

                   ___ 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 "Class/ClassB /Class.h" 用于 B 类。

4

3 回答 3

1

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

  • 将 NullPosition 作为非类型模板参数传递给基类。
  • 创建一个特征类来确定某种类型的空位置。在定义子类之前对其进行专门化。
  • 将抽象函数添加到子类覆盖的基类以返回空位置。
  • 将抽象函数添加到子类覆盖的基类以确定位置是否为 NullPosition。
于 2013-08-27T14:04:44.637 回答
0

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

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

像这样的东西：

template<class T> void MethodX<T,NullPosition>
{
    // Do NullPosition stuff here
}
于 2013-08-27T14:09:28.530 回答
0

也许有些东西我不明白，但是如果您需要父类中的成员，那么为什么将其放在子类而不是父类中呢？

哦，如果您有两个具有相同名称但方法实现不同的类，则链接后将仅存在其中一种方法。如果要使用不同源文件中的通用名称访问这两个类，请使用 typedefs：

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

typedef foo foo1;
// or typedef foo foo2;
于 2013-08-27T14:14:59.710 回答