[class.free] - C++14 → C++17

Files changed (1) hide show

tmp/tmpt3j9xxe2/{from.md → to.md} +37 -16

tmp/tmpt3j9xxe2/{from.md → to.md} RENAMED Viewed

@@ -1,10 +1,12 @@
 ## Free store <a id="class.free">[[class.free]]</a>
 Any allocation function for a class `T` is a static member (even if not
 explicitly declared `static`).
 ``` cpp
 class Arena;
 struct B {
   void* operator new(std::size_t, Arena*);
 };
@@ -17,12 +19,14 @@ void foo(int i) {
   new D1[i];        // calls ::operator new[](std::size_t)
   new D1;           // ill-formed: ::operator new(std::size_t) hidden
 }
 ```
 When an object is deleted with a *delete-expression* ([[expr.delete]]),
-a *deallocation function* (`operator delete()` for non-array objects or
 `operator delete[]()` for arrays) is (implicitly) called to reclaim the
 storage occupied by the object ([[basic.stc.dynamic.deallocation]]).
 Class-specific deallocation function lookup is a part of general
 deallocation function lookup ([[expr.delete]]) and occurs as follows.
@@ -39,10 +43,12 @@ inaccessible, or if the lookup selects a placement deallocation
 function, the program is ill-formed.
 Any deallocation function for a class `X` is a static member (even if
 not explicitly declared `static`).
 ``` cpp
 class X {
   void operator delete(void*);
   void operator delete[](void*, std::size_t);
 };
@@ -51,16 +57,22 @@ class Y {
   void operator delete(void*, std::size_t);
   void operator delete[](void*);
 };
 ```
 Since member allocation and deallocation functions are `static` they
-cannot be virtual. however, when the *cast-expression* of a
-*delete-expression* refers to an object of class type, because the
-deallocation function actually called is looked up in the scope of the
-class that is the dynamic type of the object, if the destructor is
-virtual, the effect is the same. For example,
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete(void*, std::size_t);
@@ -75,14 +87,19 @@ void f() {
   delete bp;        // 1: uses D::operator delete(void*)
 }
 ```
 Here, storage for the non-array object of class `D` is deallocated by
-`D::operator delete()`, due to the virtual destructor. Virtual
-destructors have no effect on the deallocation function actually called
-when the *cast-expression* of a *delete-expression* refers to an array
-of objects of class type. For example,
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete[](void*, std::size_t);
@@ -98,15 +115,19 @@ void f(int i) {
   B* bp = new D[i];
   delete[] bp;      // undefined behavior
 }
 ```
 Access to the deallocation function is checked statically. Hence, even
 though a different one might actually be executed, the statically
-visible deallocation function is required to be accessible. for the call
-on line //1 above, if `B::operator delete()` had been `private`, the
-delete expression would have been ill-formed.
-If a deallocation function has no explicit *exception-specification*, it
-is treated as if it were specified with `noexcept(true)` (
-[[except.spec]]).

 ## Free store <a id="class.free">[[class.free]]</a>
 Any allocation function for a class `T` is a static member (even if not
 explicitly declared `static`).
+[*Example 1*:
 ``` cpp
 class Arena;
 struct B {
   void* operator new(std::size_t, Arena*);
 };
   new D1[i];        // calls ::operator new[](std::size_t)
   new D1;           // ill-formed: ::operator new(std::size_t) hidden
 }
 ```
+— *end example*]
 When an object is deleted with a *delete-expression* ([[expr.delete]]),
+a deallocation function (`operator delete()` for non-array objects or
 `operator delete[]()` for arrays) is (implicitly) called to reclaim the
 storage occupied by the object ([[basic.stc.dynamic.deallocation]]).
 Class-specific deallocation function lookup is a part of general
 deallocation function lookup ([[expr.delete]]) and occurs as follows.
 function, the program is ill-formed.
 Any deallocation function for a class `X` is a static member (even if
 not explicitly declared `static`).
+[*Example 2*:
 ``` cpp
 class X {
   void operator delete(void*);
   void operator delete[](void*, std::size_t);
 };
   void operator delete(void*, std::size_t);
   void operator delete[](void*);
 };
 ```
+— *end example*]
 Since member allocation and deallocation functions are `static` they
+cannot be virtual.
+[*Note 1*:
+However, when the *cast-expression* of a *delete-expression* refers to
+an object of class type, because the deallocation function actually
+called is looked up in the scope of the class that is the dynamic type
+of the object, if the destructor is virtual, the effect is the same. For
+example,
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete(void*, std::size_t);
   delete bp;        // 1: uses D::operator delete(void*)
 }
 ```
 Here, storage for the non-array object of class `D` is deallocated by
+`D::operator delete()`, due to the virtual destructor.
+— *end note*]
+[*Note 2*:
+Virtual destructors have no effect on the deallocation function actually
+called when the *cast-expression* of a *delete-expression* refers to an
+array of objects of class type. For example,
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete[](void*, std::size_t);
   B* bp = new D[i];
   delete[] bp;      // undefined behavior
 }
 ```
+— *end note*]
 Access to the deallocation function is checked statically. Hence, even
 though a different one might actually be executed, the statically
+visible deallocation function is required to be accessible.
+[*Example 3*: For the call on line “// 1” above, if
+`B::operator delete()` had been `private`, the delete expression would
+have been ill-formed. — *end example*]
+[*Note 3*: If a deallocation function has no explicit
+*noexcept-specifier*, it has a non-throwing exception specification (
+[[except.spec]]). — *end note*]

Diff to HTML by rtfpessoa