[cfe-dev] Fwd: [libc++] Is libc++ compatible with previous c++ language standard implementation

[Zeson Wu via cfe-dev]

In clang, only format (1) will be used, so there is not copy construction
in *pre* c++11, but there should be a copy construction as the reference
declare "explicit vector( size_type count, const T& value = T(), const
Allocator& alloc = Allocator());".

2018-03-08 12:25 GMT+08:00 alan snape <alansnape3058 at gmail.com>:

> OK, I got your meaning. Let's summarize the interfaces declared on
> http://en.cppreference.com/w/cpp/container/vector/vector and then go over
> the implementation of libc++ version.
>
> On the site http://en.cppreference.com/w/cpp/container/vector/vector, the
> given interfaces are:
>
>> (2)
>> explicit vector( size_type count,
>>                  const T& value = T(),
>>                  const Allocator& alloc = Allocator());
>> (until C++11)
>>          vector( size_type count,
>>                  const T& value,
>>                  const Allocator& alloc = Allocator());
>> (since C++11)
>> (3)
>> explicit vector( size_type count );
>> (since C++11, until C++14)
>> explicit vector( size_type count, const Allocator& alloc = Allocator() );
>> (since C++14)
>
> If you use `vector(1)`, format (2-1) will be used until c++11, format
> (3-1) will be used since c++11 until c++14 and format (3-2) will be used
> since c++14.
> If you use `vector(1, T())`, format (2-1) will be used until c++11, format
> (2-2) will be used since c++11.
> If you use `vector(1, T(), Allocator())`, format (2-1) will be used until
> c++11, format (2-2) will be used since c++11.
> And you can use `vector(1, Allocator())` until c++14, where format (3-2)
> will be used.
> And the above interfaces are right the same with the code provided by gcc
> (just as what you pasted in the previous mail).
>
> Then, let's have a look at the libc++ version:
>
>> // libc++/include/vector:491~496: https://github.com/llvm-
>> mirror/libcxx/blob/master/include/vector#L491
>
>
>
>     explicit vector(size_type __n);  // (1)
>> #if _LIBCPP_STD_VER > 11
>>     explicit vector(size_type __n, const allocator_type& __a);  // (2)
>> #endif
>>     vector(size_type __n, const_reference __x);  // (3)
>>     vector(size_type __n, const_reference __x, const allocator_type&
>> __a);  // (4)
>
> If you use `vector(1)`, format (1) will be used.
> If you use `vector(1, T())`, format (3) will be used.
> If you use `vector(1, T(), Allocator())`, format (4) will be used.
> And you can use `vector(1, Allocator())` until c++14, where format (2)
> will be used.
> All the interfaces required are implemented, and clearer than the gcc
> version.
>
> Did I managed to answer your question?
>
> And go on with the test case you provided above, the differences between
> the two versions of header files make the different results. In gcc, format
> (2-1) will be used until c++11, which may contain value copy during
> construction, but the format (3-1) and format (3-2), which are used in
> c++11 and since c++14 respectively, do not have the value copy; while in
> clang, only format (1) will be used, and the behavior cannot be different.
>



-- 
Zeson
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-dev/attachments/20180308/b720bd5a/attachment.html>