Formally set version and testing to C++ 11

.github/workflows/test.yml

@@ -40,7 +40,7 @@ jobs:
 
       # Static Debug
       - name: "Static Debug: Configure"
-        run: cmake -G Ninja -S . -B build-static-dbg -DCMAKE_BUILD_TYPE=Debug "-DCMAKE_DEBUG_POSTFIX=d${{matrix.static_postfix}}"
+        run: cmake -G Ninja -S . -B build-static-dbg -DCMAKE_BUILD_TYPE=Debug "-DCMAKE_DEBUG_POSTFIX=d${{matrix.static_postfix}}" -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
       - name: "Static Debug: Build"
         run: cmake --build build-static-dbg
       - name: "Static Debug: Test"
@@ -49,7 +49,7 @@ jobs:
 
       # Shared Debug
       - name: "Shared Debug: Configure"
-        run: cmake -G Ninja -S . -B build-shared-dbg -DCMAKE_BUILD_TYPE=Debug -DCMAKE_DEBUG_POSTFIX=d -DBUILD_SHARED_LIBS=ON
+        run: cmake -G Ninja -S . -B build-shared-dbg -DCMAKE_BUILD_TYPE=Debug -DCMAKE_DEBUG_POSTFIX=d -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
       - name: "Shared Debug: Build"
         run: cmake --build build-shared-dbg
       - name: "Shared Debug: Test"
@@ -58,7 +58,7 @@ jobs:
 
       # Static Release
       - name: "Static Release: Configure"
-        run: cmake -G Ninja -S . -B build-static-rel -DCMAKE_BUILD_TYPE=Release "-DCMAKE_RELEASE_POSTFIX=${{matrix.static_postfix}}"
+        run: cmake -G Ninja -S . -B build-static-rel -DCMAKE_BUILD_TYPE=Release "-DCMAKE_RELEASE_POSTFIX=${{matrix.static_postfix}}" -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
       - name: "Static Release: Build"
         run: cmake --build build-static-rel
       - name: "Static Release: Test"
@@ -67,7 +67,7 @@ jobs:
 
       # Shared Release
       - name: "Shared Release: Configure"
-        run: cmake -G Ninja -S . -B build-shared-rel -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
+        run: cmake -G Ninja -S . -B build-shared-rel -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
       - name: "Shared Release: Build"
         run: cmake --build build-shared-rel
       - name: "Shared Release: Test"
@@ -89,23 +89,23 @@ jobs:
         run: >-
           ctest --build-and-test test test-static-dbg
           --build-generator Ninja
-          --build-options -DCMAKE_BUILD_TYPE=Debug -Dtinyxml2_SHARED_LIBS=NO -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
+          --build-options -DCMAKE_BUILD_TYPE=Debug -Dtinyxml2_SHARED_LIBS=NO -DCMAKE_PREFIX_PATH=${{github.workspace}}/install -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
           --test-command ctest --output-on-failure
       - name: "Test find_package: Static Release"
         run: >-
           ctest --build-and-test test test-static-rel
           --build-generator Ninja
-          --build-options -DCMAKE_BUILD_TYPE=Release -Dtinyxml2_SHARED_LIBS=NO -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
+          --build-options -DCMAKE_BUILD_TYPE=Release -Dtinyxml2_SHARED_LIBS=NO -DCMAKE_PREFIX_PATH=${{github.workspace}}/install -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
           --test-command ctest --output-on-failure
       - name: "Test find_package: Shared Debug"
         run: >-
           ctest --build-and-test test test-shared-dbg
           --build-generator Ninja
-          --build-options -DCMAKE_BUILD_TYPE=Debug -Dtinyxml2_SHARED_LIBS=YES -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
+          --build-options -DCMAKE_BUILD_TYPE=Debug -Dtinyxml2_SHARED_LIBS=YES -DCMAKE_PREFIX_PATH=${{github.workspace}}/install -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
           --test-command ctest --output-on-failure
       - name: "Test find_package: Shared Release"
         run: >-
           ctest --build-and-test test test-shared-rel
           --build-generator Ninja
-          --build-options -DCMAKE_BUILD_TYPE=Release -Dtinyxml2_SHARED_LIBS=YES -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
+          --build-options -DCMAKE_BUILD_TYPE=Release -Dtinyxml2_SHARED_LIBS=YES -DCMAKE_PREFIX_PATH=${{github.workspace}}/install -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON
           --test-command ctest --output-on-failure

CMakeLists.txt

@@ -22,8 +22,8 @@ set(CMAKE_VISIBILITY_INLINES_HIDDEN YES)
 add_library(tinyxml2 tinyxml2.cpp tinyxml2.h)
 add_library(tinyxml2::tinyxml2 ALIAS tinyxml2)
 
-# Uncomment the following line to require C++11 (or greater) to use tinyxml2
-# target_compile_features(tinyxml2 PUBLIC cxx_std_11)
+# Require C++11 (or greater) to use tinyxml2
+target_compile_features(tinyxml2 PUBLIC cxx_std_11)
 target_include_directories(tinyxml2 PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>")
 
 target_compile_definitions(

readme.md

@@ -5,6 +5,8 @@
 TinyXML-2 is a simple, small, efficient, C++ XML parser that can be
 easily integrated into other programs.
 
+It is written in C++ 11 and does not use any Standard Library (std::) features.
+
 The master is hosted on GitHub:
 https://github.com/leethomason/tinyxml2
 

tinyxml2.cpp

@@ -154,12 +154,12 @@ void StrPair::TransferTo( StrPair* other )
         return;
     }
     // This in effect implements the assignment operator by "moving"
-    // ownership (as in auto_ptr).
+    // ownership (as in unique_ptr / move semantics).
 
-    TIXMLASSERT( other != 0 );
+    TIXMLASSERT( other != nullptr );
     TIXMLASSERT( other->_flags == 0 );
-    TIXMLASSERT( other->_start == 0 );
-    TIXMLASSERT( other->_end == 0 );
+    TIXMLASSERT( other->_start == nullptr );
+    TIXMLASSERT( other->_end == nullptr );
 
     other->Reset();
 
@@ -168,8 +168,8 @@ void StrPair::TransferTo( StrPair* other )
     other->_end = _end;
 
     _flags = 0;
-    _start = 0;
-    _end = 0;
+    _start = nullptr;
+    _end = nullptr;
 }
 
 
@@ -179,8 +179,8 @@ void StrPair::Reset()
         delete [] _start;
     }
     _flags = 0;
-    _start = 0;
-    _end = 0;
+    _start = nullptr;
+    _end = nullptr;
 }
 
 
@@ -189,7 +189,7 @@ void StrPair::SetStr( const char* str, int flags )
     TIXMLASSERT( str );
     Reset();
     size_t len = strlen( str );
-    TIXMLASSERT( _start == 0 );
+    TIXMLASSERT( _start == nullptr );
     _start = new char[ len+1 ];
     memcpy( _start, str, len+1 );
     _end = _start + len;
@@ -218,17 +218,17 @@ char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLin
         ++p;
         TIXMLASSERT( p );
     }
-    return 0;
+    return nullptr;
 }
 
 
 char* StrPair::ParseName( char* p )
 {
     if ( !p || !(*p) ) {
-        return 0;
+        return nullptr;
     }
     if ( !XMLUtil::IsNameStartChar( static_cast<unsigned char>(*p) ) ) {
-        return 0;
+        return nullptr;
     }
 
     char* const start = p;
@@ -318,7 +318,7 @@ const char* StrPair::GetStr()
                         char buf[buflen] = { 0 };
                         int len = 0;
                         const char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
-                        if ( adjusted == 0 ) {
+                        if ( adjusted == nullptr ) {
                             *q = *p;
                             ++p;
                             ++q;
@@ -475,7 +475,7 @@ const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
 
         bool hex = false;
         uint32_t radix = 10;
-        const char* q = 0;
+        const char* q = nullptr;
         char terminator = '#';
 
         if (*(p + 2) == 'x') {
@@ -491,12 +491,12 @@ const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
             q = p + 2;
         }
         if (!(*q)) {
-            return 0;
+            return nullptr;
         }
 
         q = strchr(q, SEMICOLON);
         if (!q) {
-            return 0;
+            return nullptr;
         }
         TIXMLASSERT(*q == SEMICOLON);
 
@@ -516,7 +516,7 @@ const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
                 digit = *q - 'A' + 10;
             }
             else {
-                return 0;
+                return nullptr;
             }
             TIXMLASSERT(digit < radix);
 
@@ -526,7 +526,7 @@ const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
             // testing ucs > MAX_CODE_POINT - digitScaled, safe since digitScaled
             // <= MAX_CODE_POINT at this point).
             if (digitScaled > MAX_CODE_POINT || ucs > MAX_CODE_POINT - digitScaled) {
-                return 0;
+                return nullptr;
             }
             ucs += digitScaled;
             mult *= radix;
@@ -537,14 +537,14 @@ const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
         }
         // Out of range:
         if (ucs > MAX_CODE_POINT) {
-            return 0;
+            return nullptr;
         }
         // convert the UCS to UTF-8
         ConvertUTF32ToUTF8(ucs, value, length);
         if (*length == 0) {
             // If *length is 0, ConvertUTF32ToUTF8 rejected the code point.
             // Fail safely.
-            return 0;
+            return nullptr;
         }
         return p + delta + 1;
     }
@@ -628,8 +628,8 @@ bool XMLUtil::ToBool( const char* str, bool* value )
         *value = (ival==0) ? false : true;
         return true;
     }
-    static const char* TRUE_VALS[] = { "true", "True", "TRUE", 0 };
-    static const char* FALSE_VALS[] = { "false", "False", "FALSE", 0 };
+    static const char* TRUE_VALS[] = { "true", "True", "TRUE", nullptr };
+    static const char* FALSE_VALS[] = { "false", "False", "FALSE", nullptr };
 
     for (int i = 0; TRUE_VALS[i]; ++i) {
         if (StringEqual(str, TRUE_VALS[i])) {
@@ -703,7 +703,7 @@ char* XMLDocument::Identify( char* p, XMLNode** node, bool first )
     int const startLine = _parseCurLineNum;
     p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
     if( !*p ) {
-        *node = 0;
+        *node = nullptr;
         TIXMLASSERT( p );
         return p;
     }
@@ -723,7 +723,7 @@ char* XMLDocument::Identify( char* p, XMLNode** node, bool first )
 
     TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) );		// use same memory pool
     TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) );	// use same memory pool
-    XMLNode* returnNode = 0;
+    XMLNode* returnNode = nullptr;
     if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
         returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
         returnNode->_parseLineNum = _parseCurLineNum;
@@ -793,13 +793,13 @@ bool XMLDocument::Accept( XMLVisitor* visitor ) const
 
 XMLNode::XMLNode( XMLDocument* doc ) :
     _document( doc ),
-    _parent( 0 ),
+    _parent( nullptr ),
     _value(),
     _parseLineNum( 0 ),
-    _firstChild( 0 ), _lastChild( 0 ),
-    _prev( 0 ), _next( 0 ),
-	_userData( 0 ),
-    _memPool( 0 )
+    _firstChild( nullptr ), _lastChild( nullptr ),
+    _prev( nullptr ), _next( nullptr ),
+	_userData( nullptr ),
+    _memPool( nullptr )
 {
 }
 
@@ -810,9 +810,9 @@ XMLNode::~XMLNode()
     // sibling _prev/_next links is unnecessary. Only _parent must be zeroed to
     // satisfy the MarkInUse assertion inside DeleteNode.
     XMLNode *currentChild = _firstChild;
-    while (currentChild != NULL) {
+    while (currentChild != nullptr) {
         XMLNode *next = currentChild->_next;
-        currentChild->_parent = 0;
+        currentChild->_parent = nullptr;
         DeleteNode(currentChild);
         currentChild = next;
     }
@@ -854,7 +854,7 @@ const char* XMLNode::Value() const
 {
     // Edge case: XMLDocuments don't have a Value. Return null.
     if ( this->ToDocument() )
-        return 0;
+        return nullptr;
     return _value.GetStr();
 }
 
@@ -871,7 +871,7 @@ void XMLNode::SetValue( const char* str, bool staticMem )
 XMLNode* XMLNode::DeepClone(XMLDocument* target) const
 {
 	XMLNode* clone = this->ShallowClone(target);
-	if (!clone) return 0;
+	if (!clone) return nullptr;
 
 	for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
 		XMLNode* childClone = child->DeepClone(target);
@@ -887,7 +887,7 @@ void XMLNode::DeleteChildren()
         TIXMLASSERT( _lastChild );
         DeleteChild( _firstChild );
     }
-    _firstChild = _lastChild = 0;
+    _firstChild = _lastChild = nullptr;
 }
 
 
@@ -909,9 +909,9 @@ void XMLNode::Unlink( XMLNode* child )
     if ( child->_next ) {
         child->_next->_prev = child->_prev;
     }
-	child->_next = 0;
-	child->_prev = 0;
-	child->_parent = 0;
+	child->_next = nullptr;
+	child->_prev = nullptr;
+	child->_parent = nullptr;
 }
 
 
@@ -921,9 +921,9 @@ void XMLNode::DeleteChild( XMLNode* node )
     TIXMLASSERT( node->_document == _document );
     TIXMLASSERT( node->_parent == this );
     Unlink( node );
-	TIXMLASSERT(node->_prev == 0);
-	TIXMLASSERT(node->_next == 0);
-	TIXMLASSERT(node->_parent == 0);
+	TIXMLASSERT(node->_prev == nullptr);
+	TIXMLASSERT(node->_next == nullptr);
+	TIXMLASSERT(node->_parent == nullptr);
     DeleteNode( node );
 }
 
@@ -933,25 +933,25 @@ XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
     TIXMLASSERT( addThis );
     if ( addThis->_document != _document ) {
         TIXMLASSERT( false );
-        return 0;
+        return nullptr;
     }
     InsertChildPreamble( addThis );
 
     if ( _lastChild ) {
         TIXMLASSERT( _firstChild );
-        TIXMLASSERT( _lastChild->_next == 0 );
+        TIXMLASSERT( _lastChild->_next == nullptr );
         _lastChild->_next = addThis;
         addThis->_prev = _lastChild;
         _lastChild = addThis;
 
-        addThis->_next = 0;
+        addThis->_next = nullptr;
     }
     else {
-        TIXMLASSERT( _firstChild == 0 );
+        TIXMLASSERT( _firstChild == nullptr );
         _firstChild = _lastChild = addThis;
 
-        addThis->_prev = 0;
-        addThis->_next = 0;
+        addThis->_prev = nullptr;
+        addThis->_next = nullptr;
     }
     addThis->_parent = this;
     return addThis;
@@ -963,26 +963,26 @@ XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
     TIXMLASSERT( addThis );
     if ( addThis->_document != _document ) {
         TIXMLASSERT( false );
-        return 0;
+        return nullptr;
     }
     InsertChildPreamble( addThis );
 
     if ( _firstChild ) {
         TIXMLASSERT( _lastChild );
-        TIXMLASSERT( _firstChild->_prev == 0 );
+        TIXMLASSERT( _firstChild->_prev == nullptr );
 
         _firstChild->_prev = addThis;
         addThis->_next = _firstChild;
         _firstChild = addThis;
 
-        addThis->_prev = 0;
+        addThis->_prev = nullptr;
     }
     else {
-        TIXMLASSERT( _lastChild == 0 );
+        TIXMLASSERT( _lastChild == nullptr );
         _firstChild = _lastChild = addThis;
 
-        addThis->_prev = 0;
-        addThis->_next = 0;
+        addThis->_prev = nullptr;
+        addThis->_next = nullptr;
     }
     addThis->_parent = this;
     return addThis;
@@ -994,14 +994,14 @@ XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
     TIXMLASSERT( addThis );
     if ( addThis->_document != _document ) {
         TIXMLASSERT( false );
-        return 0;
+        return nullptr;
     }
 
     TIXMLASSERT( afterThis );
 
     if ( afterThis->_parent != this ) {
         TIXMLASSERT( false );
-        return 0;
+        return nullptr;
     }
     if ( afterThis == addThis ) {
         // Current state: BeforeThis -> AddThis -> OneAfterAddThis
@@ -1011,7 +1011,7 @@ XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
         return addThis;
     }
 
-    if ( afterThis->_next == 0 ) {
+    if ( afterThis->_next == nullptr ) {
         // The last node or the only node.
         return InsertEndChild( addThis );
     }
@@ -1035,7 +1035,7 @@ const XMLElement* XMLNode::FirstChildElement( const char* name ) const
             return element;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1047,7 +1047,7 @@ const XMLElement* XMLNode::LastChildElement( const char* name ) const
             return element;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1059,7 +1059,7 @@ const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
             return element;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1071,7 +1071,7 @@ const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
             return element;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1096,15 +1096,15 @@ char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
 
 	XMLDocument::DepthTracker tracker(_document);
 	if (_document->Error())
-		return 0;
+		return nullptr;
 
 	bool first = true;
 	while( p && *p ) {
-        XMLNode* node = 0;
+        XMLNode* node = nullptr;
 
         p = _document->Identify( p, &node, first );
         TIXMLASSERT( p );
-        if ( node == 0 ) {
+        if ( node == nullptr ) {
             break;
         }
         first = false;
@@ -1116,7 +1116,7 @@ char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
         if ( !p ) {
             _document->DeleteNode( node );
             if ( !_document->Error() ) {
-                _document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
+                _document->SetError( XML_ERROR_PARSING, initialLineNum, nullptr);
             }
             break;
         }
@@ -1188,12 +1188,12 @@ char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
         }
         InsertEndChild( node );
     }
-    return 0;
+    return nullptr;
 }
 
 /*static*/ void XMLNode::DeleteNode( XMLNode* node )
 {
-    if ( node == 0 ) {
+    if ( node == nullptr ) {
         return;
     }
 	TIXMLASSERT(node->_document);
@@ -1223,16 +1223,16 @@ void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
 const XMLElement* XMLNode::ToElementWithName( const char* name ) const
 {
     const XMLElement* element = this->ToElement();
-    if ( element == 0 ) {
-        return 0;
+    if ( element == nullptr ) {
+        return nullptr;
     }
-    if ( name == 0 ) {
+    if ( name == nullptr ) {
         return element;
     }
     if ( XMLUtil::StringEqual( element->Name(), name ) ) {
        return element;
     }
-    return 0;
+    return nullptr;
 }
 
 // --------- XMLText ---------- //
@@ -1256,10 +1256,10 @@ char* XMLText::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
             return p-1;
         }
         if ( !p ) {
-            _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
+            _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, nullptr );
         }
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1305,7 +1305,7 @@ char* XMLComment::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
 {
     // Comment parses as text.
     p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
-    if ( p == 0 ) {
+    if ( p == nullptr ) {
         _document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
     }
     return p;
@@ -1354,7 +1354,7 @@ char* XMLDeclaration::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
 {
     // Declaration parses as text.
     p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
-    if ( p == 0 ) {
+    if ( p == nullptr ) {
         _document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
     }
     return p;
@@ -1450,19 +1450,19 @@ char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr
     // Parse using the name rules: bug fix, was using ParseText before
     p = _name.ParseName( p );
     if ( !p || !*p ) {
-        return 0;
+        return nullptr;
     }
 
     // Skip white space before =
     p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
     if ( *p != '=' ) {
-        return 0;
+        return nullptr;
     }
 
     ++p;	// move up to opening quote
     p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
     if ( *p != '\"' && *p != '\'' ) {
-        return 0;
+        return nullptr;
     }
 
     const char endTag[2] = { *p, 0 };
@@ -1604,7 +1604,7 @@ void XMLAttribute::SetAttribute( float v )
 // --------- XMLElement ---------- //
 XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
     _closingType( OPEN ),
-    _rootAttribute( 0 )
+    _rootAttribute( nullptr )
 {
 }
 
@@ -1626,7 +1626,7 @@ const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
             return a;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1634,12 +1634,12 @@ const char* XMLElement::Attribute( const char* name, const char* value ) const
 {
     const XMLAttribute* a = FindAttribute( name );
     if ( !a ) {
-        return 0;
+        return nullptr;
     }
     if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
         return a->Value();
     }
-    return 0;
+    return nullptr;
 }
 
 int XMLElement::IntAttribute(const char* name, int defaultValue) const
@@ -1706,7 +1706,7 @@ const char* XMLElement::GetText() const
     if ( node && node->ToText() ) {
         return node->Value();
     }
-    return 0;
+    return nullptr;
 }
 
 
@@ -1917,8 +1917,8 @@ float XMLElement::FloatText(float defaultValue) const
 
 XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
 {
-    XMLAttribute* last = 0;
-    XMLAttribute* attrib = 0;
+    XMLAttribute* last = nullptr;
+    XMLAttribute* attrib = nullptr;
     for( attrib = _rootAttribute;
             attrib;
             last = attrib, attrib = attrib->_next ) {
@@ -1930,11 +1930,11 @@ XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
         attrib = CreateAttribute();
         TIXMLASSERT( attrib );
         if ( last ) {
-            TIXMLASSERT( last->_next == 0 );
+            TIXMLASSERT( last->_next == nullptr );
             last->_next = attrib;
         }
         else {
-            TIXMLASSERT( _rootAttribute == 0 );
+            TIXMLASSERT( _rootAttribute == nullptr );
             _rootAttribute = attrib;
         }
         attrib->SetName( name );
@@ -1945,7 +1945,7 @@ XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
 
 void XMLElement::DeleteAttribute( const char* name )
 {
-    XMLAttribute* prev = 0;
+    XMLAttribute* prev = nullptr;
     for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
         if ( XMLUtil::StringEqual( name, a->Name() ) ) {
             if ( prev ) {
@@ -1964,14 +1964,14 @@ void XMLElement::DeleteAttribute( const char* name )
 
 char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
 {
-    XMLAttribute* prevAttribute = 0;
+    XMLAttribute* prevAttribute = nullptr;
 
     // Read the attributes.
     while( p ) {
         p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
         if ( !(*p) ) {
             _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
-            return 0;
+            return nullptr;
         }
 
         // attribute.
@@ -1986,7 +1986,7 @@ char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
             if ( !p || Attribute( attrib->Name() ) ) {
                 DeleteAttribute( attrib );
                 _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
-                return 0;
+                return nullptr;
             }
             // There is a minor bug here: if the attribute in the source xml
             // document is duplicated, it will not be detected and the
@@ -1994,11 +1994,11 @@ char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
             // avoids re-scanning the attribute list. Preferring performance for
             // now, may reconsider in the future.
             if ( prevAttribute ) {
-                TIXMLASSERT( prevAttribute->_next == 0 );
+                TIXMLASSERT( prevAttribute->_next == nullptr );
                 prevAttribute->_next = attrib;
             }
             else {
-                TIXMLASSERT( _rootAttribute == 0 );
+                TIXMLASSERT( _rootAttribute == nullptr );
                 _rootAttribute = attrib;
             }
             prevAttribute = attrib;
@@ -2014,8 +2014,8 @@ char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
             return p+2;	// done; sealed element.
         }
         else {
-            _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
-            return 0;
+            _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, nullptr );
+            return nullptr;
         }
     }
     return p;
@@ -2023,7 +2023,7 @@ char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
 
 void XMLElement::DeleteAttribute( XMLAttribute* attribute )
 {
-    if ( attribute == 0 ) {
+    if ( attribute == nullptr ) {
         return;
     }
     MemPool* pool = attribute->_memPool;
@@ -2093,7 +2093,7 @@ char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr
 
     p = _value.ParseName( p );
     if ( _value.Empty() ) {
-        return 0;
+        return nullptr;
     }
 
     p = ParseAttributes( p, curLineNumPtr );
@@ -2187,14 +2187,14 @@ const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
 
 
 XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
-    XMLNode( 0 ),
+    XMLNode( nullptr ),
     _writeBOM( false ),
     _processEntities( processEntities ),
     _errorID(XML_SUCCESS),
     _whitespaceMode( whitespaceMode ),
     _errorStr(),
     _errorLineNum( 0 ),
-    _charBuffer( 0 ),
+    _charBuffer( nullptr ),
     _parseCurLineNum( 0 ),
 	_parsingDepth(0),
     _unlinked(),
@@ -2217,7 +2217,7 @@ XMLDocument::~XMLDocument()
 void XMLDocument::MarkInUse(const XMLNode* const node)
 {
 	TIXMLASSERT(node);
-	TIXMLASSERT(node->_parent == 0);
+	TIXMLASSERT(node->_parent == nullptr);
 
 	for (size_t i = 0; i < _unlinked.Size(); ++i) {
 		if (node == _unlinked[i]) {
@@ -2240,7 +2240,7 @@ void XMLDocument::Clear()
     ClearError();
 
     delete [] _charBuffer;
-    _charBuffer = 0;
+    _charBuffer = nullptr;
 	_parsingDepth = 0;
     
 #if 0
@@ -2318,10 +2318,10 @@ static FILE* callfopen( const char* filepath, const char* mode )
     TIXMLASSERT( filepath );
     TIXMLASSERT( mode );
 #if defined(_MSC_VER) && (_MSC_VER >= 1400)
-    FILE* fp = 0;
+    FILE* fp = nullptr;
     const errno_t err = fopen_s( &fp, filepath, mode );
     if ( err ) {
-        return 0;
+        return nullptr;
     }
 #else
     FILE* fp = fopen( filepath, mode );
@@ -2329,8 +2329,8 @@ static FILE* callfopen( const char* filepath, const char* mode )
     return fp;
 }
 
-void XMLDocument::DeleteNode( XMLNode* node )	{   
-    if(node == 0) {
+void XMLDocument::DeleteNode( XMLNode* node )	{
+    if(node == nullptr) {
         return; // check for null pointer
     }
     TIXMLASSERT(node->_document == this);
@@ -2407,7 +2407,7 @@ XMLError XMLDocument::LoadFile( FILE* fp )
     }
 
     const size_t size = static_cast<size_t>(filelength);
-    TIXMLASSERT( _charBuffer == 0 );
+    TIXMLASSERT( _charBuffer == nullptr );
     _charBuffer = new char[size+1];
     const size_t read = fread( _charBuffer, 1, size, fp );
     if ( read != size ) {
@@ -2463,7 +2463,7 @@ XMLError XMLDocument::Parse( const char* xml, size_t nBytes )
     if ( nBytes == static_cast<size_t>(-1) ) {
         nBytes = strlen( xml );
     }
-    TIXMLASSERT( _charBuffer == 0 );
+    TIXMLASSERT( _charBuffer == nullptr );
     _charBuffer = new char[ nBytes+1 ];
     memcpy( _charBuffer, xml, nBytes );
     _charBuffer[nBytes] = 0;
@@ -2489,7 +2489,7 @@ void XMLDocument::Print( XMLPrinter* streamer ) const
         Accept( streamer );
     }
     else {
-        XMLPrinter stdoutStreamer( stdout );
+        XMLPrinter stdoutStreamer( stdout );  // file=stdout, not nullptr
         Accept( &stdoutStreamer );
     }
 }
@@ -2568,7 +2568,7 @@ void XMLDocument::Parse()
         SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
         return;
     }
-    ParseDeep(p, 0, &_parseCurLineNum );
+    ParseDeep(p, nullptr, &_parseCurLineNum );
 }
 
 void XMLDocument::PushDepth()
@@ -2979,7 +2979,7 @@ bool XMLPrinter::VisitEnter( const XMLDocument& doc )
 
 bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
 {
-    const XMLElement* parentElem = 0;
+    const XMLElement* parentElem = nullptr;
     if ( element.Parent() ) {
         parentElem = element.Parent()->ToElement();
     }

tinyxml2.h

@@ -37,7 +37,7 @@ distribution.
 #   include <cstdlib>
 #   include <cstring>
 #endif
-#include <stdint.h>
+#include <cstdint>
 
 #if defined( _DEBUG ) || defined (__DEBUG__)
 #   ifndef TINYXML2_DEBUG
@@ -143,7 +143,7 @@ public:
         COMMENT							= NEEDS_NEWLINE_NORMALIZATION
     };
 
-    StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
+    StrPair() : _flags( 0 ), _start( nullptr ), _end( nullptr ) {}
     ~StrPair();
 
     void Set( char* start, char* end, int flags ) {
@@ -186,8 +186,8 @@ private:
     char*   _start;
     char*   _end;
 
-    StrPair( const StrPair& other );	// not supported
-    void operator=( const StrPair& other );	// not supported, use TransferTo()
+    StrPair( const StrPair& ) = delete;
+    StrPair& operator=( const StrPair& ) = delete;
 };
 
 
@@ -289,8 +289,8 @@ public:
     }
 
 private:
-    DynArray( const DynArray& ); // not supported
-    void operator=( const DynArray& ); // not supported
+    DynArray( const DynArray& ) = delete;
+    DynArray& operator=( const DynArray& ) = delete;
 
     void EnsureCapacity( size_t cap ) {
         TIXMLASSERT( cap > 0 );
@@ -339,7 +339,7 @@ template< size_t ITEM_SIZE >
 class MemPoolT : public MemPool
 {
 public:
-    MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0)	{}
+    MemPoolT() : _blockPtrs(), _root(nullptr), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0)	{}
     ~MemPoolT() {
         MemPoolT< ITEM_SIZE >::Clear();
     }
@@ -350,7 +350,7 @@ public:
             Block* lastBlock = _blockPtrs.Pop();
             delete lastBlock;
         }
-        _root = 0;
+        _root = nullptr;
         _currentAllocs = 0;
         _nAllocs = 0;
         _maxAllocs = 0;
@@ -374,11 +374,11 @@ public:
             for( size_t i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
                 blockItems[i].next = &(blockItems[i + 1]);
             }
-            blockItems[ITEMS_PER_BLOCK - 1].next = 0;
+            blockItems[ITEMS_PER_BLOCK - 1].next = nullptr;
             _root = blockItems;
         }
         Item* const result = _root;
-        TIXMLASSERT( result != 0 );
+        TIXMLASSERT( result != nullptr );
         _root = _root->next;
 
         ++_currentAllocs;
@@ -430,8 +430,8 @@ public:
     enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
 
 private:
-    MemPoolT( const MemPoolT& ); // not supported
-    void operator=( const MemPoolT& ); // not supported
+    MemPoolT( const MemPoolT& ) = delete;
+    MemPoolT& operator=( const MemPoolT& ) = delete;
 
     union Item {
         Item*   next;
@@ -682,46 +682,46 @@ public:
 
     /// Safely cast to an Element, or null.
     virtual XMLElement*		ToElement()		{
-        return 0;
+        return nullptr;
     }
     /// Safely cast to Text, or null.
     virtual XMLText*		ToText()		{
-        return 0;
+        return nullptr;
     }
     /// Safely cast to a Comment, or null.
     virtual XMLComment*		ToComment()		{
-        return 0;
+        return nullptr;
     }
     /// Safely cast to a Document, or null.
     virtual XMLDocument*	ToDocument()	{
-        return 0;
+        return nullptr;
     }
     /// Safely cast to a Declaration, or null.
     virtual XMLDeclaration*	ToDeclaration()	{
-        return 0;
+        return nullptr;
     }
     /// Safely cast to an Unknown, or null.
     virtual XMLUnknown*		ToUnknown()		{
-        return 0;
+        return nullptr;
     }
 
     virtual const XMLElement*		ToElement() const		{
-        return 0;
+        return nullptr;
     }
     virtual const XMLText*			ToText() const			{
-        return 0;
+        return nullptr;
     }
     virtual const XMLComment*		ToComment() const		{
-        return 0;
+        return nullptr;
     }
     virtual const XMLDocument*		ToDocument() const		{
-        return 0;
+        return nullptr;
     }
     virtual const XMLDeclaration*	ToDeclaration() const	{
-        return 0;
+        return nullptr;
     }
     virtual const XMLUnknown*		ToUnknown() const		{
-        return 0;
+        return nullptr;
     }
 
     // ChildElementCount was originally suggested by msteiger on the sourceforge page for TinyXML and modified by KB1SPH for TinyXML-2.
@@ -775,9 +775,9 @@ public:
     /** Get the first child element, or optionally the first child
         element with the specified name.
     */
-    const XMLElement* FirstChildElement( const char* name = 0 ) const;
+    const XMLElement* FirstChildElement( const char* name = nullptr ) const;
 
-    XMLElement* FirstChildElement( const char* name = 0 )	{
+    XMLElement* FirstChildElement( const char* name = nullptr )	{
         return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( name ));
     }
 
@@ -793,9 +793,9 @@ public:
     /** Get the last child element or optionally the last child
         element with the specified name.
     */
-    const XMLElement* LastChildElement( const char* name = 0 ) const;
+    const XMLElement* LastChildElement( const char* name = nullptr ) const;
 
-    XMLElement* LastChildElement( const char* name = 0 )	{
+    XMLElement* LastChildElement( const char* name = nullptr )	{
         return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name) );
     }
 
@@ -809,9 +809,9 @@ public:
     }
 
     /// Get the previous (left) sibling element of this node, with an optionally supplied name.
-    const XMLElement*	PreviousSiblingElement( const char* name = 0 ) const ;
+    const XMLElement*	PreviousSiblingElement( const char* name = nullptr ) const ;
 
-    XMLElement*	PreviousSiblingElement( const char* name = 0 ) {
+    XMLElement*	PreviousSiblingElement( const char* name = nullptr ) {
         return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( name ) );
     }
 
@@ -825,9 +825,9 @@ public:
     }
 
     /// Get the next (right) sibling element of this node, with an optionally supplied name.
-    const XMLElement*	NextSiblingElement( const char* name = 0 ) const;
+    const XMLElement*	NextSiblingElement( const char* name = nullptr ) const;
 
-    XMLElement*	NextSiblingElement( const char* name = 0 )	{
+    XMLElement*	NextSiblingElement( const char* name = nullptr )	{
         return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( name ) );
     }
 
@@ -969,8 +969,8 @@ private:
     void InsertChildPreamble( XMLNode* insertThis ) const;
     const XMLElement* ToElementWithName( const char* name ) const;
 
-    XMLNode( const XMLNode& );	// not supported
-    XMLNode& operator=( const XMLNode& );	// not supported
+    XMLNode( const XMLNode& ) = delete;
+    XMLNode& operator=( const XMLNode& ) = delete;
 };
 
 
@@ -1020,8 +1020,8 @@ protected:
 private:
     bool _isCData;
 
-    XMLText( const XMLText& );	// not supported
-    XMLText& operator=( const XMLText& );	// not supported
+    XMLText( const XMLText& ) = delete;
+    XMLText& operator=( const XMLText& ) = delete;
 };
 
 
@@ -1049,8 +1049,8 @@ protected:
     char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr) override;
 
 private:
-    XMLComment( const XMLComment& );	// not supported
-    XMLComment& operator=( const XMLComment& );	// not supported
+    XMLComment( const XMLComment& ) = delete;
+    XMLComment& operator=( const XMLComment& ) = delete;
 };
 
 
@@ -1088,8 +1088,8 @@ protected:
     char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr ) override;
 
 private:
-    XMLDeclaration( const XMLDeclaration& );	// not supported
-    XMLDeclaration& operator=( const XMLDeclaration& );	// not supported
+    XMLDeclaration( const XMLDeclaration& ) = delete;
+    XMLDeclaration& operator=( const XMLDeclaration& ) = delete;
 };
 
 
@@ -1123,8 +1123,8 @@ protected:
     char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr ) override;
 
 private:
-    XMLUnknown( const XMLUnknown& );	// not supported
-    XMLUnknown& operator=( const XMLUnknown& );	// not supported
+    XMLUnknown( const XMLUnknown& ) = delete;
+    XMLUnknown& operator=( const XMLUnknown& ) = delete;
 };
 
 
@@ -1238,11 +1238,11 @@ public:
 private:
     enum { BUF_SIZE = 200 };
 
-    XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( 0 ), _memPool( 0 ) {}
+    XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( nullptr ), _memPool( nullptr ) {}
     virtual ~XMLAttribute()	{}
 
-    XMLAttribute( const XMLAttribute& );	// not supported
-    void operator=( const XMLAttribute& );	// not supported
+    XMLAttribute( const XMLAttribute& ) = delete;
+    XMLAttribute& operator=( const XMLAttribute& ) = delete;
     void SetName( const char* name );
 
     char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );
@@ -1303,7 +1303,7 @@ public:
     	}
     	@endverbatim
     */
-    const char* Attribute( const char* name, const char* value=0 ) const;
+    const char* Attribute( const char* name, const char* value=nullptr ) const;
 
     /** Given an attribute name, IntAttribute() returns the value
     	of the attribute interpreted as an integer. The default
@@ -1683,8 +1683,8 @@ protected:
 private:
     XMLElement( XMLDocument* doc );
     virtual ~XMLElement();
-    XMLElement( const XMLElement& );	// not supported
-    void operator=( const XMLElement& );	// not supported
+    XMLElement( const XMLElement& ) = delete;
+    XMLElement& operator=( const XMLElement& ) = delete;
 
     XMLAttribute* FindOrCreateAttribute( const char* name );
     char* ParseAttributes( char* p, int* curLineNumPtr );
@@ -1827,7 +1827,7 @@ public:
     	// printer.CStr() has a const char* to the XML
     	@endverbatim
     */
-    void Print( XMLPrinter* streamer=0 ) const;
+    void Print( XMLPrinter* streamer=nullptr ) const;
     virtual bool Accept( XMLVisitor* visitor ) const override;
 
     /**
@@ -1859,7 +1859,7 @@ public:
     		<?xml version="1.0" encoding="UTF-8"?>
     	@endverbatim
     */
-    XMLDeclaration* NewDeclaration( const char* text=0 );
+    XMLDeclaration* NewDeclaration( const char* text=nullptr );
     /**
     	Create a new Unknown associated with
     	this Document. The memory for the object
@@ -1927,8 +1927,8 @@ public:
     }
 
 private:
-    XMLDocument( const XMLDocument& );	// not supported
-    void operator=( const XMLDocument& );	// not supported
+    XMLDocument( const XMLDocument& ) = delete;
+    XMLDocument& operator=( const XMLDocument& ) = delete;
 
     bool			_writeBOM;
     bool			_processEntities;
@@ -2068,35 +2068,35 @@ public:
 
     /// Get the first child of this handle.
     XMLHandle FirstChild() 													{
-        return XMLHandle( _node ? _node->FirstChild() : 0 );
+        return XMLHandle( _node ? _node->FirstChild() : nullptr );
     }
     /// Get the first child element of this handle.
-    XMLHandle FirstChildElement( const char* name = 0 )						{
-        return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
+    XMLHandle FirstChildElement( const char* name = nullptr )						{
+        return XMLHandle( _node ? _node->FirstChildElement( name ) : nullptr );
     }
     /// Get the last child of this handle.
     XMLHandle LastChild()													{
-        return XMLHandle( _node ? _node->LastChild() : 0 );
+        return XMLHandle( _node ? _node->LastChild() : nullptr );
     }
     /// Get the last child element of this handle.
-    XMLHandle LastChildElement( const char* name = 0 )						{
-        return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
+    XMLHandle LastChildElement( const char* name = nullptr )						{
+        return XMLHandle( _node ? _node->LastChildElement( name ) : nullptr );
     }
     /// Get the previous sibling of this handle.
     XMLHandle PreviousSibling()												{
-        return XMLHandle( _node ? _node->PreviousSibling() : 0 );
+        return XMLHandle( _node ? _node->PreviousSibling() : nullptr );
     }
     /// Get the previous sibling element of this handle.
-    XMLHandle PreviousSiblingElement( const char* name = 0 )				{
-        return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
+    XMLHandle PreviousSiblingElement( const char* name = nullptr )				{
+        return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : nullptr );
     }
     /// Get the next sibling of this handle.
     XMLHandle NextSibling()													{
-        return XMLHandle( _node ? _node->NextSibling() : 0 );
+        return XMLHandle( _node ? _node->NextSibling() : nullptr );
     }
     /// Get the next sibling element of this handle.
-    XMLHandle NextSiblingElement( const char* name = 0 )					{
-        return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
+    XMLHandle NextSiblingElement( const char* name = nullptr )					{
+        return XMLHandle( _node ? _node->NextSiblingElement( name ) : nullptr );
     }
 
     /// Safe cast to XMLNode. This can return null.
@@ -2105,19 +2105,19 @@ public:
     }
     /// Safe cast to XMLElement. This can return null.
     XMLElement* ToElement() 					{
-        return ( _node ? _node->ToElement() : 0 );
+        return ( _node ? _node->ToElement() : nullptr );
     }
     /// Safe cast to XMLText. This can return null.
     XMLText* ToText() 							{
-        return ( _node ? _node->ToText() : 0 );
+        return ( _node ? _node->ToText() : nullptr );
     }
     /// Safe cast to XMLUnknown. This can return null.
     XMLUnknown* ToUnknown() 					{
-        return ( _node ? _node->ToUnknown() : 0 );
+        return ( _node ? _node->ToUnknown() : nullptr );
     }
     /// Safe cast to XMLDeclaration. This can return null.
     XMLDeclaration* ToDeclaration() 			{
-        return ( _node ? _node->ToDeclaration() : 0 );
+        return ( _node ? _node->ToDeclaration() : nullptr );
     }
 
 private:
@@ -2145,28 +2145,28 @@ public:
     }
 
     const XMLConstHandle FirstChild() const											{
-        return XMLConstHandle( _node ? _node->FirstChild() : 0 );
+        return XMLConstHandle( _node ? _node->FirstChild() : nullptr );
     }
-    const XMLConstHandle FirstChildElement( const char* name = 0 ) const				{
-        return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
+    const XMLConstHandle FirstChildElement( const char* name = nullptr ) const				{
+        return XMLConstHandle( _node ? _node->FirstChildElement( name ) : nullptr );
     }
     const XMLConstHandle LastChild()	const										{
-        return XMLConstHandle( _node ? _node->LastChild() : 0 );
+        return XMLConstHandle( _node ? _node->LastChild() : nullptr );
     }
-    const XMLConstHandle LastChildElement( const char* name = 0 ) const				{
-        return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
+    const XMLConstHandle LastChildElement( const char* name = nullptr ) const				{
+        return XMLConstHandle( _node ? _node->LastChildElement( name ) : nullptr );
     }
     const XMLConstHandle PreviousSibling() const									{
-        return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
+        return XMLConstHandle( _node ? _node->PreviousSibling() : nullptr );
     }
-    const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const		{
-        return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
+    const XMLConstHandle PreviousSiblingElement( const char* name = nullptr ) const		{
+        return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : nullptr );
     }
     const XMLConstHandle NextSibling() const										{
-        return XMLConstHandle( _node ? _node->NextSibling() : 0 );
+        return XMLConstHandle( _node ? _node->NextSibling() : nullptr );
     }
-    const XMLConstHandle NextSiblingElement( const char* name = 0 ) const			{
-        return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
+    const XMLConstHandle NextSiblingElement( const char* name = nullptr ) const			{
+        return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : nullptr );
     }
 
 
@@ -2174,16 +2174,16 @@ public:
         return _node;
     }
     const XMLElement* ToElement() const			{
-        return ( _node ? _node->ToElement() : 0 );
+        return ( _node ? _node->ToElement() : nullptr );
     }
     const XMLText* ToText() const				{
-        return ( _node ? _node->ToText() : 0 );
+        return ( _node ? _node->ToText() : nullptr );
     }
     const XMLUnknown* ToUnknown() const			{
-        return ( _node ? _node->ToUnknown() : 0 );
+        return ( _node ? _node->ToUnknown() : nullptr );
     }
     const XMLDeclaration* ToDeclaration() const	{
-        return ( _node ? _node->ToDeclaration() : 0 );
+        return ( _node ? _node->ToDeclaration() : nullptr );
     }
 
 private:
@@ -2247,7 +2247,7 @@ public:
     	If 'compact' is set to true, then output is created
     	with only required whitespace and newlines.
     */
-    XMLPrinter( FILE* file=0, bool compact = false, int depth = 0, EscapeAposCharsInAttributes aposInAttributes = ESCAPE_APOS_CHARS_IN_ATTRIBUTES );
+    XMLPrinter( FILE* file=nullptr, bool compact = false, int depth = 0, EscapeAposCharsInAttributes aposInAttributes = ESCAPE_APOS_CHARS_IN_ATTRIBUTES );
     virtual ~XMLPrinter()	{}
 
     /** If streaming, write the BOM and declaration. */
@@ -2369,9 +2369,9 @@ private:
 
     DynArray< char, 20 > _buffer;
 
-    // Prohibit cloning, intentionally not implemented
-    XMLPrinter( const XMLPrinter& );
-    XMLPrinter& operator=( const XMLPrinter& );
+    // Prohibit cloning
+    XMLPrinter( const XMLPrinter& ) = delete;
+    XMLPrinter& operator=( const XMLPrinter& ) = delete;
 };