C and C++


LANG.TYPE.MUDO : Missing User-defined Operations

Summary

A class C for which one or both of the following are true.

This warning class is based on the C++ Rule of Five / Rule of Three. The Rule of Five operations are:

Note: rvalue references were added in C++11. However, certain compilers may have added support for rvalue references earlier (or later).

Properties

Class Name Missing User-defined Operations
Significance style
Mnemonic LANG.TYPE.MUDO
Categories
AUTOSARC++14 AUTOSARC++14:A12-0-1 If a class declares a copy or move operation, or a destructor, either via "=default", "=delete", or via a user-provided declaration, then all others of these five special member functions shall be declared as well.
CWE CWE:1076 Insufficient Adherence to Expected Conventions
JSF++ JSF++:68 Unneeded implicitly generated member functions shall be explicitly disallowed.
  JSF++:76 A copy constructor and an assignment operator shall be declared for classes that contain pointers to data items or nontrivial destructors.
  JSF++:80 The default copy and assignment operators will be used for classes when those operators offer reasonable semantics.
Availability Available for C++ only (not C).
Enabling Checks for this warning class are disabled by default, and require the unnormalized C ASTs for the project. To enable them, add the following WARNING_FILTER rule and RETAIN_UNNORMALIZED_C_AST specification to the project configuration file.
RETAIN_UNNORMALIZED_C_AST = Yes
WARNING_FILTER += allow class="Missing User-defined Operations"
Note that retaining the unnormalized ASTs will increase the disk space used to store the project representation, and may make the analysis take longer.

Example

class Some {           // 'Missing User-defined Operation' warning issued here
                       // - class has user declarations for some, but not all, of the
                       //   'Rule of Five' operations
  public:
    Some(Some &x);                // Copy constructor
    Some(Some &&x);               // Move constructor
    // No destructor, copy assignment, or move assignment declared
};

class All  {                      // ok: all 'Rule of Five' operations are declared
  public:
    ~All();                       // Destructor
    All(All & other);             // Copy constructor
    All(All && other);            // Move constructor
    All& operator=(All & other);  // Copy assignment
    All& operator=(All && other); // Move assignment
};

class PointerWrapper { // 'Missing User-defined Operation' warning issued here
                       // - class has pointer-typed member data but does not declare the
                       //   'Rule of Five' operations
  private:
    int *myptr;
};

class IntWrapper {                // ok: class does not declare any 'Rule of Five' operations,
                                  // and does not have any pointer-typed member data.
  private:
    int myval;
};

Relevant Configuration File Parameters

The following configuration file parameters affect checks for this warning class.