{"id":103780,"date":"2020-05-22T07:00:00","date_gmt":"2020-05-22T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=103780"},"modified":"2020-07-02T06:54:55","modified_gmt":"2020-07-02T13:54:55","slug":"20200522-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20200522-00\/?p=103780","title":{"rendered":"On the various ways of constructing a C++\/WinRT com_array"},"content":{"rendered":"

The C++\/WinRT com_array<T><\/code> represents a C-style conformant array of data where the underlying buffer is allocated via the COM task allocator. It is typically used to represent a C-style conformant array which is allocated by one component and freed by another.<\/p>\n

You will probably need to make one of these things when you are returning a projected array to the caller, either as the return value or through an output parameter. Here are your choices of constructor<\/a>, with names that I made up.<\/p>\n

<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
com_array();<\/tt><\/td>\n(1)<\/span><\/td>\n<\/tr>\n
com_array(uint32_t count);<\/tt><\/td>\n(2)<\/span><\/td>\n<\/tr>\n
com_array(uint32_t count, T const& value);<\/tt><\/td>\n(3)<\/span><\/td>\n<\/tr>\n
template<typename InIt>
\ncom_array(InIt first, InIt last)<\/tt><\/td>\n		(4)<\/span><\/td>\n<\/tr>\n
com_array(std::vector<T> const& value)<\/tt><\/td>\n(5)<\/span><\/td>\n<\/tr>\n
template<size_t N>
\ncom_array(std::array<T, N> const& value)<\/tt><\/td>\n		(6)<\/span><\/td>\n<\/tr>\n
template<size_t N>
\ncom_array(T const(&value)[N])<\/tt><\/td>\n		(7)<\/span><\/td>\n<\/tr>\n
com_array(std::initializer_list<T> value)<\/tt><\/td>\n(8)<\/span><\/td>\n<\/tr>\n
com_array(void* ptr, uint32_t count,
\n\u00a0\u00a0take_ownership_from_abi_t);<\/tt><\/td>\n		(9)<\/span><\/td>\n<\/tr>\n
com_array(com_array&& other)<\/tt><\/td>\n(10)<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

1)<\/span> Default constructor: Creates an empty buffer.<\/p>\n

2)<\/span> Capacity constructor (default value): Creates a buffer of count<\/code> elements, all containing copies of a default-constructed T<\/code>.<\/p>\n

3)<\/span> Capacity constructor (explicit value): Creates a buffer of count<\/code> elements, each of which is a copy of the provided value.<\/p>\n

4)<\/span> Range constructor: Creates a buffer that is a copy of the range [first, last)<\/code>.<\/p>\n

5)<\/span> Vector constructor: Creates a buffer that is a copy of the contents of the vector.<\/p>\n

6)<\/span> Array constructor: Creates a buffer that is a copy of the contents of the array.<\/p>\n

7)<\/span> C-style array constructor: Creates a buffer that is a copy of the contents of the C-style array.<\/p>\n

8)<\/span> Initializer-list constructor: Creates a buffer that is a copy of the contents of the initializer list.<\/p>\n

9)<\/span> ABI constructor: Takes ownership of a buffer of specified length.<\/p>\n

10)<\/span> Move constructor: Moves the resources from another com_array<\/code> of the same type, leaving the original empty.<\/p>\n

Remarks for capacity constructor with default value (2)<\/span><\/b><\/p>\n

\n

Constructor (2)<\/span> is almost but not quite the same as creating a buffer of count<\/code> elements each of which is a default-constructed T<\/code>. Consider:<\/p>\n

auto players = com_array<MediaPlayer>(50);\r\n<\/pre>\n
The MediaPlayer<\/code> object’s default constructor creates a reference to a new media player object, and its copy constructor copies the reference. Therefore, the above line of code creates an array of 50 references to the same media player object, not an array of 50 different media player objects.<\/p>\n
Bonus weirdness<\/b>: If you pass a count<\/code> of zero, the com_array<\/code> will still default-contruct a T<\/code>, even though it doesn’t use it for anything.<\/p>\n<\/div>\n
Remarks for capacity constructor with explicit value (3)<\/span><\/b><\/p>\n
\n
com_array(2, 42)<\/code> is interpreted as an attempt to use the range constructor (4)<\/span>, which fails because 2<\/code> and 42<\/code> are not iterators. To get this to be interpreted as a capacity constructor with explicit int32_t<\/code> value, use an explicitly unsigned integer as the first parameter: com_array(2u, 42)<\/code>.<\/p>\n<\/div>\n
Remarks for range constructor (4)<\/span><\/b><\/p>\n
\n
Sadly, there is (as of this writing)\u00b9 no deduction guide for the range constructor (4)<\/span>, so you will have to state the underlying type T<\/code> explicitly:<\/p>\n
auto a = com_array<T>(source.begin(), source.end());\r\n<\/pre>\n
Bonus trick<\/b>: If you want to move the range rather than copy it, use the std::<\/code>move_<\/code>iterator<\/code> iterator adaptor:<\/p>\n
auto a = com_array<T>(std::move_iterator(source.begin()),\r\n                      std::move_iterator(source.end()));\r\n<\/pre>\n<\/div>\n
Remarks for vector (5)<\/span>, array (6)<\/span>, and C-style array (7)<\/span> constructors<\/b><\/p>\n
\n
For constructors (5)<\/span> through (7)<\/span>, the contents of the container are copied. You can use the range constructor (4)<\/span> with the move_<\/code>iterator<\/code> iterator adaptor to move the contents into the com_<\/code>array<\/code> instead of copying.<\/p>\n<\/div>\n
Remarks for ABI constructor (9)<\/span><\/b><\/p>\n
\n
The ABI constructor (9)<\/span> is the lowest-level constructor. Use it when you have a block of memory already allocated via Co\u00adTask\u00adMem\u00adAlloc<\/code> and you want the com_array<\/code> to assume responsibility for it. To emphasize the special requirements for this constructor, the final parameter must be take_<\/code>ownership_<\/code>from_<\/code>abi<\/code>.<\/p>\n<\/div>\n
\u00b9 Hint hint. Add a deduction guide and create a PR. While you’re at it, fix the range constructor so it doesn’t inadvertently trigger for com_array(2, 42)<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"
Surveying the constructors.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-103780","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Surveying the constructors.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/103780","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=103780"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/103780\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=103780"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=103780"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=103780"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}