-
Notifications
You must be signed in to change notification settings - Fork 0
/
placement_new_operator.cpp
152 lines (120 loc) · 3.15 KB
/
placement_new_operator.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
//! //////////////////////////////////////////////////////////////////////// 1
// // C++ program to illustrate the placement new operator
// #include<iostream>
// using namespace std;
// int main()
// {
// // buffer on stack
// unsigned char buf[sizeof(int)*2] ;
// // placement new in buf
// int *pInt = new (buf) int(3);
// int *qInt = new (buf + sizeof (int)) int(5);
// int *pBuf = (int*)(buf+0) ;
// int *qBuf = (int*) (buf + sizeof(int));
// cout << "Buff Addr Int Addr" << endl;
// cout << pBuf <<" " << pInt << endl;
// cout << qBuf <<" " << qInt << endl;
// cout << "------------------------------" << endl;
// cout << "1st Int 2nd Int" << endl;
// cout << *pBuf << " "
// << *qBuf << endl;
// return 0;
// }
//! //////////////////////////////////////////////////////////////////////// 2
// // C++ program to illustrate the placement new operator
// #include<iostream>
// using namespace std;
// int main()
// {
// // initial value of X
// int X = 10;
// cout << "Before placement new :" << endl;
// cout << "X : " << X << endl;
// cout << "&X : " << &X << endl;
// // Placement new changes the value of X to 100
// int *mem = new (&X) int(100);
// cout << "\nAfter placement new :" << endl;
// cout << "X : " << X << endl;
// cout << "mem : " << mem << endl;
// cout << "&X : " << &X << endl;
// return 0;
// }
//! //////////////////////////////////////////////////////////////////////// 3
// C++ program to illustrate using destructor for
// deleting memory allocated by placement new
#include<iostream>
#include<cstdlib>
#include<cmath>
using namespace std;
class Complex
{
private:
double re_, im_;
public:
// Constructor
Complex(double re = 0, double im = 0): re_(re), im_(im)
{
cout << "Constructor : (" << re_ << ", " << im_ << ")" << endl;
}
// Destructor
~Complex()
{
cout << "Destructor : (" << re_ << ", " << im_ << ")" << endl;
}
double normal()
{
return sqrt(re_*re_ + im_*im_);
}
void print()
{
cout << "|" << re_ <<" +j" << im_ << " | = " << normal() << endl;
}
};
// Driver code
int main()
{
// buffer on stack
unsigned char buf[100];
Complex* pc = new Complex(4.2, 5.3);
Complex* pd = new Complex[2];
// using placement new
Complex *pe = new (buf) Complex(2.6, 3.9);
// use objects
pc -> print();
pd[0].print();
pd[1].print();
pe->print();
// Release objects
// calls destructor and then release memory
delete pc;
// Calls the destructor for object pd[0]
// and then release memory
// and it does same for pd[1]
delete [] pd;
// No delete : Explicit call to Destructor.
pe->~Complex();
return 0;
}
//! //////////////////////////////////////////////////////////////////////// 4
// // C++ program to illustrate segmentation fault
// // while using placement new operator
// #include<iostream>
// using namespace std;
// int main()
// {
// // Fine
// int i = 10;
// int *ipt = &i ;
// int *i1 = new(ipt) int(9) ;
// // Incorrect as ip may not
// // be a valid address
// int *ip;
// int *i2 = new(ip) int(4) ;
// // Fine
// void *vd = &i;
// int *i3 = new(vd) int(34) ;
// // Incorrect as x is not an address
// int x;
// int *i5 = new(x) int(3) ;
// return 0;
// }