SystemVerilog class model and visibilityKnow what the handle actually owns.
Start with the SystemVerilog object model, the four OOP ideas, and the visibility rules that keep verification classes reusable without exposing mutable internals.
Encapsulation boundaryVisibility follows the caller
unqualifiedclasschildoutside
protectedclasschildoutside
localclasschildoutside
The class is one type definition. Each new allocation creates a distinct object, while handle assignment can make multiple names refer to the same object.
Strong answer
A class is a type definition. An object is one allocated instance of that class. A class variable stores a handle that is either null or refers to an object; the handle is not the object itself.
Reason it through
Declaring Packet p creates a handle initialized to null. Executing p = new allocates a Packet object and places its handle in p.
Two different calls to new create two independent objects. Assigning one handle to another creates an alias to the same object.
Methods execute against the object reached through the handle, so a null-handle dereference is a runtime error.
Type, allocation, and aliasingsystemverilog
class Packet;
int id;
endclass
Packet p; // null handle
Packet alias_p;
p = new; // allocate one Packet object
p.id = 7;
alias_p = p; // same object, second handle
alias_p.id = 9; // p.id is now 9
Strong answer
Encapsulation controls access to state, abstraction exposes the behavior callers need, inheritance extends an existing type, and polymorphism lets one base-typed call select behavior from the actual derived object.
Reason it through
Encapsulation is the boundary around representation and invariants; visibility qualifiers are one implementation tool.
Abstraction is about the public contract. A virtual class or pure virtual method can make that contract explicit.
SystemVerilog supports single class inheritance through extends. Polymorphism depends on virtual methods, not inheritance alone.
Four object-oriented programming principles
Principle
Question it answers
SystemVerilog mechanism
PrincipleEncapsulation
Question it answersWho may touch this state?
SystemVerilog mechanismpublic, protected, local
PrincipleAbstraction
Question it answersWhat behavior is promised?
SystemVerilog mechanismbase API, virtual class
PrincipleInheritance
Question it answersWhat definition is extended?
SystemVerilog mechanismextends and super
PrinciplePolymorphism
Question it answersWhich implementation runs?
SystemVerilog mechanismvirtual method dispatch
Strong answer
Public members are visible wherever the object is visible. Protected members are visible inside the declaring class and its derived classes. Local members are visible only inside the declaring class.
Reason it through
Public access is the default when no visibility qualifier is written; ordinary public members are left unqualified in SystemVerilog source.
SystemVerilog uses local for the private-style visibility level; private is not the class-member keyword.
Prefer protected state when derived verification classes need controlled access, and public methods when outside callers need a stable interface.
Visibility from a derived classsystemverilog
class Base;
int visible_everywhere; // public by defaultprotectedint visible_to_children;
localint visible_only_here;
endclassclass Child extends Base;
functionvoid configure();
visible_everywhere = 1; // legal
visible_to_children = 2; // legal// visible_only_here = 3; // illegalendfunctionendclass
Strong answer
No. A class cannot declare multiple methods with the same name and different argument lists the way C++ or Java can. Use distinct names, default arguments, or a typed wrapper instead.
Reason it through
Overloading chooses among same-named signatures at compile time. That language feature is not available for SystemVerilog class methods.
Overriding is different: a derived class supplies the same signature as a virtual base method.
Default arguments can cover closely related call forms when one return type and one implementation are appropriate.
Use explicit names instead of overloadssystemverilog
class MathOps;
functionint add_int(int a, int b);
return a + b;
endfunctionfunction real add_real(real a, real b);
return a + b;
endfunctionendclass
Strong answer
A method boundary lets the class preserve invariants, validate updates, and change its representation without forcing every caller to change.
Reason it through
A setter can reject an illegal value or update related fields atomically.
A getter can expose a stable view without giving an outside component permission to corrupt internal state.
In a verification environment, a scoreboard should observe driver state through a deliberate interface rather than mutate the driver's internals.
SystemVerilog construction and specializationInitialize the hierarchy in order.
Reason about new(), base-constructor chaining, this and super, parameterized class types, and state shared at class scope.
Concept model
Construction flows from base state to specialization
A derived constructor establishes inherited state before its own fields. Value and type parameters specialize the class at compile time rather than at object creation.
Strong answer
new allocates an object and runs that class's constructor function to establish valid initial state. The constructor may accept arguments and assign instance properties, but it cannot consume simulation time.
Reason it through
The constructor is declared as function new with no explicit return type.
Use this.member when a formal argument has the same name as a property.
Default property initialization happens before constructor statements execute.
Construct a valid packetsystemverilog
class Packet;
int id;
string kind;
functionnew(int id = 0, string kind = "READ");
this.id = id;
this.kind = kind;
endfunctionendclass
Packet p = new(7, "WRITE");
Strong answer
The base constructor always runs before the derived constructor body. If the base constructor needs arguments, the derived constructor must call super.new(...) as its first executable statement.
Reason it through
When the base constructor has no required arguments, the compiler can insert an implicit super.new call.
Explicitly calling super.new makes required base-state initialization visible in review.
Construction proceeds from the oldest base class toward the most-derived class.
this is the handle to the current object. super is a lexical keyword that selects the immediate base-class implementation or constructor; it is not a handle that can be stored.
Reason it through
Use this.field to disambiguate an instance property from a same-named argument.
Use super.method() to call the immediate base implementation from an override.
Use super.new(...) only in a constructor and with the arguments required by the immediate base.
Strong answer
A parameterized class is a family of class types. Value parameters control constants such as width, while type parameters substitute a data type; each distinct parameter tuple is a distinct specialized type.
Reason it through
Defaults let callers use Packet #() while named overrides document specializations clearly.
Fields and method signatures can derive from both the value and type parameters. If T is declared rand, callers must choose a type the randomization model supports.
Parameter selection happens in the type declaration, not as arguments to new.
Specialize width and identifier typesystemverilog
class Packet #(
parameterint WIDTH = 32,
type T = int
);
randbit [WIDTH-1:0] data;
T id;
endclass
Packet #() default_packet = new;
Packet #(.WIDTH(64), .T(bit [15:0])) wide_packet = new;
Strong answer
A static property has one value shared by every object of that class type. A static method belongs to class scope, cannot use per-object state without an explicit handle, and is normally called with ClassName::method().
Reason it through
Use a static counter for type-wide statistics, instance numbering, registries, or one shared service handle.
The class-scope operator makes the owning type explicit and does not require an object.
A derived class that declares a same-named static member creates a separate hidden member; it does not override the base static.
Track allocations at class scopesystemverilog
class Counter;
staticint total = 0;
int serial;
functionnew();
total++;
serial = total;
endfunctionstaticfunctionint get_total();
return total;
endfunctionendclassint count = Counter::get_total();
