SV之OOP基础知识

对象声明与传递

Transaction t1 t2 ;
t1= new();
t2=t1;
t1=new();

声明句柄：申明指向某一对象的句柄t1，t2中。
创建对象：构造函数new为对象分配空间，并将其地址保存在t1这个句柄中。
传递对象：将t1句柄的对象也传给t2，这时，t1和t2指向同一对象。
创建新对象：这时t1指向新对象，t2仍指向旧对象。

专用术语

OOP中的变量称为属性property
OOP中的task或function 称为方法method
子程序的原型prototype是指明了参数列表和返回类型（如果存在的话）的第一行

数据类型

在SV中，类可以定义在program, module, package中，但是一般一个类或几个相关的类会单独写在一个文件中。最终在program中调用。
而且在SV中，所有成员 默认都是public类型的，除非显示的用local/protected来声明。实际上，SV class中的变量应该尽可能的用public并且rand，来增加可控性。
local/protected都可以针对property和method来说明，local表示member只对该class的对象可见，extend出的subclass也是不可见的。 但是该class中non-local的method调用了local的method或者property，inherit之后的method也是可以正常执行的。
protected表示member对该class和它的subclass都是可以见的。 对外部的大环境不可见。

---

静态变量

一个类中的静态变量，可以被这个类的所有实例共享，并且其使用范围仅限于这个类。

• 与动态变量的区别：动态变量中的每个变量都只能被这个类的具体某一对象使用。在其他同类型对象中不能使用。也可被称为局部变量。
• 与全局变量的区别：全局变量对于整个测试平台而言，都是可访问的。不管是其他类型的类，还是其他程序块。
• 调用： 使用.或者：：（即类作用域操作符）

静态方法

静态方法是用于对静态变量的操作的吧(猜)。
即使类是没有任意示例，也可以直接调用静态方法。

---

类中方法/类、子程序中 类 的定义

• 类中的方法：即task和function默认是采用自动存储的，即automatic类型，所以，不用担心忘记使用automatic修饰符。
• 在一个类A中调用类B的时候，注意一定要实例化类B，这一实例化的过程常在类A的构造函数（即new函数）中完成。
• 在一个字程序C中对类D进行修改（成员变量的修改）时
  
  • 如果希望自己的修改结果被C以后其他地方看到，那么，在定义C的时候，我们需要要参数D的使用定义为ref型
  • 如果不希望自己的修改结果被其他地方看到，这就需要对类D的对象简单的做一个copy。

存储方式——静态存储与动态存储

静态存储：相当于任务中的所有局部 变量都变成了 “静态变量”，
因为这时，如果在测试程序中的多个地方调用了同一个任务，局部变量会窜用共享的静态存储区，
所以不同的线程中会串用这些局部变量，某种意义上局部变量就变成了”静态变量“。
可以指定任务、函数、模块使用自动存储，迫使仿真器使用堆栈区存储局部变量。（即使用automatic）
SV中，module 和program 块默认是使用静态存储，刚好与类相反，类中存储方式默认为automatic 方式。
这也体现了类就是为了复用的目的而使用的封装方法。而module和program多不是为了复用的目的，如果需要的话，比如program中有多线程，多线程中共享变量的时候，这时就要加上automatic，使得变量入堆栈，而不冲突。

虚方法

类中的函数被标记为virtual型， 这样就可以在需要的时候（大多是继承时）重新定义了。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

多态的通俗解释1

**C++中的虚函数的作用主要是实现了多态的机制。
关于多态，简而言之就是用父类型别的指针指向其子类的实例，
然后通过父类的指针调用实际子类的成员函数。
这种技术可以让父类的指针有“多种形态”，**

多态的通俗解释2

前几天在网上看到这样的一个问题：
多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。但我搞不懂为什么要那么做，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不就行了么？
然后有人这样回答：
将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但是也各不相同。如果我在写驱动的时候，我用个父类表示外设接口，然后在子类中重写父类那个读取设备的虚函数，那这样电脑的外设接口只需要一个。但如果我不是这样做，而是用每个子类表示一个外设接口，那么我的电脑就必须有3个接口分别来读取移动硬盘、U盘以及MP3。若以后我还有SD卡读卡器，那我岂不是要将电脑拆了，焊个SD卡读卡器的接口上去？

多态的实现方法

实现多态，有二种方式，覆盖，重载。
- 列表内容
- 覆盖，是指子类重新定义父类的虚函数的做法。
- 重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
　　重载：编译期确定　　 多态：运行期才确定（晚绑定）

蓝图模式

所谓蓝图模式，起始就是将发生器分为 产生器和驱动器。（也可以理解为sequencer和driver了）。
这样的话。我们写好驱动部分就不用动了。再次修改时，只需要修改产生的trans就好

BluePrint pattern：
        其实是类的继承在可重用验证环境中的一种典型用法。
        以Transaction为例，定义一个Transaction的基类，然后再定义一个Transaction的扩展类，
        然后在顶层Test中，指定Generator需要哪一个Transaction。
        其实和UVM中的sequencer调用sequence如出一辙。

class Environment;
         Generator gen;
            Driver drv;
       mailbox gen2drv;
      function void build;      //new函数的构建，mailbox, drv, gen
             task  run();
             task  wrap_up() ; 
    endclass
---------------------------------------------
 class Generator;                                                                         
            mailbox gen2drv;                                                               
            Transaction tr;                                                                
            function new (input mailbox gen2drv)                                           
                                  this.gen2drv = gen2drv;                                  
                                  tr = new();                                              
            endfunction                                                                    
            task run;                                                                      
                     Transaction tr1;
                     forever begin
                                    assert(tr.randomize() );
                                    tr1 = tr.copy();       //copy一份到driver
                                    gen2drv.put (tr1);
                                end
             endtask
 endclass
----------------------------------------------------- 
     program  automatic test;
                       Environment  env;
                           initial begin
                                       env = new();
                                       env.build();        //new函数
                                           begin
                                               BadTr bad = new();
                                               env.gen.tr = bad; //通过类的顶层关系来调用，Transaction的替换。
                                           end
                                       env.run();
                                       env.wrap_up();
                                    end
               endprogram