MISRA C++:2023 Rule 13.3.2

Parameters in an overriding virtual function shall not specify different default arguments

Since R2024b

Description

Parameters in an overriding virtual function shall not specify different default arguments. ¹

Rationale

If the default parameter of a virtual function is different in an overriding function, then the function call uses different values when invoked using different classes of a hierarchy. Such behavior is unexpected for a class hierarchy. Consider this class hierarchy:

class Base{
public:
   virtual foo(int x = 0);
   //...
};

class Derived: public Base{
public:
   virtual foo(int x = 1) override; //Noncompliant

};

The virtual function foo() has different default parameters depending on whether base::foo() or Derived::foo() is invoked. This behavior is unexpected and can result in unexpected results.

Polyspace Implementation

Polyspace^® reports a violation of this rule if an overriding virtual function has a different default parameter compared to the virtual function it overrides. This includes situations where the overriding virtual function has a default parameter, but the base virtual function does not have a default parameter. Polyspace does not report violations when overriding virtual functions specify no default parameters.

Troubleshooting

If you expect a rule violation but Polyspace does not report it, see Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Avoid Specifying Different Default Parameter for Overriding Virtual Functions

In this example, the overriding virtual function myDerivedClass<T>::function() overrides myClass<T>::function() but has a different default parameter. Polyspace reports a violation of this rule.

template  <class T>
class myClass{
public:
   virtual myClass<T> function(int val = 0);

};

template<class T>
class myDerivedClass: public myClass<T>{
public:
   virtual myClass<T> function(int val = 10) override; //Noncompliant
	
};

void func(){
   myClass<int> a;
   myDerivedClass<float> b;
}

Check Information

Group: Derived Classes

Category: Required

PQL Name: std.misra_cpp_2023.R13_3_2

Version History

Introduced in R2024b

R2026a: Improved accuracy across compilers

The rule checker no longer incorrectly flags violations on overriding virtual functions when using certain compilers such as GCC, Clang, and Visual Studio^®.

R2025a: Violation not reported if overriding virtual function has the same constant string parameter

If an overriding virtual function has the same constant string parameter as the base virtual function, Polyspace no longer reports a violation. For example, no violations are reported for this class hierarchy:

class Base {
public:
	virtual bool checkTypeData(const char *theData = "");
};

class Derived : public Base {
public:
	bool checkTypeData(const char *theData = "") override;
};