AUTOSAR C++14 Rule A20-8-6

std::make_shared shall be used to construct objects owned by std::shared_ptr

Description

Rule Definition

std::make_shared shall be used to construct objects owned by std::shared_ptr.

Rationale

Create a std::shared_ptr object directly by using the std::make_shared function:

auto numberPtr = std::make_shared<numberClass>(aNumber);

Avoid creating std::shared_ptr objects by converting raw pointers to dynamic memory:

class numberClass {
   public:
     numberClass(int n): number(n){}
   private: 
     int number;
}
int aNumber=1; 
std::shared_ptr<numberClass> numberPtr (new numberClass(aNumber)); 

Using std::make_shared is preferred because:

• The creation of the std::shared_ptr object is performed in a single dynamic memory allocation and improves run-time performance. Otherwise, creating a raw pointer by using the new operator requires one dynamic memory allocation and converting the raw pointer to an std::shared_ptr object requires a second allocation. The second allocation creates a control block that keeps track of the reference count of the shared resource and makes the std::shared_ptr object aware of all pointers to the shared resource.

• The creation of the std::shared_ptr object using std::make_shared is exception-safe. Otherwise, an exception can occur between the dynamic memory allocation with the new operator and the subsequent conversion, leading to a memory leak. An exception causes a memory leak only in certain contexts, for instance, when the std::shared_ptr object is created in an argument of a multi-parameter function and another function argument evaluation throws an exception.

• You can use a more concise syntax. You do not have to repeat the data type of the object that is dynamically allocated.

Polyspace Implementation

The checker flags the creation of an std::shared_ptr object (or boost::shared_ptr object) from the raw pointer returned by the new operator.

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

std::shared_ptr Created Separately from Dynamic Memory Allocation

#include<memory>
#include <cstdint>
#include <string>

class Record {
public:
	Record() = default;
	Record(std::string aName, std::string someInfo): name(aName), info(someInfo){       
	}
private:
	std::string name;
	std::string info;
};

void addRecordToDataBase(std::shared_ptr<Record> aRecord, bool dataBaseIsFull);
bool checkDataBase(void); //Checks if database can accept more entries

void createRecord() {
	std::shared_ptr<Record> recordPtr1 (new Record("John", "Mechanic, New York")); //Noncompliant
	auto recordPtr2 = std::make_shared<Record>("Tom", "Plumber, Boston"); //Compliant
	//...
	addRecordToDataBase(std::shared_ptr<Record>(new Record("John", "Mechanic, New York")), checkDataBase()); //Noncompliant
	addRecordToDataBase(std::make_shared<Record>("Tom", "Plumber, Boston"), checkDataBase()); //Compliant
	//...
}

std::shared_ptr<Record> getSP(void) {
	std::shared_ptr<Record> result{std::make_shared<Record>()};//Compliant 
	return result;                                                      
}

In this example, the rule is violated whenever the new operator returns a raw pointer and a subsequent conversion creates an std::shared_ptr object from the raw pointer.

In the first call to addRecordToDatabase, the following sequence of events can occur (prior to C++17):

• First argument evaluation. The new operator dynamically allocates memory for a Record object.

• Second argument evaluation. The function checkDataBase is called.

• Continuation of first argument evaluation. The raw pointer obtained from new is converted to an std::shared_ptr object.

If the second step throws an exception, the raw pointer is not assigned to the resource management object and results in a memory leak. Polyspace flags the first call to addRecordToDatabase.

In the function getSP(), the shared pointer result is copy constructed from a temporary shared_ptr object. An implicit copying of the shared pointer also takes place during the return statement. Polyspace does not flag these operations.

Check Information

Group: General utilities library

Category: Required, Automated

Version History

Introduced in R2020b

R2023b: Checker does not flag member functions that returns copy of existing std::shared_ptr object

The rule checker does not report violations of this rule when you use a member function that returns a copy of an existing std::shared_ptr object. In this code, the function myClass::copySharedPtr() copies the std::shared_ptr object fooPtr. Because fooPtr is created by using the function std::make_shared, this copy is not a violation of this rule.

#include<memory>
class foo {
  };

  class myClass {
    std::shared_ptr<foo> fooPtr;
  public:
    myClass() : fooPtr{ std::make_shared<foo>() } {
    } //Class c'tor creates shared_ptr using make_shared
    std::shared_ptr<foo> copySharedPtr() const {
      return fooPtr; //Compliant                                                    
    } //copySharedPtr returns a copy of the member shared_ptr
  };

R2022b: Checker does not flag direct initialization of std::shared pointer using another std::shared pointer

The rule checker no longer reports a violation when an std::shared pointer is initialized directly using another std::shared pointer.