本文介绍了 system verilog 中静态数组、动态数组、队列作为函数参数传递的规则，以及 input、output、ref 关键字的规则。

先说明，sv 中的静态数组、动态数组、队列都是用一块内存存放，而他们的名字作为该内存的地址，这点应该和 c 一致，但 sv 里面没有指针的概念。

传递这种大片内存的值一般只有两种规则

1. 地址传递，函数内部修改可以改变函数调用的值。
2. 值传递，将整片空间复制一份，函数内部修改不会改变函数调用的值。

但是 system verilog 里面关键字有三个，input、output、ref。

具体哪个对应哪个，我们来试一下。

以静态数组作为模板来试。

1
2
3
4
5
6
7

function void run();
   int r[2];
    r[0] = 1;
    r[1] = 2;
    f(r);
    $display("%0x %0x",r[0],r[1]);
endfunction

加 input 的情况

1
2
3

function void f(input int a[2]);
    a[0] = 3;
endfunction

输出结果是：1 2

具体过程如下：

1. 函数调用之前，内存里只有 r 数组的空间
2. 函数调用之后，会将 r 拷贝一份到 a，函数里面用的都是 a 这份空间
3. 函数调用之后，赋值后，修改的是 a 这份空间的值
4. 函数返回之后，a 空间会被释放掉，所以 r 的值并没有修改

因此，input 是标准的值传递。

加 output 的情况

1
2
3

function void f(output int a[2]);
   a[0] = 3;
endfunction

输出结果是：3 0
具体过程如下：

1. 函数调用之前，内存里只有 r 数组的空间
2. 函数调用之后，会新建一份 a 数组，注意这里并不会把 r 的值传进来，函数里面用的都是 a 这份空间
3. 函数调用之后，赋值后，修改的是 a 这份空间的值
4. 函数返回之后，会将 r 指向 a 空间，而原来 r 指向的空间会被释放掉，所以 r 的值都被修改了

因此，加 output，采用的是地址传递，确切的说是反向的地址传递，数组共有两份，函数内部看到的是新建的一份，并传递给函数调用处，因此，函数调用前看到的是第一份，函数调用后看到的是新建的那份。

加 ref 的情况

1
2
3

function void f(ref int a[2]);
  a[0] = 3;
endfunction

输出结果是：3 2

具体过程如下：

1. 函数调用之前，内存里只有 r 数组的空间
2. 函数调用之后，会将 a 指向 r 所在的空间，函数里面用的都是这份空间
3. 函数调用之后，赋值后，修改的是这份空间的值，所以 r 和 a 都修改了
4. 函数返回之后，所以 r 的值只有部分修改

因此，加 ref，采用的是标准的地址传递，只有一份数组，函数内部和调用处都是访问该空间。

对比来看，input 是将函数外面的值传递到函数里面，调用结束之后，函数里面的值就被丢弃了；out 是将函数里面的值传递到函数外面来，调用结束之后，函数外面的值就丢了；ref 是函数内部和外部看到的是同一份值，哪里改都会改。

另外，可以看出，采用 ref 关键字是占用内存最小的，因为只有一份数组，这样能提高效率。

动态数组或队列作为参数

如果传递的是动态数组或者队列，其结果是一模一样的，不另外作说明。

类作为参数

但是！！如果传递的是类，则会有点不一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class c;
 int v0;
  int v1;
endclass
function void run();
    c c0;
    c0 = new();
  c0.v0 = 1;
   c0.v1 = 2;
   f(c0);
   $display("%0x %0x",c0.v0,c0.v1);
endfunction
function void f(input/output/ref c c0);
 c0.v0 = 3;
endfunction

结果是：

1. input：3 2
2. output：报 null point 错误
3. ref：3 2

可以看出，如果是传递类的话，使用 input 和 ref 是一样的，都是地址传递，而 output 和数组的结果是一样的。