AutosarC++18_10-A18.1.4ΒΆ

A pointer pointing to an element of an array of objects shall not be passed to a smart pointer of single object type

Required inputs: IR

Rationale

A dynamically allocated array of objects needs a corresponding deallocation function, e.g. allocation by new[] requires deallocation by delete[], see also rule A18-5-3 in section 6.18.5. Smart pointers of a single object type, e.g. std::unique_ptr <T> and std::shared_ptr<T>, by default have a deleter associated with them which is only capable of deleting a single object. Therefore, it is undefined behavior if a pointer pointing to an element of an array of objects is passed to such a smart pointer. With the standard library smart pointer templates std::unique_ptr and std::shared_ptr, this is possible when calling the constructor or the reset function.

Note that the standard library provides a specialization of the std::unique_ptr template for array types, std::unique_ptr<T[]>, and corresponding overloads for std::make_unique. Usage of these features is conforming to this rule.

Note that corresponding features for std::shared_ptr are only available in C++17 (usage of std::shared_ptr<T[]> with C++11 and C++14 will lead to compilation errors). The overloads for std::make_shared will only be available in C++20.

Furthermore, note that it is possible to create a smart pointer of single object type with a custom deleter handling an array of objects. This is well behaving as long as this smart pointer is actually managing an array of objects. However, such a use is error- prone, since the smart pointer can be assigned a single object again in the reset function; it may no longer be possible in C++17 (moving a std::unique_ptr<T[]> into a std::shared_ptr<T> is no longer allowed); and it is superseded by better alternatives in C++17 (availability of std:shared_ptr<T[]>). Therefore such usage is considered not compliant to this rule.

In many cases, using a container such as std::array or std::vector or a smart pointer to a container, e.g. std::shared_ptr<std::vector<T>>, is a better alternative than a smart pointer to an array of objects.

Example
// $Id: A18-1-4.cpp 313638 2018-03-26 15:34:51Z jan.babst $
    #include <memory>
    class A
    {
    };
    void F1()
    {
        // Create a dynamically allocated array of 10 objects of type A.
        auto up1 = std::make_unique<A[]>(10); // Compliant

        std::unique_ptr<A> up2{up1.release()};      // Non-compliant
    }
    void F2()
    {
        auto up1 = std::make_unique<A[]>(10);      // Compliant

        std::unique_ptr<A> up2;
        up2.reset(up1.release());  // Non-compliant
    }
    void F3()
    {
        auto up = std::make_unique<A[]>(10); // Compliant

        std::shared_ptr<A> sp{up.release()};      // Non-compliant
    }
    void F4()
    {
        auto up = std::make_unique<A[]>(10);      // Compliant

          std::shared_ptr<A> sp;
          sp.reset(up.release());// Non-compliant
    }
    void F5()
    {
        auto up = std::make_unique<A[]>(10); // Compliant

          // sp will obtain its deleter from up, so the array will be correctly
          // deallocated. However, this is no longer allowed in C++17.
          std::shared_ptr<A> sp{std::move(up)}; // Non-compliant
          sp.reset(new A{});                     // leads to undefined behavior
    }
    void F6()
    {
        auto up = std::make_unique<A[]>(10);      // Compliant

          // Well behaving, but error-prone
          std::shared_ptr<A> sp{up.release(),
                                std::default_delete<A[]>{}};     // Non-compliant
          sp.reset(new A{}); // leads to undefined behavior
    }
See Also
  • HIC++ v4.0 [9]: 17.3.4: Do not create smart pointers of array type.
  • ISO/IEC 14882:2014 [3]: 20.8 Smart pointers: [smartptr]
  • Rule A18-5-3 in section 6.18.5

Possible Messages

Key

Text

Severity

Disabled

type_used

{} shall not refer to an array type.

None

False

Options