What is the difference between System Verilog Dynamic Array, Associative Array & Queue and their applications?

Ans: The following is the difference between Dynamic Array, Associative Array & Queue.

Dynamic Array:

We use dynamic array when we have no idea about the size of the array during compile time and we have to allocate its size for storage during run time.
We basically use this array when we have to store a contiguous or Sequential collection of data.
The array indexing should be always integer type.
To allocate size of a dynamic array, we have to use new[] operator.

            Example:
               int my_array [];
               initial
                   begin
                         my_array = new[4];                              //Allocated 4 elements
                    end

To resize a dynamic array, we have to do as follows:

             Example:
               initial
                  begin
                       my_array = new[18](my_array);     //Resize the Array and Copy
                  end

To know the size of the array, we have to use size() operator.

Example:
my_array.size(); //Returns the current size of the array, my_array as an integer.

To delete an element from a dynamic array, we have to use delete() operator.

             Example:
              initial
                  begin
                       my_array.delete();    //All the elements of array, my_array will be deleted.
                   end

Associative Array:

It is also allocated during run time.
This is the array, where data stored in random fashion.
It is used when we don’t have to allocate contiguous collection of data, or data in a proper sequence or index.
In associative array, the index itself associates the data. So it is called so.
Indexing is not regular, can be accessed using indexing like integer or string type or any scalar.

Example:

my_array ["name"];           // “name”, Index type is a string
my_array[address];           // address, Index type is an integer (here address is an integer).
my_array[my_class];       // my_class, Index type is a class.
my_array[s_array];          // s_array, Index type is an array.

It is better to use associative array, when size of the array is unknown & data space is random or irregular or sparse.
Following are the methods associated with Associative array.

num() — returns the number of entries in the Associative array

Eg: my_array.num()
first() — assigns the value of the first index in the Associative array to the given index variable Eg:my_array.first(i);
last() — assigns the value of the last index in the Associative array to the given index variable Eg:my_array.last(i);
next() — assigns the value of the next index in the Associative array to the given index variable Eg:my_array.next(i);
prev() — assigns the value of the previous index in the Associative array to the given index variable Eg:my_array.prev(i);
delete() — removes all the elements in the Associative array.
Eg: my_array.delete(i); If the index is specified, then the element at the specified index “i”is deleted
exists() — checks if element exists at the specified index “i” in the Associative array Eg:my_array.exists(i);

Queue:

Queue is a variable size, ordered collection of Homogenous Data.
It is flexible, as it is variable in size and analogous to an 1-dimensional Unpacked array that can shrink & grow automatically and can be of size zero.
The main advantage of queue over dynamic array is that, we don’t need new[] operator to allocate storage space for a queue.
The other advantages of queue over dynamic array is that we can manipulate the queue using various queue methods like: push, pop, delete, insert, size.

Example:

module test_example ;
int my_queue[$] = { 1, 2, 3 };
string s_queue [$] = {"first","second","third","fourth"};
string store;

initial
begin

// Use of the size() method/operator
$display("\n size() operator used");
for (int i = 0 ; i < my_queue.size(); i++ )
$display (my_queue[i]);
$display("\n\n Elements of s_queue is :");
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of insert() method/operator
s_queue.insert(1,"next"); // Previous element 1 is now turned to element 2.
s_queue.insert(2,"somewhere");
$display("\n\n insert() operator used");
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of delete() method/operator
s_queue.delete(1); // delete the element 1
s_queue.delete(3); // delete the element 3
$display("\n\n delete() operator used");
for (int i = 0; i < s_queue.size; i++)
$write(string_queue[i]," ");
// Use of pop_front() method/operator (it deletes the front of the queue)
store = s_queue.pop_front();
$display("\n\n pop_front() operator used");
$display(" %s",store);
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of pop_back() method/operator (it deletes the back of the queue)
store= s_queue.pop_back();
$display("\n\n pop_back() operator used");
$display(" %s",store);
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," ");
// Use of push_front() and push_back() method/operator
s_queue.push_front("in-front");
s_queue.push_back("in-back");
$display("\n\n push_front() and push_back() operator used");
for (int i = 0; i < s_queue.size; i++)
$write(s_queue[i]," \n ");
end
endmodule

Result:

size() operator used
1
2
3

Elements of s_queue[$] is:
first second third fourth

insert() operator used
first next somewhere second third fourth

delete() operator used
first somewhere second fourth

pop_front() operator used
first
somewhere second fourth

pop_back() operator used
fourth
somewhere second

push_front() and push_back() operator used
in-front
somewhere
second
in-back