This is an unofficial snapshot of the ISO/IEC JTC1 SC22 WG21 Core Issues List revision 115e. See http://www.open-std.org/jtc1/sc22/wg21/ for the official list.
2024-11-11
[Accepted as a DR at the November, 2017 meeting.]
Consider the following example:
void *operator new(size_t n, std::string s) {
std::string t = std::move(s);
std::cout << "new " << t << std::endl;
return operator new(n);
}
void operator delete(void*, std::string s) {
std::cout << "delete " << s << std::endl;
}
struct X { X() { throw 0; } };
int main() {
try {
new ("longer than the small string buffer") X();
} catch (...) {}
}
Current implementations print
new longer than the small string buffer delete
because the same std::string object is used for both the new and delete calls. We should introduce additional copies to separate out the parameters in this case or make non-trivially-copyable parameter types ill-formed here.
Notes from the October, 2015 meeting:
CWG favored limiting the parameters of an overloaded deallocation function to trivially-copyable types.
Proposed resolution (October, 2017):
Change 7.6.2.8 [expr.new] paragraph 24 as follows:
If a new-expression calls a deallocation function, it passes the value returned from the allocation function call as the first argument of type void*. If a placement deallocation function is called, it is passed the same additional arguments as were passed to the placement allocation function, that is, the same arguments as those specified with the new-placement syntax. If the implementation is allowed to introduce a temporary object or make a copy of any argument as part of the call to the allocation function, it isallowed to make a copy (of the same original value) as part of the call to the deallocation function or to reuse the copy made as part of the call to the allocation function. If the copy is elided in one place, it need not be elided in the otherunspecified whether the same object is used in the call to both the allocation and deallocation functions,