也许 C++ 和 Java 的人可以帮助我定义我要解释的这个问题。我在 Ada 中有一个问题(你不需要知道它，我只是对这个概念感兴趣)关于如何表示实现动态标识符三个主要分支的类的构造函数:

• 纯数值(整数、 float 、字符串等)
• 列出/堆叠项目
• C++ 中的东西可能是线程(在 Ada 中，我们对此有更广泛的概念，与任务相关，但我们可以将一个简单的任务概念为一个线程，所以这个概念也适用)

我要调用这个类Par_Class，并将任何构造的对象调用Par_Obj。因此，当一个对象 Par_Obj 被创建时(因此，数字值被初始化，列表/堆栈分配了其他列表/堆栈或为空并且线程执行的内存范围被保留)，操作系统自动开始与我的主应用程序并行执行新线程(现在它们争用系统资源)。但为了简化示例，假设我有一个类，其中包含一个整数和一个指向字符串的指针。

例如，我可以在 C++ 中编写代码(如果我做错了，请纠正我)

class Par_Class {
public:
  Par_Class (int aValue, const std::string & aName);

private:
  int theValue;
  std::string theName;
};

构造函数可以实现为

Par_Class::Par_Class (int aValue, const std::string & aName)
  : theValue(aValue)
  , theName(aName)
{
}

最后我们可以实例化这个类

Par_Class Par_Obj (23, "My object is this");

并确保此构造方法属于类 Par_Class 而不是任何其他类。

同样，在 Java 中，我们可以编写代码

public class Par_Class {
  private int theValue;
  private String theName;

  public Par_Class (int aValue, String aName){
    theValue = aValue;
    theName = aName;
  }
};

我们可以使用实例化对象

Par_Class Par_Obj = new Par_Class (23, "My object is this");

(如果我错了，请再次纠正我)。同样，Par_Class 构造函数是类 Par_Class 的一个方法。

在 Ada 2005 中，此类可以编码为

--par_pkg.ads
package Par_Pkg is
   type Par_Class is tagged private;
   type Par_Class_Ptr is access all Par_Class;
   type Integer_Ptr is access Integer;

   function Construct 
     (P : access Par_Class; aValue : Integer; aName : Integer_Ptr)
      return Par_Class_Ptr;

private
   type Par_Class is tagged
      record
         theValue : Integer;
         theName  : Integer_Ptr;
      end record;
end Par_Pkg;

-- par_pkg.adb
package body Par_Pkg is
   function Construct 
     (P : access Par_Class; aValue : Integer; aName : Integer_Ptr)
      return Par_Class_Ptr is
      pragma Unreferenced (P);
      P_Ptr : constant Par_Class_Ptr := new Par_Class;
   begin
      P_Ptr.theValue := aValue;
      P_Ptr.theName := aName;
      return P_Ptr;
   end Construct;

end Par_Pkg;

并且用户可以调用

with Par_Pkg; use Par_Pkg;
procedure Par_Main is
   Par_Obj : Par_Class_Ptr;
   Int_Obj : Integer_Ptr;
begin
   Int_Obj := new Integer;
   Int_Obj.all := 12; -- don't worry about been string or integer
   Par_Obj := Par_Obj.Construct 
     (aValue => 23,
      aName => Int_Obj);
end Par_Main;

这就是问题所在。编译器告诉我，我不能在 Par_Obj := Par_Obj.Construct 中使用 Construct 方法，因为我的对象还是空的。但这很明显，因为我只想初始化对象(这样它就不会再为 null)。还有其他构造对象的方法，例如，使用类外部的函数，但我不想使用这种方法，因为它脱离了体系结构。你能帮我把这个问题表述给我的 Ada friend ，这样他们就可以帮助我在 Ada 中实现它吗？我想我在用一般概念术语解释这一点时有点困难。谢谢。

回答

@paercebal 给了我我认为可以实现我的目标的东西:

• “有没有办法在 Par_Class 中声明一个“静态”函数？”和“有没有办法让非成员函数声明为 Par_Class 的友元？”

我可以用“有没有办法在标记类型中声明一个“静态”函数？另外，声明该类的包可以充当友元函数还是静态函数？”

更新

根据@SimonWright 和来自 comp.lang.ada 论坛的一些人的建议，得到了更多关于为什么实现它的充分理由:

function Construct (aValue: Integer; aName: Integer)
                    return Par_Class is
begin
  return (theValue => aValue,
          theName  => aName);
end Construct;

所以我问:在这种情况下，函数 Construct 将表现为 C++ 静态函数(或者可能是 friend 函数？)？

Dmitry Kazakov 回答说:

That depends on what you mean. In Ada:

1. there is no hidden parameters

2. an operation can be dispatching (virtual) in any combination of parameters and/or result. But an operation cannot be dispatching in more than one type (no multiple dispatch). All tags of dispatching parameters must be same (no multi-methods).

3. there is no static or friend operations as the visibility rules are based on packages.

The function Construct above is a primitive operation, it is not a constructor.

Constructors in Ada are implicit, they consist of

1. construction of the components (in an unspecified order, recursively);

2. a call to Initialize if the type is a descendant of Ada.Finalization.[Limited_]Controlled. (Overridden bodies of Initialize are not called! I.e. Ada constructors do not traverse derivation path. In short, aggregation is safe, derivation is not;

3. starting all task components. (Note, tasks are not running when Initialize is called!)

Destructors act in the reverse order: tasks - Finalize - components.

我想它会回应。谢谢大家。

最佳答案

Par_Class (int aValue, const char *aName) 是非常特殊的 C++ 构造函数语法；使用时，编译器会生成一个新的空白内存区域(如果有 new，则调用 malloc()，否则在堆栈上)，构造函数会填充它。

这不与

function Construct 
  (P : access Par_Class; aValue : Integer; aName : Integer_Ptr)
   return Par_Class_Ptr;

这需要有一个先前的 Par_Class 实例，就像有一个 C++ 成员函数

Par_Class *a_Par_Class(int aValue, const char *aName);

如果使用未初始化的 Par_Class * 调用，它将以与当前 Ada 代码相同的方式失败。

我认为最接近(Ada 2012)的构造函数是

function Construct 
  (aValue : Integer; aName : Integer_Ptr)
   return Par_Class is
begin
   return Result : Par_Class do
      Result.theValue := aValue;
      Result.theName := aName;
   end return;
end Construct;

或者，适用于 Ada 95/2005 并且最接近您目前的方案:

function Construct 
  (aValue : Integer; aName : Integer_Ptr)
   return Par_Class_Ptr is
   P_Ptr : constant Par_Class_Ptr := new Par_Class;
begin
   P_Ptr.theValue := aValue;
   P_Ptr.theName := aName;
   return P_Ptr;
end Construct;

@paercebal 提到你需要一个静态成员函数，这是正确的； C++ 构造函数是我认为的语法糖。在 Ada 中，作用域是在包级别完成的，因此 function Construct - 在同一包的公共(public)部分声明并返回 Par_Class_Ptr - 明确无误地(在架构上)关联与 Par_Class。

关于java - 从 C++ 和 Java 到 Ada 的类构造概念，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8074623/