Map One Bug Finder Checker to Coding Rule

If your coding rule has a narrow scope, it is possible that you can map a single Bug Finder checker to the coding rule. Consider the C++ Core Guideline C.4[1]: Make a function a member only if it needs direct access to the representation of a class. This rule is specific and the C++ Core Guidelines clearly define when the rule is violated — this rule is violated when you have a class with a non-virtual member function that does not modify any of the class data members. Conversely, if a non-virtual class member function modifies a data member, the rule is not violated. To find a Bug Finder checker that you can map to the guideline, create a specification file. The specification file contains:

This example specification file contains four noncompliant member functions, two examples of compliant member function, and an operator that is compliant by exception.

 Example Specification for C++ Core Guideline C.4

#include <iostream>

class Rectangle {
private:
	double width;
	double height;

public:
	Rectangle(double width, double height) : width(width), height(height) {}


	void printDetails() { //Noncompliant
		std::cout << "Width: " << width << ", Height: " << height << std::endl;
	}

	void setWidth(double newWidth) { //Compliant
		width = newWidth;
	}
	void setHeight(double newHeight) {//Compliant
		height = newHeight;
	}


	double *getDimensions() { //Noncompliant
		static double dimensions[2] = {width, height};
		return dimensions;
	}


	double area()  { //Noncompliant
		return width * height;
	}



	bool isEqualTo(const Rectangle &other) { //Noncompliant
		return width == other.width && height == other.height;
	}

	//
	Rectangle operator+(const Rectangle &other) { // Compliant by exception
                                                    // operator must be member
		return Rectangle(width + other.width, height + other.height);
	}
};

To find a mapping for C++ Core Guideline C.4, run a Polyspace Bug Finder analysis on the specification. Enable C++ coding rules such as the AUTOSAR C++14 and MISRA C++:2023 coding rules. After the analysis completes, review the results. To reduce the number of results you review, limit the review to coding rules related to class design that show four or fewer violations. The results show only one coding rule related to class design with four or fewer violations — AUTOSAR C++14 Rule M9-3-3. A review of the implementation of this rule checker reveals that AUTOSAR C++14 Rule M9-3-3 reports violations on non-const and non-static class member functions that do not access or modify any data members. You can map this checker to C++ Core Guideline C.4..

Map Multiple Bug Finder Checkers to Coding Rule

Some coding rules are broad and can require multiple checkers to cover the different kinds of violations. Consider the C++ Core Guideline C.22: Make default operations consistent[2]. The guideline covers many different inconsistencies in default operations. To make this guideline enforceable by Bug Finder, specify the inconsistencies in default operations that you want to detect. Consider these inconsistencies:

Create specification files for these three issues and run Bug Finder on these specification files.

 Move and copy constructors have side effects

// Move constructor has side effects
#include<utility>
#include<string>
#include <iostream>
class B
{
public:
	// Implementation
	B(B &&oth) : str(std::move(oth.str)) {  //Compliant

	}

private:
	std::string str;
};

class BB
{
public:
	// Implementation
	BB(BB &&oth) : str(std::move(oth.str)) { //Noncompliant
		std::cout << "Moved";
	}

private:
	std::string str;
};

 Move constructors fail to move

//Move constructor does not move
#include<utility>
#include<string>
class B
{
public:
	// Implementation
	B(B &&oth) : str(std::move(oth.str)) {  //Compliant

	}

private:
	std::string str;
};

class BB
{
public:
	// Implementation
	BB(BB &&oth) : str((oth.str)) { //Noncompliant

	}

private:
	std::string str;
};

 Constructor does not correctly initialize data members and base classes

//Constructor does not initializae appropriately
class A {  
public:  
	A() : a{1} {}  
	virtual void abstractA() const = 0;  
private:  
	int a;  
};  

class B : public  A {  
public:  
	B() : b{1} {} //Noncompliant 
	void abstractA() const override {}  
private:  
	int b;  
};

class BB : public  A {  
public:  
	BB() : A(), b{1} {} //Compliant 
	void abstractA() const override {}  
private:  
	int b;  
}; 

A review of the results show that these Bug Finder checkers each report violations on one of the issues:

To detect violations of the C++ Core Guideline C.22, these checkers are required.