Home | History | Annotate | Download | only in uninitialized.copy
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // <memory>
     11 
     12 // template <class InputIterator, class Size, class ForwardIterator>
     13 //   ForwardIterator
     14 //   uninitialized_copy_n(InputIterator first, Size n,
     15 //                        ForwardIterator result);
     16 
     17 #include <memory>
     18 #include <cassert>
     19 
     20 struct B
     21 {
     22     static int count_;
     23     int data_;
     24     explicit B() : data_(1) {}
     25     B(const B& b) {if (++count_ == 3) throw 1; data_ = b.data_;}
     26     ~B() {data_ = 0;}
     27 };
     28 
     29 int B::count_ = 0;
     30 
     31 struct Nasty
     32 {
     33     Nasty() : i_ ( counter_++ ) {}
     34     Nasty * operator &() const { return NULL; }
     35     int i_;
     36     static int counter_;
     37 };
     38 
     39 int Nasty::counter_ = 0;
     40 
     41 int main()
     42 {
     43     {
     44     const int N = 5;
     45     char pool[sizeof(B)*N] = {0};
     46     B* bp = (B*)pool;
     47     B b[N];
     48     try
     49     {
     50         std::uninitialized_copy_n(b, 5, bp);
     51         assert(false);
     52     }
     53     catch (...)
     54     {
     55         for (int i = 0; i < N; ++i)
     56             assert(bp[i].data_ == 0);
     57     }
     58     B::count_ = 0;
     59     std::uninitialized_copy_n(b, 2, bp);
     60     for (int i = 0; i < 2; ++i)
     61         assert(bp[i].data_ == 1);
     62     }
     63     {
     64     const int N = 5;
     65     char pool[sizeof(Nasty)*N] = {0};
     66     Nasty * p = (Nasty *) pool;
     67     Nasty arr[N];
     68     std::uninitialized_copy_n(arr, N, p);
     69     for (int i = 0; i < N; ++i) {
     70         assert(arr[i].i_ == i);
     71         assert(  p[i].i_ == i);
     72     }
     73     }
     74 }
     75