【问题标题】:OO Design -- where to put non-member functionsOO 设计——放置非成员函数的位置
【发布时间】:2012-06-26 17:52:01
【问题描述】:

我有一个具有许多参数的复杂构造过程的类。多个客户端共享该类的对象,这些客户端参数的并集用于实例化该类。因此,我有一个工厂类来存储这些需求,检查各种客户请求的一致性,并实例化该类。

此外,还有一组通用的使用模型(或参数集)可供多个客户用于多个工厂。

例如,考虑一个例子。 (请注意,实际代码是 C++,但我的经验是 Python,所以我将在 Python 中编写伪代码。是的,我知道这个示例实际上不会按原样工作。)

class Classroom:
    def __init__(self, room_size=None, n_desks=None, n_boards=None, 
                       n_books=None, has_globe=False, ... ):
        ...

class ClassroomFactory:
    def __init__(self):
        self._requirements = dict()

    def addRequirement(self, name, value):
        if name.startswith("n_"):
            self._requirements[name] = max(value, self._requirements.get(name, 0))
        ...

    def createClassroom(self):
        return Classroom(**self._requirements)


# instantiate the factory
factory = ClassroomFactory()

# "client 1" is a geography teaacher
factory.addRequirement("n_desks", 10)
factory.addRequirement("n_boards", 1)
factory.addRequirement("has_globe", True)

# "client 2" is a math teacher
factory.addRequirement("n_desks", 10)
factory.addRequirement("n_boards", 1)

# "client 3" is a after-school day-care
factory.addRequirement("room_size",  (20,20))
factory.addRequirement("has_carpet", True)

room = factory.createClassroom()

常见的使用模式是作为老师,我们需要 10 张课桌和一个板子。我认为这最好由非成员函数/装饰器提供,例如:

def makeTeacherRoom(factory):
    factory.addRequirement("n_desks", 10)
    factory.addRequirement("n_boards", 1)        
    return factory

这似乎是“喜欢非会员/非朋友而不是会员”范式的一个很好的例子。

我正在努力解决的问题是,在更大的 OO 代码框架内,这些类型的非成员函数/装饰器应该在哪里存在,无论是就命名空间还是就实际文件而言?

  1. 他们应该住在工厂的文件/命名空间中吗?它们与工厂密切相关,但仅限于一般工厂,不需要使用工厂。

  2. 它们应该存在于客户端的文件/命名空间中吗?客户端了解这些使用模型,但这会限制多个客户端之间的重用。

  3. 他们是否应该使用客户端的公共基类(例如,可以想象一个“教师”类/命名空间,它还将提供非成员函数 makeTeacherRoom(),该函数将由 MathTeacher 继承和地理老师。

  4. 他们应该完全住在其他地方,在“utils”文件中吗?如果是,在哪个命名空间中?

【问题讨论】:

  • @harper 这不是 C++,这似乎是 python....
  • 对不起,我以为我很清楚——我的伪代码是 python,但实际应用程序是 C++。我特别尝试让 python 原型不使用“python 但不是 C++”的东西,比如实际的装饰器类。请注意,对命名空间的影响会非常不同......
  • 这可能与您的问题无关,但如果您使用Named Parameter Idiom,您可能会使您的多参数 C++ 构造函数更像 Python。
  • @Ethan Coon 大多数东西在 Python 或 C++ 中的工作方式可能相似,但是非成员函数是少数在 Python 和 C++ 中处理方式不同的情况

标签: c++ python oop


【解决方案1】:

这主要是个人决定。您的大多数选择没有技术上的负面影响。例如:

  1. 他们可以,因为使用地点的原因,但这不是必需的。
  2. 他们可以,因为数据的局部性,但同样...
  3. 他们可以,虽然这个看起来确实会让事情变得有点混乱。制作实用程序类,您最终可能不得不继承它们,或者将部分虚拟化以便稍后覆盖,这将很快变得丑陋。
  4. 这是我个人最喜欢的,或者是它的变体。

我通常会创建一个具有相关名称的 util 文件(或具有静态方法的类),并将其放在与它所使用的类相同的命名空间中(更有用的 mutilate 版本)。对于Education::Teacher 类,您可以有一个Education::TeacherUtils 文件或包含在Teacher 上运行的函数的类。这保持了一个非常明显的命名搭配,但也将 util 函数放在它们自己的区域中,因此可以将它们包含在任何需要它们的地方(在Teacher.cpp 或类似的地方会阻止这种情况)。在类的情况下,您可以将 util 类和基类作为朋友,这偶尔会有所帮助(但很少使用,因为它可能是一种气味)。

我看到了一个命名变体,Education::Utils::Teacher,但这有点难以转换为文件(除非您将内容放入 utils 目录)并且还可能导致名称解析异常(在某些情况下,编译器可能尝试使用 Education::Utils::Teacher 而不是 Education::Teacher 当你不是故意的)。因此,我更喜欢保留utils 作为后缀。

【讨论】:

    【解决方案2】:

    您可能希望在应用程序的单例类中处理非成员函数。工厂可以从程序或其他对象中执行。

    C++ 支持全局函数(非成员函数),但是,为应用程序使用单个对象,“就行了”。

    此外,由于“教室”对象可能会使用许多可选参数进行实例化,因此您可能希望在调用构造函数(python 中的“init”)之后对其进行赋值。

    // filename: "classrooms.cpp"
    
    class ClassroomClass
    {
      protected:
        int _Room_Size;
        int _N_Desks;
        int _N_Boards;
        int _N_Books;
        bool _Has_Globe;
    
      public:
        // constructor without parameters,
        // but, can be declared with them
        ClassroomClass()
        {
          _Room_Size = 0;
          _N_Desks = 0;
          _N_Boards = 0;
          _N_Books = 0;
          _Has_Globe = false;
        } // ClassroomClass()
    
        public int get_Room_Size()
        {
          return _Room_Size;
        }
    
        public void set_Room_Size(int Value)
        {
          _Room_Size = Value;
        }
    
        // other "getters" & "setters" functions
        // ...
    
    } // class ClassroomClass
    
    class ClassroomFactoryClass
    {
      public:
        void addRequirement(char[] AKey, char[] AValue);
    } // class ClassroomFactoryClass    
    
    class MyProgramClass
    {
      public:
        ClassroomFactoryClass Factory;
      public:
        void makeTeacherRoom();
    
        void doSomething();
    } // class MyProgramClass
    
    void MyProgramClass::addRequirement(char[] AKey, char[] AValue)
    {
      ...
    }  // void MyProgramClass::addRequirement(...)
    
    void MyProgramClass::makeTeacherRoom()
    {
      Factory.addRequirement("n_desks", "10")
      Factory.addRequirement("n_boards", "1")   
    }  // void MyProgramClass::makeTeacherRoom(...)
    
    void MyProgramClass::doSomething()
    {
      ...
    }  // void MyProgramClass::doSomething(...)
    
    int main(char[][] args)
    {
       MyProgramClass MyProgram = new MyProgramClass();
    
       MyProgram->doSomething();
    
       delete MyProgram();
    
      return 0;
    }  // main(...)
    

    干杯

    【讨论】:

    • 这实际上是应用程序的旧形式,但结果是一个非常复杂的 ClassroomClass。设置者都必须具有重要的逻辑来管理各种客户请求的联合。然后,我们需要一个“Finalize()”方法来让对象知道它已经完成了获取客户端请求并可以创建实际数据。基本上,对象(教室)必须管理一堆客户端请求,这些请求与实际对象无关,而与创建对象有关。把它拿出来放在工厂里会让事情变得更干净(IMO)。
    【解决方案3】:

    我个人会让它们成为类的静态成员。

    class File
    {
        public:
    
        static bool load( File & file, std::string const & fileName );
    
        private:
    
        std::vector< char > data;
    };
    
    int main( void )
    {
        std::string fileName = "foo.txt";
        File myFile;
    
        File::load( myFile, fileName );
    }
    

    使用静态方法,它们可以访问类的私有数据,但不属于类的特定实例。这也意味着方法不会与它们作用的数据分开,如果你把它们放在某个实用程序头中就会出现这种情况。

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 2014-04-02
      • 1970-01-01
      • 2014-12-25
      • 1970-01-01
      • 1970-01-01
      • 2022-11-23
      • 1970-01-01
      相关资源
      最近更新 更多