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 ForwardIterator>
13 //   ForwardIterator
14 //   uninitialized_copy(InputIterator first, InputIterator last,
15 //                      ForwardIterator result);
16 
17 #include <memory>
18 #include <cassert>
19 
20 struct B
21 {
22     static int count_;
23     int data_;
BB24     explicit B() : data_(1) {}
BB25     B(const B& b) {if (++count_ == 3) throw 1; data_ = b.data_;}
~BB26     ~B() {data_ = 0;}
27 };
28 
29 int B::count_ = 0;
30 
31 struct Nasty
32 {
NastyNasty33     Nasty() : i_ ( counter_++ ) {}
operator &Nasty34     Nasty * operator &() const { return NULL; }
35     int i_;
36     static int counter_;
37 };
38 
39 int Nasty::counter_ = 0;
40 
main()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(b, b+N, 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(b, 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(arr, 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 }
76