内容来自白皮书，仅做复习记录！
SystemVerilog是一种面向对象的编程语言。与非面向对象的编程语言（如C语言）相比，面向对象语言最重要的特点是所有的功能都要在类（class）里实现。
A.1 结构体的使用
在非面向对象编程中，最经常使用的就是函数。
要实现一个功能，那么就要实现相应的函数。当要实现的功能比较简单时，函数可以轻易地完成目标。
如计算一串数据流的CRC校验值，虽然CRC的算法比较复杂，但是完全可以用一个函数实现。
但是，当要实现的功能比较复杂时，仅仅使用函数实现会显得比较笨拙。
假设某动物园要实现一个简单的园内动物管理系统，这个系统要具有如下的功能：统计园内所有的动物的信息，如名字、出生年月、类别（是否能飞翔）、每天进食量、是否健康等。
打印动物园内所有动物的信息。要实现上述的这些功能，仅仅考虑如何写函数是不够的，需要考虑如何存储这些信息，即要考虑数据结构。
伟大的EDA让电路设计也变成了程序设计！！！
程序设计=算法+数据结构。所以，在程序设计的开始阶段定一个好的数据结构就相当于成功了一半。
在程序设计语言中，一般都支持结构体。以C语言为例，可以使用struct声明一个结构体（这个结构体中有些信息的定义并不完善，如生日、类别等，但是作为例子足以说明问题）：
struct animal { char name[20]; int birthday;/*example: 20030910*/ char category[20];/*example: bird, non_bird*/ int food_weight; int is_healthy; };
当声明了结构体后，可以定义结构变量，并将结构变量作为函数的参数来实现上述功能：
void print_animal(struct animal * zoo_member){ printf("My name is %s\n", zoo_member->name); printf("My birthday is %d\n", zoo_member->birthday); printf("I am a %s\n", zoo_member->category); printf("I could eat %d gram food one day\n", zoo_member->food_weight); printf("My healthy status is %d\n", zoo_member->is_healthy); } void main() { struct animal members[20]; strcpy(members[0].name, "parrot"); members[0].birthday = 20091021; strcpy(members[0].category, "bird"); members[0].food_weight = 20; members[0].is_healthy = 1; print_animal(&members[0]); }
A.2 从结构体到类
结构体简单地将不同类型的几个数据放在一起，使得它们的集合体具有某种特定的意义。与这个结构体相对应的是一些函数操作（上节中只列出了print_animal函数）。
对于这些函数来说，如果没有了结构体变量，它们就无法使用；**对于结构体变量来说，如果没有这些函数，那么结构体也没有任何意义。**对于二者间如此亲密的关系，面向对象的开创者们开创出了类（class）的概念。
类将结构体和它相应的函数集合在一起，成为一种新的数据组织形式。
在这种新的数据组织形式中，有两种成分，
- 一种是来自结构体的数据变量，在类中被称为成员变量；
- 另外一种来自与结构体相对应的函数，被称为一个类的接口：
class animal; string name; int birthday;/*example: 20030910*/ string category;/*example: bird, non_bird*/ int food_weight; int is_healthy; function void print(); $display("My name is %s", name); $display("My birthday is %d", birthday); $display("I am a %s", category); $display("I could eat %d gram food one day", food_weight); $display("My healthy status is %d", is_healthy); endfunction endclass
当一个类被定义好后，需要将其实例化才可以使用。当实例化完成后，可以调用其中的函数：
initial begin animal members[20]; members[0] = new(); members[0].name = "parrot"; members[0].birthday = 20091021; members[0].category = "bird"; members[0].food_weight = 20; members[0].is_healthy = 1; members[0].print(); end
这里使用了new函数。new是一个比较特殊的函数，在类的定义中，没有出现new的定义，但是却可以直接使用它。
在面向对象编程的术语中，new被称为构造函数。
编程语言会默认提供一个构造函数，所以这里可以不定义而直接使用它。
A.3 类的封装
如果只是将结构体和函数集合在一起，那么类的优势并不明显，面向对象编程也不会如此流行。让面向对象编程流程的原因是类还额外具有一些特征。
这些特征是面向对象的精髓。
通常来说，类有三大特征：封装、继承和多态。本节讲述封装。
在上节的例子中，animal中所有的成员变量对于外部来说都是可见的，所以在initial语句中可以直接使用直接引用的方式对其进行赋值。
这种直接引用的方式在某种情况下是危险的。当不小心将它们改变后，那么可能会引起致命的问题，这有点类似于全局变量。
由于对全局是可见的，所以全局变量的值可能被程序的任意部分改变，从而导致一系列的问题。
为了避免这种情况，面向对象的开发者们设计了私有变量（SystemVerilog中为local，其他编程语言各不相同，如private）这一类型。当一个变量被设置为local类型后，那么这个变量就会具有两大特点：
此变量只能在类的内部由类的函数/任务进行访问。
在类外部使用直接引用的方式进行访问会提示出错。
class animal; string name; local int birthday;/*example: 20030910*/ local string category;/*example: bird, non_bird*/ local int food_weight; local int is_healthy; endclass
由于不能进行直接引用式的赋值，所以需要在类内部定义一个初始化函数来对类进行初始化：
function void init(string iname, int ibirthday, string icategory, int ifood _ weight, int iis_healthy); name = iname; birthday = ibirthday; category = icategory; food_weight = ifood_weight; is_healthy = iis_healthy; endfunction
除了成员变量可以被定义为local类型外，函数/任务也可以被定义为local类型。
这种情况通常用于某些底层函数，如animal有函数A，它会调用函数B。
B函数不会也不应被外部调用，这种情况下，就可以将其声明为local类型的：
local function void B(); … endfunction
A.4 类的继承
面向对象编程的第二大特征就是继承。
在一个动物园中，有两种动物，一种是能飞行的鸟类，一种是不能飞行的爬行动物。假设动物园中有100只鸟类、200只爬行动物。
在建立动物园的管理系统时，需要实例化100个animal变量，这100个变量的category都要设置为bird，同时需要实例化200个animal变量，这200个变量的category都要设置为non_bird。
100次或者200次做同样一件事情是比较容易出错的。
考虑到这种情况，面向对象编程的开创者们提出了继承的概念。分析所要解决的问题，并找出其中的共性，用这些共性构建一个基类（或者父类）；
在此基础上，将问题分类，不同的分类具有各自的共性，使用这些分类的共性构建一个派生类（或者子类）。
一个动物园中所有的动物都可以抽像成上节所示的animal类，在animal类的基础上，派生（继承）出bird类和non_bird类：
class bird extends animal; function new(); super.new(); category = "bird"; endfunction endclass class non_bird extends animal; function new(); super.new(); category = "non_bird"; endfunction endclass
当子类从父类派生后，子类天然地具有了父类所有的特征，父类的成员变量也是子类的成员变量，父类的成员函数同时也是子类的成员函数。
除了具有父类所有的特征外，子类还可以有自己额外的成员变量和成员函数，如对于bird类，可以定义自己的fly函数：
class bird extends animal; function void fly(); … endfunction endclass
在上一节中讲述封装时，提到了local类型成员变量。如果一个变量是local类型的，那么它是不能被外部直接访问的。
如果父类中某成员变量是local类型，那么子类是否可以使用这些变量？
答案是否定的。对于父类来说，子类算是“外人”，只是算是比较特殊的“外人”而已。
如果想访问父类中的成员变量，同时又不想让这些成员变量被外部访问，那么可以将这些变量声明为protected类型：
class animal; string name; protected int birthday;/*example: 20030910*/ protected string category;/*example: bird, non_bird*/ protected int food_weight; protected int is_healthy; endclass
与local类似，protected关键字同样可以应用于函数/任务中，这里不再举例。
A.5 类的多态
多态是面向对象编程中最神奇的一个特征，但是同时也是最难理解的一个特征。对于初学者来说，可以暂且跳过本节。
当对SystemVerilog有一定使用经验时再过来看本节，效果会更好。
假设在animal中有函数print_homehown：
class animal; function void print_hometown(); $display("my hometown is on the earth!"); endfunction endclass
同时，在bird和non_bird类中也有自己的print_hometown函数：
class bird extends animal; function void print_hometown(); $display("my hometown is in sky!"); endfunction endclass class non_bird extends animal; function void print_hometown(); $display("my hometown is on the land!"); endfunction endclass
现在，有一个名字为print_animal的函数：
print_animal的参数是一个animal类型的指针，如果实例化了一个bird，并且将其传递给print_animal函数，这样做是完全允许的，因为bird是从animal派生的，所以bird本质上是个animal：
initial begin bird members[20]; members[0] = new(); members[0].init("parrot", 20091021, "bird", 20, 1); print_animal(members[0]); end
只是，这样打印出来的结果是“my hometown is on the earth！”，而期望的结果是“my hometown is in sky!”。如果要想得到正确的结果，那么在print_animal函数中调用print_ hometown之前要进行类型转换：
function automatic void print_animal2(animal p_animal); bird p_bird; non_bird p_nbird; p_animal.print(); if($cast(p_bird, p_animal)) p_bird.print_hometown(); else if($cast(p_nbird, p_animal)) p_nbird.print_hometown(); endfunction
如果将members[0]作为参数传递给此函数，那么可以得到期待的结果。cast是一个类型转换函数。
从animal向bird或者non_bird类型的转换是父类向子类的类型转换，这种类型转换必须通过cast来完成。
但是反过来，子类向父类的类型转换可以由系统自动完成，如调用print_animal时，members[0]是bird类型的，系统自动将其转换成animal类型。
但是print_animal2的作法显得非常复杂，并且代码的可重用性不高。
现在只有bird和non_bird类型，如果再多加一种类型，那么就需要重新修改这个函数。
在调用print_animal和print_animal2时，传递给它们的members[0]本身是bird类型的，那么有没有一种方法可以自动调用bird的print_hometown函数呢？
这个问题的答案就是虚函数。
在animal、bird、non_bird中分别定义print_hometown2函数，只是在定义时其前面要加上virtual关键字：
class animal; virtual function void print_hometown2(); $display("my hometown is on the earth!"); endfunction endclass class bird extends animal; virtual function void print_hometown2(); $display("my hometown is in sky!"); endfunction endclass class non_bird extends animal; virtual function void print_hometown2(); $display("my hometown is on the land!"); endfunction endclass
在print_animal3中调用此函数：
function automatic void print_animal3(animal p_animal); p_animal.print(); p_animal.print_hometown2(); endfunction
在initial语句中将members[0]传递给此函数后，打印出的结果就是“my hometown is insky!”，这正是想要的结果。如果在initial中实例化了一个non_bird，并将其传递给print_animal3：
initial begin non_bird members[20]; members[0] = new(); members[0].init("tiger", 20091101, "non_bird", 2000, 1); print_animal(members[0]); end
那么打印出的结果就是“my hometown is on the land!”。在print_animal3中，同样都是调用print_hometown2函数，但是输出的结果却不同，表现出不同的形态，这就是多态。
多态的实现要依赖于虚函数，普通的函数，如print_hometown是不能实现多态的。
A.6 randomize与constraint
SystemVerilog是一门用于验证的语言。验证中，很重要的一条是能够产生一些随机的激励。为此，SystemVerilog为所有的类定义了randomize方法：
class animal; bit [10:0] kind; rand bit[5:0] data; rand int addr; endclass initial begin animal aml; aml = new(); assert(aml.randomize()); end
在一个类中只有定义为rand类型的字段才会在调用randomize方法时进行随机化。上面的定义中，data和addr会随机化为一个随机值，而kind在randomize被调用后，依然是默认值0。
与randomize对应的是constraint。constraint是SystemVerilog中非常有特色也是非常有用的一个功能。在不加任何约束的情况下，上述animal中的data经过随机化后，其值为0～’h3F中的任一值。可以定义一个constraint对其值进行约束：
class animal; rand bit[5:0] data; constraint data_cons{ data > 10; data < 30; } endclass
经过上述约束后，data在随机时，其值将会介于10～30之间。
除了在类的定义时对数据进行约束外，还可以在调用randomize时对数据进行约束：
initial begin animal aml; aml = new(); assert(aml.randomize() with {data > 10; data < 30;}); end
