一、非组合型数组

1.声明

logic [31:0] array [1024];
或者logic [31:0] array [1023:0];
或者logic array [31:0] [1023:0];

理解成一维数组就表示array 数组中有1024个数据，每个数据32bit。

也可以理解为二维数组。

int [1:0][2:0]a1[3:0][4:0]

这是一个4×5×2×3维（高维-低维）的数组。要先看数组名右边的，再看数组名左边的，其中每一边都是从左到右

2.特点

声明时数组元素个数在数组名右边，各数据是独立的，非连续存储。且左边是高位，右边是低位

3.数组的赋值

int array1 [7:0] [31:0];
int array2 [7:0] [31:0];
array2[3] = array1 [0];

表示将array1数组的所有32个元素的第一位赋值给array2对应的32个元素的第4位。

所以其实array2[3]是一种简写，完整写法为array2[3][31:0]

注意非组合型数组不能使用向量来进行赋值。如a = 8'h5。因为向量是连续的而非组合型数组是非连续的。

4.数组的初始化

非组合型（unpacked）数组初始化时，则需要通过’{}来对数组的每一个维度进行赋值

int d [0:1][0:3] = ’{ ’{7,3,0,5}, ’{2,0,1,6} };
// d[0][0] = 7
// d[0][1] = 3
// d[0][2] = 0
// d[0][3] = 5
// d[1][0] = 2
// d[1][1] = 0
// d[1][2] = 1
// d[1][3] = 6

5.拷贝

• 对于组合型数组，由于数组会被视为向量，因此当赋值左右两侧操作数的大小和维度不相同时，也可以做赋值。
• 如果当尺寸不相同时，则会通过截取或者扩展右侧操作数的方式来对左侧操作数赋值。

B = A

当A的位宽小于B的位宽时，要对B的高位进行填充，如果都是有符号数则填充符号位，无符号数填充0; 当A的位宽大于B的位宽时，截掉A的高位

二、组合型数组

1.声明

logic [3:0][7:0] array;

表示有4个8bit数据

2.特点

维度声明在数组名的左边；各数据连续存放。高维在最左边

3.赋值

logic [1:0][1:0][7:0] a; // 3-D packed array
a[1][1][0] = 1’b0; // assign to one bit
a = 32’hF1A3C5E7; // assign to full array
a[1][0][3:0] = 4’hF; // assign to a part select
a[0] = 16’hFACE; // assign to a slice
a = {16’bz, 16’b0}; // assign concatenation

可以使用向量进行整体赋值

4.初始化

组合型数组的初始化与向量的初始化一致.

logic [3:0][7:0] a = 32’h0; // vector assignment
logic [3:0][7:0] b = {16’hz,16’h0}; // concatenate operator
logic [3:0][7:0] c = {16{2’b01}}; // replicate operator

5.拷贝

对于非组合型数组，在发生数组间拷贝时，则要求做左右两侧操作数的维度和大小必须严格一致

logic [31:0] a [2:0][9:0];
logic [0:31] b [1:3][1:10];
a = b; // assign unpacked array to unpacked array

非组合型数组无法直接赋值给组合型数组，同样地，组合型数组也无法直接赋值给非组合型数组

三、 组合型声明数组

组合型（packed）除了可以用来声明数组，也可以用到结构体里面去。

typedef struct packed {
logic [ 7:0] crc;
logic [63:0] data;
} data_word;
data_word [7:0] darray; // 1-D packed array of
// packed structures

如果未添加packed，则默认他是非组合型。添加了则是组合型，结构体内各变量连续存放，节省空间，方便赋值

四、数组的索引

• SV添加foreach循环来对一维或者多维数组进行循环索引，而不需要指定该数组的维度大小。
• foreach循环结构中的变量无需声明。
• foreach循环结构中的变量是只读的，其作用域只在此循环结构中。

int sum [1:8] [1:3];
foreach ( sum[i,j] )
sum[i][j] = i + j; // initialize array

五、关于数组的一些系统函数

• $dimensions(array_name)用来返回数组的维度。
• $left(array_name, dimension)返回指定维度的最左索引值（msb）。

logic [1:2][7:0] word [0:3][4:1];
$left(word,1) will return 0
$left(word,2) will return 4
$left(word,3) will return 1
$left(word,4) will return 7

• 与$left()类似的，还有${right, low, high}(array_name, dimension)。
• $size(array_name, dimension)可以返回指定维度的尺寸大小。
• $increment(array_name, dimension)，如果指定维度的最左索引值大于或等于最右索引值，那么返回1，否则返回-1。
• $bits(expression)可以用来返回数组存储的比特数目。

wire [3:0][7:0] a [0:15]; // $bits(a) 返回512
struct packed {byte tag; logic [31:0] addr;} b; $bits(b) 返回40

六、动态数组

以上的组合数组与非组合数组都是叫做定常数组，即位宽大小都是确定的，下面介绍动态数组。

1.声明

• 动态数组在声明时需要使用[]，这表示不会在编译时为其指定尺寸，而是在仿真运行时来确定。
• 动态数组一开始为空，而需要使用new[]来为其分配空间。

2.系统函数

• new[]

dynamic_array_new ::= new[expression] [(expression)]

[expression]:

数组中元素的数目。必须是一个非负的 integral 表达式。

(expression):

可选的。用一个已知的数组来初始化新的数组。如果没有指定，那么最新分配的数组元素被初始化成它们的缺省值。数组标识符必须与左侧的数组具有相同的数据类型，但不必具有相同的尺寸。如果这个数组的尺寸小于新数组的尺寸，那么多余 的元素会被初始化成它们的缺省值。如果这个数组的尺寸大于新数组的尺寸，那么多余的元素会被忽略。 例如：

integer addr[]; // 声明动态数组
addr = new[100]; // 产生具有 100 个元素的数组 ...
addr = new[200](addr);// 加倍数组的尺寸，但保留以前的值。

• size（）

int j = addr.size(); 
addr = new[j] (addr); // 将 addr 数组的尺寸扩大为 4 倍

size()方法返回动态数组的当前尺寸，如果数组还没有产生，则返回 0。

• delete（）

int ab [] = new[N]; // 产生一个尺寸为 N 的临时数组
ab.delete(); // 删除数据内容
$display("%d", ab.size); // 打印 0

delete()方法清空数组，产生一个 0 尺寸的数组。

不可以像队列一样使用delete(i)删除第i个元素

同样也可以使用new[0]来进行清空

七、队列（queue）

1. 定义

队列类似于一个一维的非压缩数组，它可以自动地增长和缩减。0 代表第一个 元素，$代表最后一个元素

1. 赋值

byte q1[$]; // 一个字节队列
string names[$] = {"Bob"}; // 具有一个元素的字符串队列
integer Q[$] = {3, 2, 7}; // 一个被初始化成三个元素的整数队列
bit q2[$:255]; // 一个最大尺寸为 256 的位队列

1. 队列操作符

int q[$] = {2, 4, 8};
int p[$];
int e, pos; 
e = q[0]; // 读取第一个（最左边）条目。
e = q[$]; // 读取最后一个（最右边）条目。
q[0] = e; // 写第一个元素 
p = q; // 读和写整个队列（拷贝） 
q = {q, 6}; // 在队列的尾部插入'6' 
q = {e, q}; // 在队列的头部插入'e' 
q = q[1:$]; // 删除第一个（最左边）元素
q = {}; // 清除队列（删除所有的元素） 
q = {q[0:pos-1], e, q[pos:$]}; // 在位置'pos'处插入'e' 
q = {q[0:pos], e, q[pos+1:$]}; // 在位置'pos'之后插入'e'

Tips:

如果 a>b，那么 Q[a:b]产生一个空队列{}。

Q[n:n]产生具有一个元素的队列，这个元素位于位置 n。因此，Q[n:n]==={Q[n]}。

如果 n 位于 Q(n < 0 或 n > $)的范围之外，那么 Q[n:n]产生一个空队列{}。

无论是 a 还是 b 是一个包含 X 或 Z 的四态表达式，都产生一个空队列{}。

Q[a:b]中如果 a < 0，那么它与 Q[0:b]相同。

Q[a:b]中如果 b > $，那么它与 Q[a:$]相同。

1. 队列方法

• size()

size()方法返回队列中元素的数目。如果队列是空的，它返回 0。

for (int j=0; j<q.size; j++) $display(q[j]);

• insert()

insert()方法在指定的索引位置插入指定的元素。

q[$]={1,2,3};
q.insert(1,3);//在第二个位置插入元素3.

不过insert只能插入元素，不能插入一个队列，下面的操作是错误的

int q1[$]={1,2,3};
int q2[$]={1};
q1.insert(1,q2);//这种做法是错误的

• delete()

delete()方法删除指定索引位置的元素。

q[$]={1,2,3};
q.delete(1);//删除第二个元素
q.delete();//删除所有元素

• push_front(); push_back()

q[$]={1,2,3};
q.push_front(1);//在第一个位置插入元素1
q.push_back(1);//在最后位置插入元素1.

• push_front(); push_back()

q[$]={1,2,3};
j=q.pop_front();//队列q删除第一个元素，并返回第一个元素1给j
j=q.pop_back();//队列q删除最后一个元素，并返回最后一个元素3给j

• 拼接符

q1[$]={1,2,3};
q2[$]={4,5,6};
q={q1[0:1],7,q2[1:$]};//q表示{1,2,7,5,6}

八、关联数组（hash）

1. 定义

对于处理成员数目会动态改变的连续变量集合而言，动态数组非常有用。然而，当集合的尺寸是未知的或者数据存储空间比较有限的时候，联合数组则是更好的选择。联合数组在使用之前不会分配任何存储空间，并且索引表达式不再被限制成 integral 表达式，而是可以具有任何数据类型。在对一个非常大的地址空间进行寻址时，SV只为实际写入的元素分配空间

1. 声明

data_type array_id [index_type];

index_type 是用作索引的数据类型， 或者使用*。如果是*，那么数组可以使用任意尺寸的 integral 表达式来索引。采用数据类型作为索引的联合数组将索引表达式限制成一个特定的数据类型。

integer i_array[*]; // 整数联合数组（未指定索引）
bit [20:0] array_b[string]; // 21 位向量的联合数组，使用字符串类型作为索引
event ev_array[myClass]; // 事件类型的联合数组，使用类 myClass 索引