C and C++


LANG.FUNCS.COPINC : Copy Operation Parameter Is Not const

Summary

A copy constructor or copy assignment operator has a non-const parameter.

A warning of this class is issued for a constructor or overloaded assignment operator if all of the following are true.

Warnings of this class are not issued if the copy-constructed or copy-assigned object is of a std type. Types such as std::shared_ptr<> require a reference counter to be incremented each time a copy is made, so cannot be const parameters in these contexts.

Properties

Class Name Copy Operation Parameter Is Not const
Significance style
Mnemonic LANG.FUNCS.COPINC
Categories
AUTOSARC++14 AUTOSARC++14:A12-8-1 Move and copy constructors shall move and respectively copy base classes and data members of a class, without any side effects.
MisraC++2008 MisraC++2008:12-8-1 A copy constructor shall only initialize its base classes and the non- static members of the class of which it is a member.
CERT-CPP CERT-CPP:OOP58-CPP Copy operations must not mutate the source object
JSF++ JSF++:117.1 An object should be passed as const T& if the function should not change the value of the object.
Availability Available for C++ only (not C).
Enabling Checks for this warning class are disabled by default. To enable them, add the following WARNING_FILTER rule to the project configuration file.
WARNING_FILTER += allow class="Copy Operation Parameter Is Not const"

Example

#include <utility>
#include <memory>

namespace lang_funcs_copinc_OK
{
    struct S {
        S();
        S( const S & s ) {}                                              // ok: const argument                        
        S& operator=( const S & s ) { return *this; }                    // ok: const argument
        S(  S && s ) {}                                                  // ok: rvalue reference argument (move constructor)
        int sf;
    };

    void test() {
        S s;
        S sc(s);
        S sm = std::move(s);
        sc = s;
        std::shared_ptr<S> p = std::make_shared<S>();                    // ok: copy-assigning to std::shared_ptr<>     
        std::shared_ptr<S> p2(p);                                        // ok: copy-constructing std::shared_ptr<>     
    }
}

namespace lang_funcs_copinc_WARNINGS
{
    struct S {
        S();
        S( S & s ) {}                                 // 'Copy Operation Parameter Is Not const' warning issued here
        S& operator=( S & s ) { return *this; }       // 'Copy Operation Parameter Is Not const' warning issued here
        int sf;
    };

    void test() {
        S s;
        S sc(s);
        sc = s;
    }
}

Relevant Configuration File Parameters

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