Ada泛型、不完整类型与自引用结构难点：泛型包内智能指针实现

其实这个问题我之前也碰到过，Ada的类型声明顺序确实容易在这里绕进去！核心问题是要利用Ada的不完整类型声明来打破自引用和泛型之间的循环依赖，下面给你两种实用的方案：

方案一：泛型包内部直接封装自引用节点 #

如果你的智能指针是和链表/自引用结构绑定的，可以把整个逻辑放在泛型包内部，这样类型声明顺序会更清晰：

-- 泛型双向链表包，内置自引用节点和智能指针
generic
   type Item_Type is private; -- 泛型元素类型，支持任意私有类型
package Doubly_Linked_Lists is
   -- 第一步：声明不完整的节点类型，告诉编译器"这个类型存在，后面会补全定义"
   type Node;

   -- 第二步：定义智能指针类型（这里用Ada原生access类型做基础，你可以扩展成带引用计数的安全指针）
   type Node_Access is access Node;

   -- 第三步：补全节点类型定义，此时Node_Access已经存在，可以正常引用
   type Node is record
      Data  : Item_Type;
      Next  : Node_Access;
      Prev  : Node_Access;
   end record;

   -- 示例操作：创建新节点
   function Create_Node(Val : Item_Type) return Node_Access;

   -- 你可以在这里添加更多链表操作：插入、删除、遍历等
end Doubly_Linked_Lists;

-- 泛型包的实现部分
package body Doubly_Linked_Lists is
   function Create_Node(Val : Item_Type) return Node_Access is
   begin
      return new Node'(Data => Val, Next => null, Prev => null);
   end Create_Node;
end Doubly_Linked_Lists;

实例化使用示例 #

-- 实例化一个存储整数的链表包
package Integer_Lists is new Doubly_Linked_Lists(Item_Type => Integer);
use Integer_Lists;

procedure Test_Integer_List is
   Head : Node_Access := Create_Node(10);
   Second_Node : Node_Access := Create_Node(20);
begin
   Head.Next := Second_Node;
   Second_Node.Prev := Head;
   -- 后续可以添加更多链表操作逻辑
end Test_Integer_List;

方案二：通用智能指针包 + 外部自引用结构 #

如果你的智能指针是通用型的（可以复用在多种自引用结构上），可以把智能指针单独做成泛型包，再配合外部的不完整类型声明：

第一步：定义通用智能指针包 #

with Ada.Finalization; use Ada.Finalization;

-- 带引用计数的安全智能指针泛型包
generic
   type Element_Type is private;
package Safe_Smart_Pointers is
   type Element_Access is access Element_Type;

   -- 安全指针类型，继承自Controlled来实现自动内存管理
   type Safe_Pointer is new Controlled with private;

   -- 创建新的智能指针
   function Create(Val : Element_Type) return Safe_Pointer;
   -- 获取内部的原始指针（只读/可写按需调整）
   function Get(SP : Safe_Pointer) return Element_Access;

private
   -- 引用计数记录：存储数据指针和引用次数
   type Ref_Count_Record is record
      Data  : Element_Access;
      Count : Natural := 1;
   end record;
   type Ref_Count_Access is access Ref_Count_Record;

   type Safe_Pointer is new Controlled with record
      Ref : Ref_Count_Access;
   end record;

   -- 重写Finalize：离开作用域时减少引用计数，计数为0则释放内存
   overriding procedure Finalize(Obj : in out Safe_Pointer);
   -- 重写Adjust：复制指针时增加引用计数
   overriding procedure Adjust(Obj : in out Safe_Pointer);
end Safe_Smart_Pointers;

package body Safe_Smart_Pointers is
   overriding procedure Finalize(Obj : in out Safe_Pointer) is
   begin
      if Obj.Ref /= null then
         Obj.Ref.Count := Obj.Ref.Count - 1;
         if Obj.Ref.Count = 0 then
            Free(Obj.Ref.Data);
            Free(Obj.Ref);
         end if;
         Obj.Ref := null;
      end if;
   end Finalize;

   overriding procedure Adjust(Obj : in out Safe_Pointer) is
   begin
      if Obj.Ref /= null then
         Obj.Ref.Count := Obj.Ref.Count + 1;
      end if;
   end Adjust;

   function Create(Val : Element_Type) return Safe_Pointer is
   begin
      return Result : Safe_Pointer do
         Result.Ref := new Ref_Count_Record'(Data => new Element_Type'(Val), Count => 1);
      end return;
   end Create;

   function Get(SP : Safe_Pointer) return Element_Access is
   begin
      return (if SP.Ref /= null then SP.Ref.Data else null);
   end Get;
end Safe_Smart_Pointers;

第二步：实现自引用结构 #

-- 1. 先声明不完整的节点类型
type String_Node;

-- 2. 实例化智能指针包，指向这个不完整类型
package String_Node_SP is new Safe_Smart_Pointers(Element_Type => String_Node);
use String_Node_SP;

-- 3. 补全节点类型定义，使用智能指针做自引用
type String_Node is record
   Data : String(1..10);
   Next : Safe_Pointer;
   Prev : Safe_Pointer;
end record;

-- 使用示例
procedure Test_Safe_Pointers is
   Node1 : Safe_Pointer := Create(String_Node'(Data => "Hello      ", Next => <>, Prev => <>));
   Node2 : Safe_Pointer := Create(String_Node'(Data => "World      ", Next => <>, Prev => Node1));
begin
   Get(Node1).Next := Node2;
   -- 无需手动释放内存，当Node1/Node2离开作用域时，Finalize会自动处理引用计数
end Test_Safe_Pointers;

关键要点总结 #

• 必须先声明不完整类型（比如type Node;），打破“记录需要指针类型，指针需要记录类型”的循环依赖。
• 智能指针类型（不管是泛型包内部定义还是外部实例化）必须放在不完整类型声明之后、完整记录类型定义之前。
• 如果需要真正的“安全指针”，一定要利用Ada的Controlled类型实现自动引用计数和内存释放，避免内存泄漏。

内容的提问来源于stack exchange，提问作者Mehdi Saada