Re: Can an arbitrary continuous sequence of objects of type T be
interpreted as an array of T?
On 24 Oct, 16:17, MiB <michael.boehni...@gmail.com> wrote:
On Oct 16, 3:21 pm, Nikolay Ivchenkov <ts...@mail.ru> wrote:
[..]
Are the results of the explicit type conversion (performed by
static_cast) and of the implicit array-to-pointer conversion well-
defined here?
Yes, its well-defined, both.
I would like to see a proof (a set of normative rules that would allow
us to make such conclusion).
vec.data() returns a pointer, and instead of the void* / static_cast
cast you could use
reinterpret_cast<std::string (*)[2]>( vec.data() );
I didn't use reinterpret_cast intentionally, because the result of
such conversion here would be unspecified.
On 24 Oct, 20:48, Francis Glassborow
<francis.glassbo...@btinternet.com> wrote:
Contiguous is used about discrete objects to
indicate that there is no space between them. Continuous Is a property
of a single object and implies that it can be broken apart anywhere
rather than just at discrete points.
Thanks for the explanation.
and since a std::vector is a "contiguous" sequence, you should be fine
in your code.
Can you prove that?
I know that this was discussed several times by WG21 during the last
decade. It was certainly intended that the elements of a vector be
located in a contiguous sequence and I am pretty sure that words were
eventually found for the Standard to require that
I see permission to apply pointer arithmetic to pointers that point to
elements of an std::vector object. However, I don't see permission to
access its elements through dereferencing a result of an array-to-
pointer conversion (as shown above). The fact that array objects
consist of contiguously allocated subobjects of the same types doesn't
imply that any contiguously allocated sequence of objects of the same
type is semantically equivalent to an array object. Simple logic.
Note that i can be treated as an array of 1 element
For the purposes of pointer arithmetic - yes. However, again, this
doesn't imply that we can access i through dereferencing a result of
an array-to-pointer conversion applied to an expression of type
int[1].
We also need to consider this code in C++
int i_array[10];
int & i{i_array[0]};
i = 0;
i[1] = 1; // well defined or undefined behaviour?
That's ill-formed with required diagnostic.
I'll try to explain why I'm looking for strict proof. We can create a
dynamic array of built-in arrays via a new-expression:
std::string (*p)[2] = new std::string[3][2];
p[2][1] = "text";
Unfortunately, the following code doesn't work.
std::vector<std::string[2]> v(3);
v[2][1] = "text";
This is because std::allocator cannot properly handle arrays. In some
cases we can use std::array instead of built-in arrays:
std::vector<std::array<std::string, 2>> v(3);
v[2][1] = "text";
This is not a solution if we already have an immutable interface that
expects a pointer to built-in array. One possible workaround I
described above. We can also use our custom allocator as follows:
-----------------------------------------------------------
#include <cstddef>
#include <iostream>
#include <iterator>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
template <class T>
struct array_size {};
template <class T>
struct array_size<T &> : array_size<T> {};
template <class T>
struct array_size<T &&> : array_size<T> {};
template <class T, std::size_t size>
struct array_size<T[size]>
{ static constexpr size_t value = size; };
template <class T>
struct Allocator : std::allocator<T>
{
template <class U>
struct rebind
{ typedef Allocator<U> other; };
Allocator() noexcept {};
template <class U>
Allocator(Allocator<U> const &) noexcept {}
template <class U, class... Params>
typename std::enable_if<!std::is_array<U>::value>::type
static construct(U *p, Params &&... params)
{
::new((void *)p) U(std::forward<Params>(params)...);
}
template <class U>
typename std::enable_if<std::is_array<U>::value>::type
static construct(U *p)
{
typedef typename std::remove_extent<U>::type ElemType;
ElemType *const dst_end = std::end(*p);
ElemType *dst = *p;
try
{
for (; dst != dst_end; ++dst)
Allocator<void>::construct(dst);
}
catch (...)
{
while (dst != *p)
Allocator<void>::destroy(--dst);
throw;
}
}
template <class U, class Param>
typename std::enable_if<
array_size<U>::value == array_size<Param>::value>::type
static construct(U *p, Param &¶m)
{
typedef typename std::remove_extent<U>::type ElemType;
typedef typename std::remove_extent<
typename std::remove_reference<Param>::type>::type
ParamElemType;
typedef typename std::conditional<
std::is_lvalue_reference<Param>::value,
ParamElemType &,
ParamElemType>::type ParamElemTypeFwd;
ElemType *const dst_end = std::end(*p);
ParamElemType *src = param;
ElemType *dst = *p;
try
{
for (; dst != dst_end; ++dst, ++src)
Allocator<void>::construct(
dst, std::forward<ParamElemTypeFwd>(*src));
}
catch (...)
{
while (dst != *p)
Allocator<void>::destroy(--dst);
throw;
}
}
template <class U>
typename std::enable_if<!std::is_array<U>::value>::type
static destroy(U *p)
{ p->~U(); }
template <class U>
typename std::enable_if<std::is_array<U>::value>::type
static destroy(U *p)
{
typedef typename std::remove_extent<U>::type ElemType;
for (ElemType *it = std::end(*p); it != *p;)
(*--it).~ElemType();
}
};
int main()
{
typedef std::string Strings[2];
std::vector<Strings, Allocator<Strings>> v(3);
v[2][1] = "text";
std::cout << v[2][1] << std::endl;
}
-----------------------------------------------------------
I could suggest LWG to improve std::allocator if I would be sure that
such a solution is really well-defined.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]