面向对象概念整理

sv是面向对象语言，面向对象的三大基本特征：封装、继承和多态。

面向过程：关注处理的流程、逻辑问题，不关心对象主体。分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用。把任务交给A来做，A先完成第一个任务，再完成第二个，依次完成最后一个。优点是性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源

面向对象：对象包括属性和方法。属性属于对象静态的一面，方法属于对象动态的一面。类是具有相同属性的对象的集合。物以类聚，人以群分。对象是类的元素。类可以声明对象并实例化。优点是易维护，易复用，易扩展。由于面向对象由封装，继承，多态性的特性，可以设计出耦合度低的系统，使系统更加灵活，更加易于维护。 缺点是性能比面向过程低。

面向对象是将构成问题的事物，分解成若干个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在解决问题过程中的行为。实际编程过程中在实现一个模块的时候不都是，先拆分流程化使得编程任务明确，然后在逐一实现具体的吗？如何理解上述语句。面向对象在处理时将问题分解，把属性、行为抽象成类，类创建的对象具有解决某个子问题的功能。通过不同对象的调用，解决组合问题。不同对象的方法在调用时有顺序之分。有些类似面向过程。类似于并行，把不同的任务交个A、B、C三个不同的对象来做，不同对象之间需要互相调用。A的输出作为B的输入，B可以调用A，把A的返回值作为输入。

封装：隐藏对象的属性和实现细节，仅对外公开接口，将抽象得到的数据和行为，即数据和操作数据的源代码进行有机结合，形成类。其中数据和函数都是类的成员。封装可以增强安全和简化编程。

继承：子类继承父类的特征和行为，使得子类对象具有父类的属性和方法。

多态：是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。

当在父类定义一个函数或任务时，如果将其设置为virtual类型，则可以在子类中重载这个函数或任务。重载最大的优势是使得子类的一个指针以父类的类型传递时，表现出的依然是子类的行为。不同的子类重载方法表现不同，结果不同，则呈现多态。

隐式转换：从存储范围小的类型到存储范围大的类型。也称自动类型转换，是指不需要书写代码，由系统自动完成的类型转换。由俭入奢易，由奢入俭难。如数据类型由byte类型的转换为short继而int、long、float、double，其占用长度、表示精度更高，这样转换时出现数据错误的可能性第低，但也不是完全没有。在整数之间进行类型转换时，数值不发生改变，而将整数类型，特别是比较大的整数类型转换成小数类型时，由于存储方式不同，有可能存在数据精度的损失；对象类型中，父类的条件少，范围大，子类的条件多，包括范围小。如父类是bird，子类是parrot。是parrot则一定是bird，是bird不一定是parrot。因此将子类实例赋值给一个父类变量是默认允许的。在本例中，28行的print_hungry参数是parrot_inst，是parrot类实例化的对象。但在17行定义的function：print_hungry（bird b_ptr），其类型为bird类型。因此会发生parrot类被隐式转换成bird类型。但定义的virtual类型的方法，虽然指针类型以父类传递，但表现出子类的行为。 因为子类向父类转换的存在，相同类型的引用变量（指以父类指针传递），其实际类型可能不同，执行方法的时候结果就可能不同，这就是多态的一种表现。

显式类型转换：也称强制类型转换，是指必须书写代码才能完成的类型转换。该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。

1 class bird extends uvm_object;
2    virtual function void hungry();
3        $display("I am a bird, I am hungry");
4    endfunction
5    function void hungry2();
6        $display("I am a bird, I am hungry2");
7    endfunction

8 endclass

9 class parrot extends bird;

10   virtual function void hungry();
11         $display("I am a parrot, I am hungry");

12     endfunction
13    function void hungry2();
14        $display("I am a parrot, I am hungry2");
15     endfunction

16 endclass

17 function void my_case0::print_hungry(bird b_ptr);
18    b_ptr.hungry();
19    b_ptr.hungry2();
20 endfunction

21 function void my_case0::build_phase(uvm_phase phase);
22    bird bird_inst;
23    parrot parrot_inst;
 
24    super.build_phase(phase);

25    bird_inst = bird::type_id::create("bird_inst");
26    parrot_inst = parrot::type_id::create("parrot_inst");
27    print_hungry(bird_inst);
28    print_hungry(parrot_inst);
29 endfunction

bird类中定义了两个function，其中一个是virtual类型的hungry，一个不是virtual类型的hungry2。parrot类派生自bird，重写两个function。17行定义的print_hungry函数会调用b_ptr.hungry（）和b_ptr.hungry2（）。27行在执行print_hungry(bird_inst)函数时，参数bird_inst是bird类实例化的，此函数指向的实例是bird类型的。因此会执行bird类里的hungry( )和hungry2（），打印结果是

I am a bird, I am hungry
I am a bird, I am hungry2

28行在执行print_hungry函数时，其参数是parrot_inst，则在执行18行的b_ptr.hungry函数时，其指针类型是parrot类，虽然是parrot类，但被隐式地转换成了bird类型。而hungry函数是virtual类型，虽然被转换成bird类型，但表现的行为是子类的行为，即打印的是

I am a parrot, I am hungry

 而hungry2不是virtual类型，表现的行为是父类的行为，打印结果是 

I am a bird, I am hungry2

利用重载功能可以方便的添加异常测试用例，通过对约束重载的方式。如item中的某些数据出现某个值的概率很低，在正常用例里对item约束不出现此值即可，而在异常用例里，可声明新item类派生自原item，并对约束改写，类似上述parrot类中对hungry函数的改写。

在item文件中正常约束。

    class my_transaction extends uvm_sequence_item;

17     constraint crc_err_cons{
18     crc_err == 1'b0;
19     }
20     constraint sfd_err_cons{
21     sfd_err == 1'b0;
22     }
23     constraint pre_err_cons{
24     pre_err == 1'b0;
25     }

55  endclass

   

 在case中对item进行重载，并对其进行随机化。

class new_transaction extends my_transaction;

5     `uvm_object_utils(new_transaction)
6     function new(string name= "new_transaction");
7         super.new(name);

8     endfunction
9
10     constraint crc_err_cons{
11     crc_err dist {0 := 2, 1 := 1};
12     }

13 endclass

    virtual task body();

23     new_transaction ntr;

26     repeat (10) begin
27         `uvm_do(ntr)
28         ntr.print();
29     end
…
33 endtask

上述讲了方法重载、对约束重载的应用、另外还有部分重载，连续重载、替换重载等。

 本文章参考《UVM实战》、《芯片验证漫游指南》等资料整理而成，仅作学习心得交流，如果涉及侵权烦请请告知，我将第一时间处理。