forked from cirosantilli/cpp-cheat
-
Notifications
You must be signed in to change notification settings - Fork 0
/
new.cpp
151 lines (113 loc) · 3.71 KB
/
new.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
/*
# Dynamic memory
C++ replaces C's malloc and free with new and delete.
It is very rare to need explicit dynamic allocation. Always use:
std::vector<int> is(n)
instead of:
int *is = new int[n];
and `vector<int>(n)` is as efficient and much more flexible than `new int[N]`.
Dynamic allocation is a dangerous, and it may lead to hard to debug memory leaks.
Always encapsulate dynamic allocation inside class constructors,
and free it the destructor, like `std::vector` does.
Never use C style malloc on C++ code. `new` works better with classes.
# new
Allocate dynamic memory.
Throw `std::bad_alloc` in case of error.
# realloc
There is no direct replacement to realloc or calloc as of C++11
http://stackoverflow.com/questions/3482941/how-do-you-realloc-in-c
*/
#include "common.hpp"
int main() {
/*
Basic usage with proper error checking.
*/
{
int* ip;
try {
ip = new int[5];
} catch(std::bad_alloc& ba) {
assert(false);
}
ip[0] = 1;
delete[] ip;
}
/*
# delete
Free memory allocatedby `new`.
Just like C `free`:
- deleting a `NULL` does nothing.
- deleting any other pointer twice can lead to memory corruption
- deleting a pointer which was not dynamically allocated can lead to memory curruption
Destructor of object pointed to is called.
A common technique is to set a pointer to `NULL` after it is deleted,
to avoid deleting a pointer twice:
<stackoverflow.com/questions/4190703/is-it-safe-to-delete-a-null-pointer>
An even better techinque may be to use smart pointers and containers.
*/
{
delete (int*)NULL;
delete[] (int*)NULL;
//delete NULL;
// WARN: cannot delete an integer type
//delete (void*)NULL;
// WARN: cannot delete a void pointer
}
// Allocate single object / base type.
{
int* ip = new int;
*ip = 1;
delete ip;
}
// Delete calls destructors of deleted objects.
{
callStack.clear();
NoBaseNoMember* cp = new NoBaseNoMember;
//NoBaseNoMember* cp = new NoBaseNoMember();
//SAME
assert(callStack.back() == "NoBaseNoMember::NoBaseNoMember()");
cp->method();
callStack.clear();
delete cp;
assert(callStack.back() == "NoBaseNoMember::~NoBaseNoMember()");
//calls destructor
}
{
callStack.clear();
NoBaseNoMember* cp = new NoBaseNoMember[2];
assert(callStack.back() == "NoBaseNoMember::NoBaseNoMember()"); callStack.pop_back();
assert(callStack.back() == "NoBaseNoMember::NoBaseNoMember()"); callStack.pop_back();
cp[0].method();
cp[1].method();
callStack.clear();
delete[] cp;
assert(callStack.back() == "NoBaseNoMember::~NoBaseNoMember()"); callStack.pop_back();
assert(callStack.back() == "NoBaseNoMember::~NoBaseNoMember()"); callStack.pop_back();
}
{
//int* ip = new int;
//delete ip;
//BAD
//undefined behavior, maybe crash
//delete ip;
}
{
//int* ip = new int;
//ip = new int;
//delete ip;
//BAD
//memory leak. memory is lost forever.
}
{
//int* ip;
//delete ip;
//BAD
//undefined behavior, maybe crash
//ip was not allocated after delete!
}
/*
# calloc
An analogue effect to calloc can be attained with *value-initialization*.
http://stackoverflow.com/questions/808464/c-new-call-that-behaves-like-calloc
*/
}