AutosarC++17_10-A8.5.4ΒΆ
A constructor taking parameter of type std::initializer_list shall only be defined in classes that internally store a collection of objects
Required inputs: IR
| Level | advisory |
|---|---|
| Target | implementation |
| Enforcement | non-automated |
Rationale
If an object is initialized using {} braced-initialization, the compiler strongly prefers constructor taking parameter of type std::initializer_list to other constructors. Usage of constructors taking parameter of type std::initializer_list needs to be limited in order to avoid implicit calls to wrongly deduced constructor candidate of a class.
A class that internally stores a collection of objects is the case in which constructors taking parameter of type std::initializer_list are reasonable, allowing readable initialization of a class with a list of its elements.
Example
// $Id: A8-5-4.cpp 289436 2017-10-04 10:45:23Z michal.szczepankiewicz $
#include <algorithm>
#include <cstdint>
#include <initializer_list>
#include <vector>
class A {
public:
A() : x(0), y(0) {}
A(std::int32_t first, std::int32_t second) : x(first), y(second) {}
A(std::initializer_list<std::int32_t> list)
: x(0), y(0) // Non-compliant - class A does not store a collection
// of objects
{
// ...
}
private:
std::int32_t x;
std::int32_t y;
};
class B {
public:
B() : collection() {}
B(std::int32_t size, std::int32_t value) : collection(size, value) {}
B(std::initializer_list<std::int32_t> list)
: collection(list) // Compliant - class B stores a collection of objects
{}
private:
std::vector<std::int32_t> collection;
};
class C {
public:
C() : array{0} {}
C(std::initializer_list<std::int32_t> list)
: array{0} // Compliant - class C stores a collection of objects
{
std::copy(list.begin(), list.end(), array);
}
private:
static constexpr std::int32_t size = 100;
std::int32_t array[size];
};
class D : public C {
public:
D() : C() {}
D(std::initializer_list<std::int32_t> list)
: C{list} // Compliant - class D inherits a collection of objects
// from class C
{}
};
class E {
public:
E() : container() {}
E(std::initializer_list<std::int32_t> list)
: container{list} // Compliant - class E stores class C which
// stores a collection of objects
{}
private:
C container;
};
void F1() noexcept {
A a1{}; // Calls A::A()
A a2{{}}; // Calls A::A(std::initializer_list<std::int32_t>)
A a3{0, 1}; // Calls A::A(std::initializer_list<std::int32_t>)
A a4(0, 1); // Calls A::A(std::int32_t, std::int32_t)
}
void F2() noexcept {
B b1{}; // Calls B::B()
B b2{{}}; // Calls B::B(std::initializer_list<std::int32_t>)
B b3{1, 2}; // Calls B::B(std::initializer_list<std::int32_t>)
B b4(10, 0); // Calls B::B(std::int32_t, std::int32_t)
}
void F3() noexcept {
C c1{}; // Calls C::C()
C c2{{}}; // Calls C::C(std::initializer_list<std::int32_t>)
C c3{1, 2, 3}; // Calls C::C(std::initializer_list<std::int32_t>)
}
void F4() noexcept {
D d1{}; // Calls D::D()
D d2{{}}; // Calls D::D(std::initializer_list<std::int32_t>)
D d3{1, 2, 3}; // Calls D::D(std::initializer_list<std::int32_t>)
}
void F5() noexcept {
E e1{}; // Calls E::E()
E e2{{}}; // Calls E::E(std::initializer_list<std::int32_t>)
E e3{1, 2, 3}; // Calls E::E(std::initializer_list<std::int32_t>)
}
See Also
- Effective Modern C++ [12]: Item 7. Distinguish between () and {} when creating objects.
Possible Messages
Key |
Text |
Severity |
Disabled |
|---|---|---|---|
constructor_init_list_container |
The class should be a container if a constructor taking std::initializer_list is defined. |
None |
False |
Options
This rule shares the following common options: confidence, exclude_in_macros, exclude_messages_in_system_headers, excludes, extend_exclude_to_macro_invocations, includes, justification_checker, languages, post_processing, provider, report_at, severity
The following places define options that affect this rule: Stylechecks, Analysis-GlobalOptions
This rule has no individual options.