diff --git a/include/yaml-cpp/node/impl.h b/include/yaml-cpp/node/impl.h
index 02cfe94..8c80ac4 100644
--- a/include/yaml-cpp/node/impl.h
+++ b/include/yaml-cpp/node/impl.h
@@ -16,58 +16,48 @@
 
 namespace YAML {
 inline Node::Node()
-    : m_isValid(true),
-      //m_pMemory(nullptr),
-      m_pMemory(new detail::memory_holder),
+    : m_pMemory(new detail::memory_holder),
       m_pNode(NULL) {}
 
 inline Node::Node(NodeType::value type)
-    : m_isValid(true),
-      m_pMemory(new detail::memory_holder),
+    : m_pMemory(new detail::memory_holder),
       m_pNode(&(m_pMemory->create_node())) {
   m_pNode->set_type(type);
 }
 
 template <typename T>
 inline Node::Node(const T& rhs)
-    : m_isValid(true),
-      m_pMemory(new detail::memory_holder),
+    : m_pMemory(new detail::memory_holder),
       m_pNode(&(m_pMemory->create_node())) {
   Assign(rhs);
 }
 
 inline Node::Node(const detail::iterator_value& rhs)
-    : m_isValid(rhs.m_isValid),
-      m_pMemory(rhs.m_pMemory),
+    : m_pMemory(rhs.m_pMemory),
       m_pNode(rhs.m_pNode) {}
 
 inline Node::Node(const Node& rhs)
-    : m_isValid(rhs.m_isValid),
-      m_pMemory(rhs.m_pMemory),
+    : m_pMemory(rhs.m_pMemory),
       m_pNode(rhs.m_pNode) {}
 
 inline Node::Node(Zombie)
-    : m_isValid(false),
-      m_pMemory(nullptr),
+    : m_pMemory(nullptr),
       m_pNode(NULL) {}
 
 inline Node::Node(Node&& rhs)
-    : m_isValid(rhs.m_isValid),
-      m_pMemory(rhs.m_pMemory), // move ?
+    : m_pMemory(std::move(rhs.m_pMemory)),
       m_pNode(rhs.m_pNode) {
-
     rhs.m_pNode = nullptr;
 }
 
 inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
-    : m_isValid(true),
-      m_pMemory(pMemory),
+    : m_pMemory(pMemory),
       m_pNode(&node) {}
 
 inline Node::~Node() {}
 
 inline void Node::EnsureNodeExists() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   if (!m_pNode) {
     m_pMemory.reset(new detail::memory_holder);
@@ -77,21 +67,21 @@ inline void Node::EnsureNodeExists() const {
 }
 
 inline bool Node::IsDefined() const {
-  if (!m_isValid) {
+  if (!isValid()) {
     return false;
   }
   return m_pNode ? m_pNode->is_defined() : true;
 }
 
 inline Mark Node::Mark() const {
-  if (!m_isValid) {
+  if (!isValid()) {
     throw InvalidNode();
   }
   return m_pNode ? m_pNode->mark() : Mark::null_mark();
 }
 
 inline NodeType::value Node::Type() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   return m_pNode ? m_pNode->type() : NodeType::Null;
 }
@@ -158,45 +148,45 @@ struct as_if<std::string, void> {
 // access functions
 template <typename T>
 inline T Node::as() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   return as_if<T, void>(*this)();
 }
 
 template <typename T, typename S>
 inline T Node::as(const S& fallback) const {
-  if (!m_isValid)
+  if (!isValid())
     return fallback;
   return as_if<T, S>(*this)(fallback);
 }
 
 inline const std::string& Node::Scalar() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
 }
 
 inline const std::string& Node::Tag() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
 }
 
 inline void Node::SetTag(const std::string& tag) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_tag(tag);
 }
 
 inline EmitterStyle::value Node::Style() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   return m_pNode ? m_pNode->style() : EmitterStyle::Default;
 }
 
 inline void Node::SetStyle(EmitterStyle::value style) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_style(style);
@@ -204,7 +194,7 @@ inline void Node::SetStyle(EmitterStyle::value style) {
 
 // assignment
 inline bool Node::is(const Node& rhs) const {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   if (!m_pNode || !rhs.m_pNode)
     return false;
@@ -213,14 +203,14 @@ inline bool Node::is(const Node& rhs) const {
 
 template <typename T>
 inline Node& Node::operator=(const T& rhs) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   Assign(rhs);
   return *this;
 }
 
 inline void Node::reset(const YAML::Node& rhs) {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   m_pMemory = rhs.m_pMemory;
   m_pNode = rhs.m_pNode;
@@ -228,35 +218,35 @@ inline void Node::reset(const YAML::Node& rhs) {
 
 template <typename T>
 inline void Node::Assign(const T& rhs) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   AssignData(convert<T>::encode(rhs));
 }
 
 template <>
 inline void Node::Assign(const std::string& rhs) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_scalar(rhs);
 }
 
 inline void Node::Assign(const char* rhs) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_scalar(rhs);
 }
 
 inline void Node::Assign(char* rhs) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_scalar(rhs);
 }
 
 inline Node& Node::operator=(const Node& rhs) {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   if (is(rhs))
     return *this;
@@ -265,7 +255,7 @@ inline Node& Node::operator=(const Node& rhs) {
 }
 
 inline Node& Node::operator=(Node&& rhs) {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   if (is(rhs))
     return *this;
@@ -276,7 +266,7 @@ inline Node& Node::operator=(Node&& rhs) {
 }
 
 inline void Node::AssignData(Node&& rhs) {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   EnsureNodeExists();
   rhs.EnsureNodeExists();
@@ -286,7 +276,7 @@ inline void Node::AssignData(Node&& rhs) {
 }
 
 inline void Node::AssignNode(const Node& rhs) {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   rhs.EnsureNodeExists();
 
@@ -303,32 +293,32 @@ inline void Node::AssignNode(const Node& rhs) {
 
 // size/iterator
 inline std::size_t Node::size() const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   return m_pNode ? m_pNode->size() : 0;
 }
 
 inline const_iterator Node::begin() const {
-  if (!m_isValid)
+  if (!isValid())
     return const_iterator();
   return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory)
                  : const_iterator();
 }
 
 inline iterator Node::begin() {
-  if (!m_isValid)
+  if (!isValid())
     return iterator();
   return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
 }
 
 inline const_iterator Node::end() const {
-  if (!m_isValid)
+  if (!isValid())
     return const_iterator();
   return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
 }
 
 inline iterator Node::end() {
-  if (!m_isValid)
+  if (!isValid())
     return iterator();
   return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
 }
@@ -336,13 +326,13 @@ inline iterator Node::end() {
 // sequence
 template <typename T>
 inline void Node::push_back(const T& rhs) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   push_back(Node(rhs));
 }
 
 inline void Node::push_back(const Node& rhs) {
-  if (!m_isValid || !rhs.m_isValid)
+  if (!isValid() || !rhs.isValid())
     throw InvalidNode();
   EnsureNodeExists();
   rhs.EnsureNodeExists();
@@ -399,7 +389,7 @@ inline typename to_value_t<T>::return_type to_value(const T& t) {
 // indexing
 template <typename Key>
 inline const Node Node::operator[](const Key& key) const {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   detail::node* value = static_cast<const detail::node&>(*m_pNode)
@@ -412,7 +402,7 @@ inline const Node Node::operator[](const Key& key) const {
 
 template <typename Key>
 inline Node Node::operator[](const Key& key) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
@@ -421,14 +411,14 @@ inline Node Node::operator[](const Key& key) {
 
 template <typename Key>
 inline bool Node::remove(const Key& key) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   return m_pNode->remove(detail::to_value(key), m_pMemory);
 }
 
 inline const Node Node::operator[](const Node& key) const {
-  if (!m_isValid || !key.m_isValid)
+  if (!isValid() || !key.isValid())
     throw InvalidNode();
   EnsureNodeExists();
   key.EnsureNodeExists();
@@ -442,7 +432,7 @@ inline const Node Node::operator[](const Node& key) const {
 }
 
 inline Node Node::operator[](const Node& key) {
-  if (!m_isValid || !key.m_isValid)
+  if (!isValid() || !key.isValid())
     throw InvalidNode();
   EnsureNodeExists();
   key.EnsureNodeExists();
@@ -452,7 +442,7 @@ inline Node Node::operator[](const Node& key) {
 }
 
 inline bool Node::remove(const Node& key) {
-  if (!m_isValid || !key.m_isValid)
+  if (!isValid() || !key.isValid())
     throw InvalidNode();
   EnsureNodeExists();
   key.EnsureNodeExists();
@@ -462,7 +452,7 @@ inline bool Node::remove(const Node& key) {
 // map
 template <typename Key, typename Value>
 inline void Node::force_insert(const Key& key, const Value& value) {
-  if (!m_isValid)
+  if (!isValid())
     throw InvalidNode();
   EnsureNodeExists();
   m_pNode->force_insert(detail::to_value(key), detail::to_value(value),
diff --git a/include/yaml-cpp/node/node.h b/include/yaml-cpp/node/node.h
index 865316a..a42824b 100644
--- a/include/yaml-cpp/node/node.h
+++ b/include/yaml-cpp/node/node.h
@@ -132,9 +132,10 @@ class YAML_CPP_API Node {
   void AssignNode(const Node& rhs);
 
  private:
-  bool m_isValid;
   mutable detail::shared_memory_holder m_pMemory;
   mutable detail::node* m_pNode;
+
+  bool isValid() const { return m_pMemory; }
 };
 
 YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs);