C++ Initializing a template array in a contructor initializer list

Question

I have a component class that doesn't have a default constructor and needs an object passed to it instead. I want to have a template class that builds a stack space, arbitrarily sized array of this component. Because it doesn't and really shouldn't have a default constructor, I'm running into issues making it work. Another note on the template class is that it can only have one parameter passed to it, and it must use it to initialize all of the array's elements.

Relevant parts of the component I want to create the array of.

class CSomeComponent : public CComponent {
public:
    CSomeComponent(const IObject* pObject) : CComponent(pObject) {
    }
};

Relevant parts of the template array I'm trying to make work.

template<size_t _Count>
class CComponentArray {
public:
    CComponentArray(const IObject* pObject) : m_component(...) {
    }

private:
    CSomeComponent m_component[_Count];
};

I can't change the fact that components don't have a default constructor. I also can't give the component array template more than one parameter. These two constraints are why I can't figure out how I'd do this, so hopefully someone else can. Thank you!

Can you use C++11 ?

Piotr Skotnicki
– Piotr Skotnicki

2020-05-16 14:43:03 +00:00
Commented May 16, 2020 at 14:43 — Piotr Skotnicki
– Piotr Skotnicki, Commented May 16, 2020 at 14:43
Yes, all the way through to C++17.

ryan
– ryan

2020-05-16 14:45:33 +00:00
Commented May 16, 2020 at 14:45 — ryan
– ryan, Commented May 16, 2020 at 14:45

bolov · Accepted Answer · 2020-05-16 15:06:43Z

Use std::array and then you can make a constexpr function that initializes and returns the array:

namespace details
{
template <class T, std::size_t Size, class... Args, std::size_t... I>
constexpr auto make_arr_emplace_impl(std::index_sequence<I...>, Args&&... args)
    -> std::array<T, Size>
{
    return std::array<T, Size> {(I, T{args...})...};
}
}


/* creates an std::array<T, Size> where each element is created by calling `T{args...}`
 * note: args will not be moved
 * forwarding references used for preserving constness and binding to temporaries
*/
template <class T, std::size_t Size, class... Args>
constexpr auto make_arr_emplace(Args&&... args) -> std::array<T, Size>
{
    return details::make_arr_emplace_impl<T, Size>(std::make_index_sequence<Size>{}, args...);
}

template<size_t Count>
class CComponentArray {
public:
    CComponentArray(const IObject* pObject)
        : m_component{make_arr_emplace<CSomeComponent, Count>(pObject)}
    {
    }

private:
    std::array<CSomeComponent, Count> m_component;
};

Please note that identifiers starting with double underscore or one underscore and a capital letter - like your _Count - are reserved for implementation.

It worked great, thank you! Thanks for the note on underscores as well. I didn't realize that. I'll have to spend some time learning about constant expressions.
@ryan you are welcome. Make sure you have the latest version. I've edited it several times.

Collectives™ on Stack Overflow

C++ Initializing a template array in a contructor initializer list

1 Answer 1

2 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Related