// which uses a counter in the triangulation class to denote the fact that
// there is still an object out there using this triangulation, thus
// leading to an abort in case the triangulation is attempted to be
- // destructed while this object still uses it.
+ // destroyed while this object still uses it.
//
// Note that while the pointer itself is declared constant
// (i.e. throughout the lifetime of this object, the pointer points to the
* While we have only one of these objects per thread, several
* Threads::Thread objects may refer to this descriptor. If all Thread
* objects go out of scope the ThreadDescriptor will detach from the
- * thread before being destructed.
+ * thread before being destroyed.
*/
template <typename RT>
struct ThreadDescriptor
// is wrong, namely that some other
// object is still using the object
// that is presently being
-// destructed, but most of the time
+// destroyed, but most of the time
// not who this user is. It is
// therefore often rather
// time-consuming to find out where
// above. The reason is that member
// variables of the
// <code>LaplaceProblem</code> class are
-// destructed bottom-up (i.e. in
+// destroyed bottom-up (i.e. in
// reverse order of their declaration
// in the class), as always in
// C++. Thus, the finite element
-// object will be destructed before
+// object will be destroyed before
// the DoF handler object, since its
// declaration is below the one of
// the DoF handler. This triggers the
// situation above, and an exception
// will be raised when the <code>fe</code>
-// object is destructed. What needs
+// object is destroyed. What needs
// to be done is to tell the
// <code>dof_handler</code> object to release
// its lock to the finite element. Of