c++ - 从静态类继承

Question

我有一系列静态类，用于填充和访问 std::map 中的数据。

由于它们是静态的，因此很容易进行设置，以便仅在需要时填充 map ，并且只需要填充一次。

沿着这些线的东西:

class MyClass
{
public:
  string at(int key)
  {
    PopulateEmptyMap();
    return myMap.at(key);
  }

private:
  void PopulateEmptyMap()
  {
    if(!myMap.empty())
      return;
    PopulateMap();
  }

  void PopulateMap()
  {
    myMap[1] = "str1";
    myMap[2] = "str2";
  }

  static map<int, string> myMap;
};

实际的类(class)更复杂，有多个 map ，但你明白了。

我有一系列这样的类，除了 map 的类型和值之外，它们几乎完全相同。

我不想让多个类都重现相同的代码，而是希望代码存在于一个地方，但我不知道该怎么做。

我的第一个想法是继承一个具有所有共享代码的模板类。 PopulateMap 函数将变为纯虚函数，然后由每个继承类实现。这当然行不通，因为函数不可能既是静态的又是虚拟的。

我有哪些选择来做我正在尝试的事情？

Answer 1

没有静态类这样的东西。您正在描述一个只有静态数据的类，这些数据只填充一次并在以后使用。您可以拥有任意数量的非静态函数(虚拟函数和常规函数)，只要它们仅使用静态成员数据即可。

这似乎是您正在寻找的东西。

#include <iostream>
#include <string>
#include <map>

// A base class template that has a virtual function
// to allow derived classes to fill up the map.
template <typename Key, typename Value>
class MyTemplateClass
{
   public:

      Value at(Key const& key)
      {
         PopulateEmptyMap();
         return myMap.at(key);
      }

      void PopulateEmptyMap()
      {
         if(!myMap.empty())
            return;
         PopulateMap();
      }

   protected:

      virtual void PopulateMap() = 0;

      static std::map<Key, Value> myMap;
};

// Define the static member data of the class template.
template <typename Key, typename Value>
std::map<Key, Value> MyTemplateClass<Key, Value>::myMap;

// Define a sub-calss of MyTemplateClass that works
// int as key and string as value.
class MyClass1 : public MyTemplateClass<int, std::string>
{
   protected:

      virtual void PopulateMap()
      {
         myMap[1] = "str1";
         myMap[2] = "str2";
      }
};

// Define a sub-calss of MyTemplateClass that works
// int as key and int as value.
class MyClass2 : public MyTemplateClass<int, int>
{
   protected:

      virtual void PopulateMap()
      {
         myMap[1] = 10;
         myMap[2] = 20;
      }
};

int main()
{
   MyClass1 c1;
   std::cout << c1.at(1) << std::endl;
   std::cout << c1.at(2) << std::endl;

   MyClass2 c2;
   std::cout << c2.at(1) << std::endl;
   std::cout << c2.at(2) << std::endl;
}

注意:

如果您定义另一个继承自MyTemplateClass 的派生类使用 int作为键和 int作为值(value)，你会看到意想不到的行为。 MyTemplateClass<int, int> 只能有一个实例化.

// This will lead to unexpected behavior. You will get either 10 and 20 in
// the map or 30 and 40. You will not get all four in the map.
// If the behavior of MyClass2 seems sane, the behavior of MyClass3 will seem
// the opposite, or vice versa.
class MyClass3 : public MyTemplateClass<int, int>
{
   protected:

      virtual void PopulateMap()
      {
         myMap[1] = 30;
         myMap[2] = 40;
      }
};

但是，您可以使用 MyTemplateClass 的第三个参数来解决该问题.

#include <iostream>
#include <string>
#include <map>

template <typename Key, typename Value, typename Derived>
class MyTemplateClass
{
   public:

      Value at(Key const& key)
      {
         PopulateEmptyMap();
         return myMap.at(key);
      }

      void PopulateEmptyMap()
      {
         if(!myMap.empty())
            return;
         PopulateMap();
      }

   protected:

      virtual void PopulateMap() = 0;

      static std::map<Key, Value> myMap;
};


template <typename Key, typename Value, typename Derived>
std::map<Key, Value> MyTemplateClass<Key, Value, Derived>::myMap;

class MyClass1 : public MyTemplateClass<int, std::string, MyClass1>
{
   protected:

      virtual void PopulateMap()
      {
         myMap[1] = "str1";
         myMap[2] = "str2";
      }
};

class MyClass2 : public MyTemplateClass<int, int, MyClass2>
{
   protected:

      virtual void PopulateMap()
      {
         myMap[1] = 10;
         myMap[2] = 20;
      }
};

class MyClass3 : public MyTemplateClass<int, int, MyClass3>
{
   protected:

      virtual void PopulateMap()
      {
         myMap[1] = 30;
         myMap[2] = 40;
      }
};

int main()
{
   MyClass1 c1;
   std::cout << c1.at(1) << std::endl;
   std::cout << c1.at(2) << std::endl;

   MyClass2 c2;
   std::cout << c2.at(1) << std::endl;
   std::cout << c2.at(2) << std::endl;

   MyClass3 c3;
   std::cout << c3.at(1) << std::endl;
   std::cout << c3.at(2) << std::endl;
}

这对我有用。希望它对你有用。

更新

有几个选项可供您选择，不需要在堆栈上创建对象。

全部static成员

您可以设计类以通过 static 访问所有内容成员函数。

#include <iostream>
#include <string>
#include <map>

template <typename Key, typename Value, typename Derived>
class MyTemplateClass
{
   public:

      static Value at(Key const& key)
      {
         PopulateEmptyMap();
         return myMap.at(key);
      }

      static void PopulateEmptyMap()
      {
         if(!myMap.empty())
            return;
         Derived::PopulateMap();
      }

   protected:

      static std::map<Key, Value> myMap;
};


template <typename Key, typename Value, typename Derived>
std::map<Key, Value> MyTemplateClass<Key, Value, Derived>::myMap;

class MyClass1 : public MyTemplateClass<int, std::string, MyClass1>
{
   public:

      static void PopulateMap()
      {
         myMap[1] = "str1";
         myMap[2] = "str2";
      }
};

int main()
{
   // Access the data without needing to create an object.
   std::cout << MyClass1::at(1) << std::endl;
   std::cout << MyClass1::at(2) << std::endl;

   // They are also accessible using an object.
   MyClass1 c1;
   std::cout << c1.at(1) << std::endl;
   std::cout << c1.at(2) << std::endl;
}

单例模式

另一种可能对您有用的方法是使用 singleton pattern .

#include <iostream>
#include <string>
#include <map>

template <typename Key, typename Value, typename Derived>
class MyTemplateClass
{
   public:

      Value at(Key const& key)
      {
         PopulateEmptyMap();
         return myMap.at(key);
      }

      void PopulateEmptyMap()
      {
         if(!myMap.empty())
            return;
         PopulateMap();
      }

   protected:

      virtual void PopulateMap() = 0;

      static std::map<Key, Value> myMap;
};


template <typename Key, typename Value, typename Derived>
std::map<Key, Value> MyTemplateClass<Key, Value, Derived>::myMap;

class MyClass1 : public MyTemplateClass<int, std::string, MyClass1>
{
   public:

      static MyClass1* instance()
      {
         static MyClass1 theInstance;
         return &theInstance;
      }

      void PopulateMap()
      {
         myMap[1] = "str1";
         myMap[2] = "str2";
      }

   private:

      // Disallow creation of objects by clients
      MyClass1() {}
      ~MyClass1() {}
};

int main()
{
   // Access the data using the instance() interface.
   std::cout << MyClass1::instance()->at(1) << std::endl;
   std::cout << MyClass1::instance()->at(2) << std::endl;
}