简短版:
考虑以下伪代码:

class Foo {
    private:
        abstract type myVar;
} // This class is abstract

您将如何在标准 C++ 中实现此行为？

长版:
我必须将大量面向对象的代码从 Matlab 移植到 C++。 请注意，我是世界上使用 Matlab 经验最少的人，自 2007 年以来我就不再使用 C++。

我在谷歌上搜索了很多关于这个主题的内容，但找不到正确的答案来解决我的问题。 所以我在这里 :)

假设您有这个 matlab 类:

classdef Foo < handle
    properties (Abstract, Dependent)
        A
    end

    properties
        B
    end

    methods (Abstract)
        computeA()
    end

    methods (Access = protected)
        function obj = Foo(bar)
            obj.B = Matlab.BlaBlaBla(bar)
    end
end

这个类(我想)不能“直接”分配，因为它的构造函数是 protected 。 属性“A”也是抽象的(暂时忽略也是从属的事实)。 MathWorks 告诉我们，这意味着:

• 具体子类必须重新定义抽象属性，而无需 抽象属性，并且必须对 SetAccess 和 GetAccess 属性与抽象父类(super class)中使用的属性相同。
• 抽象属性不能定义 set 或 get 访问方法(参见 属性访问方法)并且不能指定初始值。这 定义具体属性的子类可以创建 set 或 get 访问方法并指定初始值。

那么您如何在 C++ 中正确翻译此类行为？ 如果我这样做是对的吗？ (我的意思是，这不是一个糟糕的设计实践)

class Foo {
    private:
         type A;
         type B;
    protected:
         virtual void computeA() = 0;
         Foo(type bar) { this.B = SomeFoo(bar); }
}

我的想法(我可能是错的)是，如果我这样做，人们将不得不这样做

class Subclass: Foo {
    protected:
        void computeA(){...} 
    public:
        type A() { computeA(); return A; } //This is A getter that grants Dependent behavior
}

否则会在编译时出错。

我错了吗？有更好的方法吗？ 也是翻译 Dependent 关键字的正确方法吗？

最佳答案

首先，我认为重要的是要问:一个类的公共(public)接口(interface)是什么(它的职责是什么，它如何与其他人交互)？

根据您的 Matlab 代码，答案是:该类定义了属性 A 和 B 以及方法 computeA。根据我对依赖属性的理解，我怀疑 computeA() 应该是公开的(参见 Matlab docs )。如果您的其余代码需要它，您当然可以将其公开，但我会尽量减少可访问性。

现在 C++ 中不存在 Property 的概念。 Matlab 的有趣之处在于基类决定是否有 A.get、A.set 或两者以及可访问性。我不知道这背后的原理，但在我看来似乎没有太大意义。在 C++ 中，我会将属性转换为获取/设置方法。参见 this question用于讨论在 C++ 中实现这些。根据您的选择，您可以将非依赖属性实现为成员对象或 get/set 方法。

一旦您定义了方法的公共(public)接口(interface)，我就会开始考虑如何实现它。请注意，Matlab 和 C++ 的内存管理是不同的(Matlab 使用 Copy on Write 并关心内存管理，这些在纯 C++ 中都不存在)。此外，在(慢速面向对象的)Matlab 代码中可能需要缓存值(如对 computeA 和依赖属性所做的那样)，但在 C++ 中则不一定。为避免过早优化，为什么不这样做:

class Foo {
    public:
      ClassB B;
      virtual ClassA getA() = 0;
      //define a setA()=0 if you need it here
    protected:
         //I wouldn't force subclasses to have the "caching" of dependent properties, so no virtual void computeA() = 0; 
         Foo(ClassBar const& bar) { this.B = ClassB(bar); /*Note that SomeFoo cannot be assigned to B*/ }
}
class Subclass: public Foo {
    private:
        ClassA A;
    public:
        ClassA getA() { ClassA A; /*compute A*/ return A; } 
}

如果你觉得A的计算速度太慢，你仍然可以在子类中“本地缓存A”:

class Subclass: public Foo {
    private:
        ClassA A;
    public:
        ClassA getA() { /*compute A if required*/ return A; } 
}

如果您真的想将 A 存储在 Foo 中，我宁愿将其实现为

class Foo {
    private:
      ClassA A;
    public:
      ClassB B;
      ClassA getA() { if (!A.initialized) A=computeA(); return A; };
    protected:
         virtual ClassA computeA() = 0;
         Foo(ClassBar const& bar) { this.B = ClassB(bar); /*Note that SomeFoo cannot be assigned to B*/ }
}
class Subclass: public Foo {
    protected:             
         virtual ClassA computeA() {...}
}

并且不要忘记始终考虑您是否真的想传递(常量)引用或值...

关于C++ 等效于类属性的 Matlab 抽象，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14359330/