6.1 概述 (Overview)
一个程序是由一个或更多的子程序组成，以一个主过程(main procedure)为根本，主过程类似与 C 下的 main 函数。子程序包括过程(proceudre)和函数(function)两类,两者区别在于，过程没有返回值，而函数有返回值。
子程序，包括函数和过程，以及下一章所讲述的程序包，是构成 Ada 程序的基础。Ada 提供了一些和 C、Pascal 不同的新特性，如重载、参数模式、分离程序等。
6.2 过程(Procedure)
过程我们以前已经见过了，但那些都是主过程(main procedure)，即程序的主体部体，作用和C下的 main 函数相似。一般情况下，Ada 程序的主程序名应当和该主程序所在的文件名相同。过程的声明格式如下：
procedure procedure_name (parameter_specification);
它的执行部份则为：
procedure procedure_name (parameter_specification) is
declarations;
begin
statements;
end procedure_name;
procedure_name 为该过程的名称；parameter_specification 是这个过程所要使用的参数，是可选的；declarations 是声明一些局部的新类型、变量、函数、过程；statements 则是该过程要执行的语句。
下例创建一个比较两数大小，并输出较大值的过程**：**
procedure compare (A:Integer; B :Integer) is
begin
if A > B then
Put_Line ("A > B");
elsif A = B then
Put_Line ("A = B");
else
Put_ine ("A <B");
end if;
end compare;
下例则是完整的程序：
000 -- filename:comp.adb;
001 with Ada.Text_IO; use Ada.Text_IO;
002 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
003 procedure comp is
004 procedure compare (A:Integer; B :Integer) is
005 begin
006 if A > B then
007 Put_Line ("A > B.");
008 elsif A = B then
009 Put_Line ("A = B.");
010 else
011 Put_ine ("A < B.");
012 end if;
013 end compare;
014 X,Y:Integer;
015 begin
016 Put ("Enter A:"); Get (X);
017 Put ("Enter B:"); Get (Y);
018 compare (X,Y);
019 end comp;
通过上例，对过程的用法应该会有基本的了解了。因为 compare 的执行部分是在 comp 内部，所以我们无须给出单独的 compare 声明，如果要加一句**"procedure** compare (A:Integer; B :Integer)；"，程序还是老样子。声明部份和执行部份一般在使用程序包时分离。其中Put_Line，Get也都是预定义的过程
6.3 函数 (Function)
函数和过程也很像，只是它还要有返回值，和 C 很相似，也用 return 来返回函数值。声明格式为：
function function_name (parameter_specification) return return_type;
执行部份为：
function function_name (parameter_specification) return return_type is
declarations;
begin
statements;
return return_value;
end function_name;
function_name 为该函数的名称；parameter_specification 是这个函数所要使用的参数，是可选的；declarations 是声明一些局部的新类型、变量、函数、过程；statements则是该函数要执行的语句。return 返回一个数据类型为return_type的return_value**。**
将上一节的 comp 程序改动一下：
000 -- filename:comp.adb;
001 with Ada.Text_IO; use Ada.Text_IO;
002 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
003 procedure comp is
004 function compare (A:Integer; B :Integer) return Integer is
005 begin
006 return (A - B);
007 end compare;
008 X,Y,Result:Integer;
009 begin
010 Put ("Enter A:"); Get (X);
011 Put ("Enter B:"); Get (Y);
012 Result := compare (X,Y);
013 case Result is
014 when Integer'First..-1 => Put_Line (" A < B.");
015 when 0 => Put_Line (" A = B.");
016 when 1..Integer'Last => Put_Line (" A > B.");
017 when others => null;
018 end case;
019 end comp;
上例应该还能说明函数的特点。因为函数是返回一个值，所以在变量声明中赋予初始值时，也可用函数作为所要赋的值，如返回当前时间的 Clock 函数，可以直接在初始化某变量时作为要赋的值：Time_Now :Time:= Clock。与过程一样，在上述情况下，单独的函数声明可有可无。还有一点就是函数、过程的嵌套，上面两个例子就是过程包含过程，过程包含函数，可以无限制的嵌套下去---只要编译器别出错。
6.4 参数模式（Parameter Mode)
在上面的例子中，我们对函数或过程的参数并没做什么修饰，只是很简单的说明该参数的数据类型，但有时候，我们要设置参数的属性---函数和过程是否能修改该参数的值。一共有三种模式：in,out,in out。
in 模式
默认情况下，函数和过程的参数是 in 模式，它表示这个参数可能在子程序中被使用，但值不能被子程序改变。如我们写一个略微像样点的swap函数：
000 filename:swap.adb
001 with Ada.Text_IO; use Ada.Text_IO;
002 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;003 procedure Swap is
004 procedure Swap ( A: in Integer;B: in Integer) is
005 Temp :Integer;
006 begin
007 Temp := A; A:= B; B :=Temp;
008 end Swap;
009 X,Y:Integer;
010 begin
011 Put ("Enter A:"); Get (X);
012 Put ("Enter B:"); Get (Y);
013 Put ("After swap:"); New_Line;
014 swap(X,Y);
015 Put ("A is "); Put (X); New_Line;
016 Put ("B is "); Put (Y); New_Line;
017 end Swap;
上例的程序是无法编译通过的，因为Swap的两个参数 A 和 B 都是 in 模式，在这个子过程中无法修改X,Y的值，也就无法互换这两个值。这时就要使用 in out 模式的参数。
in out 模式
in out 模式表示该参数在这个子程序中既可修改又可使用。如只要将上例的[004]改为：procedure Swap ( A: in out Integer,B: in out Integer) **is;**该程序便能编译通过，运行正常。
out 模式
单纯的 out 模式表示该参数在这个子程序中可以修改，但不能使用。如求和的 add 过程：
procedure Add (Left ,Right : Integer; Result : out Integer) is****begin Result := Left + Right; end Add**;**
这个过程没问题，但假如还有个输出过程为：
procedure PutResult ( Result : out Integer) is
Temp : Integer := Result;
begin
Put (Temp);
end PutResult;
则会产生问题，虽然编译可能通过，但结果是不定的，最起码不是所指望的结果，因此 out 模式的参数不能赋值给其它变量。单独的 out 模式一般也不会出现。
6.5 调用子程序(Calling Subprograms)
调用子程序最简单的方式就是按照子程序声明的格式调用，如前例的procedure swap(A:Integer;B:Integer),只要填入的参数是Integer类型，便能直接使用 swap (A,B)。注意调用子程序时参数之间用“,”隔开;同类型的参数在声明时也可简化，如procedure swap(A,B:Integer)。但使用参数时还有下列几种特殊情况.
有名参数（Named Parameter)
我们也可以不按照参数顺序调用子程序。如调用 swap 也可以这样: swap(B => Y, A => X),这时是使用有名参数，明确声明每个变量的值，可以不按照子程序声明中的参数顺序赋值。这样的做的话可读性是好了一点,比较适合参数较多的情况。
如果将有名参数和位置参数一起混用，只需遵守一条规则：位置参数在有名参数前面。因此 swap 的调用有以下几种情况：
swap(x , y);
swap(A => x , B => y);
swap(B => y , A => x);
swap(x, B => Y);
上述四种情况是一样的。下列两种情况是非法的：
swap(y, A => x); ---不合法
swap(A => x , y); ---不合法
默认参数值（Default Parameter Values )
在声明某个子程序时，我们也可以使参数具有默认值，如下例：
000 -- filename:putlines.adb
001 with Ada.Text_IO; use Ada.Text_IO;
002 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
003 procedure putlines is
004 procedure putline(lines: integer:=1) is<> 005 begin
006 for count in 1..lines loop
007 New_Line;
008 end loop;
009 end putline;
010 Line :Integer;
011 begin
012 Put ("Print Lines :"); Get (Line);
013 putline;
014 end putlines;
实际上[012]可有可无，因为调用输出行函数 putline 时，没用参数。而 putline 在声明时赋予了参数 lines 一个默认值 1，这样的话如果调用 putline 没用参数，就以 1 作为参数值。上例也就只输出一个空行。如果putline有参数，如putline(Line),则输出的行数取决于 Line 的数值。
6.6 重载(Overload)
子程序重载
实际上通过先前的一些例子，细心的朋友可能发现，过程 Put 能处理不能类型的参数，不像 C 下的 printf 要选择输出类型，这就涉及到子程序重载：只要参数不一样，子程序可以有相同的名称。如在程序包Ada.Text_IO里的两个过程:
procedure Put (Item : in Character);
procedure Put (Item : in String);
编译器会自动选择合适的子程序，如果Put后面的参数为 Character类型，则调用procedure Put (Item : in Character);为 String 类型，则调用procedure Put (Item : in String)。这样在用户层上使用子程序简便了许多，很多常见的子程序:Get,Put_Line,Line, Page都是这样实现的----虽然在预定义程序包内针对不同参数都有一个子程序与之相对应,用户却只要记住一个名称就可以了。
运算符重载
运算符重载应该说时时刻刻都在----不同的数据类型都拥有相同的运算符:+,-,*,/等。它的原理和子程序重载是一样的，在 Ada 里，运算符也是通过子程序形式来实现。下面就给出一个“+”和 put 重载的例子：
000 -- filename: overload.adb
001 with Ada.Text_IO; use Ada.Text_IO;
002 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
003 procedure overload is
004 type Vector is array (1 .. 5 ) of Integer;
005 a, b, c :Vector;
006 function "+"(left,right:Vector) return Vector is
007 result : Vector;
008 begin
009 for i in left'range loop
010 result(i) := left(i) + right(i);
011 end loop;
012 return result;
013 end "+";
014 procedure Put (Item : Vector) is
015 begin
016 for i in Item'range loop
017 Put (Item(i));
018 end loop;
019 end Put;
020 begin
021 a := (1,2,3,4,5);
022 b := (1,2,3,4,5);
023 c := a + b;
024 Put (c);
025 end overload;
上例为了简化问题，有些实际中应该有的代码去除了----如检测所操作数的类型。但其它类型的运算符和重载子程序实现原理也和上例一样。
6.7 分离子程序(Separating Subprogram)
Ada 还允许子程序分成多个部份，而不是像以前的例子一样都塞在同一文件里，如将上例分成两个文件：
第一个文件：
000 -- filename: overload.adb
001 with Ada.Text_IO; use Ada.Text_IO;
002 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
003 procedure overload is
004 type Vector is array (1 .. 5 ) of Integer;
005 a, b, c :Vector;
006 function "+"(left,right:Vector) return Vector is
007 result : Vector ;
008 begin
009 for i in left'range loop
010 result(i) := left(i) + right(i);
011 end loop;
012 return result;
013 end "+";
014 procedure Put (Item : Vector) is separate;
015 begin
016 a := (1,2,3,4,5);
017 b := (1,2,3,4,5);
018 c := a + b;
019 Put (c);
020 end overload;
第二个文件：
000 --filename:overload-put.adb
001 separate (overload) -- 注意结尾没有分号；
002 procedure Put (Item : Vector) is
003 begin
004 for i in Item'range loop
005 Put (Item(i));
006 end loop;
007 end Put;
这个程序和先前那个完全一样，只是"分了家"而已。这样分离程序有时能更好的分解程序的任务，使程序结构更为清楚。注意一下overload.adb的[014] 和 overload-put.adb的 [001]，这两句就是分离子程序的主要语句。
６.８ 子程序的内嵌扩展(Inline Expansion of Subprograms)
子程序可以在调用地点被内嵌扩展，以提高程序效率，它的格式为：
pragma Inline(name);
如果 name 是一个可调用的实体，子程序或类属子程序（见第11章），那么 pragma Inline 指示在所有调用该实体的地方要求对该实体进行内嵌扩展。这在封装其它语言的接口时，使用的比较多，以提高效率。
