diff --git a/src/blackmisc/collection.h b/src/blackmisc/collection.h
index 7cf58deba..ac1d46361 100644
--- a/src/blackmisc/collection.h
+++ b/src/blackmisc/collection.h
@@ -234,24 +234,24 @@ namespace BlackMisc
         public:
             static_assert(std::is_same<T, typename C::value_type>::value, "CCollection must be initialized from a container with the same value_type.");
             Pimpl(C &&c) : m_impl(std::move(c)) {}
-            PimplBase *clone() const { return new Pimpl(*this); }
-            PimplBase *cloneEmpty() const { return new Pimpl(C()); }
-            iterator begin() { return iterator::fromImpl(m_impl.begin()); }
-            const_iterator begin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
-            const_iterator cbegin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
-            iterator end() { return iterator::fromImpl(m_impl.end()); }
-            const_iterator end() const { return const_iterator::fromImpl(m_impl.cend()); }
-            const_iterator cend() const { return const_iterator::fromImpl(m_impl.cend()); }
-            size_type size() const { return m_impl.size(); }
-            bool empty() const { return m_impl.empty(); }
-            void clear() { m_impl.clear(); }
-            iterator insert(const T &value) { return iterator::fromImpl(insertHelper(m_impl.insert(value))); }
-            iterator erase(iterator pos) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(pos.getImpl()))); }
-            //iterator erase(iterator it1, iterator it2) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
-            iterator erase(iterator it1, iterator it2) { while (it1 != it2) { it1 = iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()))); } return it1; }
-            iterator find(const T &value) { return iterator::fromImpl(m_impl.find(value)); }
-            const_iterator find(const T &value) const { return const_iterator::fromImpl(m_impl.find(value)); }
-            bool operator ==(const PimplBase &other) const { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.insert(*i); return m_impl == copy.m_impl; }
+            PimplBase *clone() const override { return new Pimpl(*this); }
+            PimplBase *cloneEmpty() const override { return new Pimpl(C()); }
+            iterator begin() override { return iterator::fromImpl(m_impl.begin()); }
+            const_iterator begin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
+            const_iterator cbegin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
+            iterator end() override { return iterator::fromImpl(m_impl.end()); }
+            const_iterator end() const override { return const_iterator::fromImpl(m_impl.cend()); }
+            const_iterator cend() const override { return const_iterator::fromImpl(m_impl.cend()); }
+            size_type size() const override { return m_impl.size(); }
+            bool empty() const override { return m_impl.empty(); }
+            void clear() override { m_impl.clear(); }
+            iterator insert(const T &value) override { return iterator::fromImpl(insertHelper(m_impl.insert(value))); }
+            iterator erase(iterator pos) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(pos.getImpl()))); }
+            //iterator erase(iterator it1, iterator it2) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
+            iterator erase(iterator it1, iterator it2) override { while (it1 != it2) { it1 = iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()))); } return it1; }
+            iterator find(const T &value) override { return iterator::fromImpl(m_impl.find(value)); }
+            const_iterator find(const T &value) const override { return const_iterator::fromImpl(m_impl.find(value)); }
+            bool operator ==(const PimplBase &other) const override { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.insert(*i); return m_impl == copy.m_impl; }
         private:
             C m_impl;
             // insertHelper: QSet::insert returns an iterator, but std::set::insert returns a std::pair<interator, bool>
diff --git a/src/blackmisc/iterator.h b/src/blackmisc/iterator.h
index bf4fa57c1..592ec24a2 100644
--- a/src/blackmisc/iterator.h
+++ b/src/blackmisc/iterator.h
@@ -149,12 +149,12 @@ namespace BlackMisc
                 static_assert(std::is_same<T, typename std::iterator_traits<I>::value_type>::value,
                     "ConstForwardIterator must be initialized from an iterator with the same value_type.");
                 Pimpl(I &&i) : m_impl(std::move(i)) {}
-                virtual PimplBase *clone() const { return new Pimpl(*this); }
-                virtual const_reference operator *() const { return *m_impl; }
-                virtual void operator ++() { ++m_impl; }
-                virtual void operator +=(difference_type n) { std::advance(m_impl, n); }
-                virtual bool operator ==(const PimplBase &other) const { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
-                virtual void *impl() { return &m_impl; }
+                virtual PimplBase *clone() const override { return new Pimpl(*this); }
+                virtual const_reference operator *() const override { return *m_impl; }
+                virtual void operator ++() override { ++m_impl; }
+                virtual void operator +=(difference_type n) override { std::advance(m_impl, n); }
+                virtual bool operator ==(const PimplBase &other) const override { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
+                virtual void *impl() override { return &m_impl; }
             private:
                 I m_impl;
             };
@@ -349,19 +349,19 @@ namespace BlackMisc
                 static_assert(std::is_same<T, typename std::iterator_traits<I>::value_type>::value,
                     "ConstBidirectionalIterator must be initialized from an iterator with the same value_type.");
                 Pimpl(I &&i) : m_impl(std::move(i)) {}
-                virtual PimplBase *clone() const { return new Pimpl(*this); }
-                virtual const_reference operator *() const { return *m_impl; }
-                virtual void operator ++() { ++m_impl; }
-                virtual void operator --() { --m_impl; }
-                virtual void operator +=(difference_type n) { m_impl += n; }
-                virtual void operator -=(difference_type n) { m_impl -= n; }
-                virtual difference_type operator -(const PimplBase &other) const { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator ==(const PimplBase &other) const { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator <(const PimplBase &other) const { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator >(const PimplBase &other) const { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator <=(const PimplBase &other) const { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator >=(const PimplBase &other) const { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
-                virtual void *impl() { return &m_impl; }
+                virtual PimplBase *clone() const override { return new Pimpl(*this); }
+                virtual const_reference operator *() const override { return *m_impl; }
+                virtual void operator ++() override { ++m_impl; }
+                virtual void operator --() override { --m_impl; }
+                virtual void operator +=(difference_type n) override { m_impl += n; }
+                virtual void operator -=(difference_type n) override { m_impl -= n; }
+                virtual difference_type operator -(const PimplBase &other) const override { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator ==(const PimplBase &other) const override { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator <(const PimplBase &other) const override { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator >(const PimplBase &other) const override { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator <=(const PimplBase &other) const override { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator >=(const PimplBase &other) const override { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
+                virtual void *impl() override { return &m_impl; }
             private:
                 I m_impl;
             };
@@ -569,20 +569,20 @@ namespace BlackMisc
                 static_assert(std::is_same<T, typename std::iterator_traits<I>::value_type>::value,
                     "BidirectionalIterator must be initialized from an iterator with the same value_type.");
                 Pimpl(I &&i) : m_impl(std::move(i)) {}
-                virtual PimplBase *clone() const { return new Pimpl(*this); }
-                virtual const_reference operator *() const { return *m_impl; }
-                virtual reference operator *() { return *m_impl; }
-                virtual void operator ++() { ++m_impl; }
-                virtual void operator --() { --m_impl; }
-                virtual void operator +=(difference_type n) { m_impl += n; }
-                virtual void operator -=(difference_type n) { m_impl -= n; }
-                virtual difference_type operator -(const PimplBase &other) const { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator ==(const PimplBase &other) const { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator <(const PimplBase &other) const { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator >(const PimplBase &other) const { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator <=(const PimplBase &other) const { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
-                virtual bool operator >=(const PimplBase &other) const { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
-                virtual void *impl() { return &m_impl; }
+                virtual PimplBase *clone() const override { return new Pimpl(*this); }
+                virtual const_reference operator *() const override { return *m_impl; }
+                virtual reference operator *() override { return *m_impl; }
+                virtual void operator ++() override { ++m_impl; }
+                virtual void operator --() override { --m_impl; }
+                virtual void operator +=(difference_type n) override { m_impl += n; }
+                virtual void operator -=(difference_type n) override { m_impl -= n; }
+                virtual difference_type operator -(const PimplBase &other) const override { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator ==(const PimplBase &other) const override { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator <(const PimplBase &other) const override { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator >(const PimplBase &other) const override { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator <=(const PimplBase &other) const override { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
+                virtual bool operator >=(const PimplBase &other) const override { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
+                virtual void *impl() override { return &m_impl; }
             private:
                 I m_impl;
             };
diff --git a/src/blackmisc/sequence.h b/src/blackmisc/sequence.h
index 59502f271..8e70ba8dd 100644
--- a/src/blackmisc/sequence.h
+++ b/src/blackmisc/sequence.h
@@ -461,29 +461,29 @@ namespace BlackMisc
         public:
             static_assert(std::is_same<T, typename C::value_type>::value, "CSequence must be initialized from a container with the same value_type.");
             Pimpl(C &&c) : m_impl(std::move(c)) {}
-            PimplBase *clone() const { return new Pimpl(*this); }
-            PimplBase *cloneEmpty() const { return new Pimpl(C()); }
-            iterator begin() { return iterator::fromImpl(m_impl.begin()); }
-            const_iterator begin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
-            const_iterator cbegin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
-            iterator end() { return iterator::fromImpl(m_impl.end()); }
-            const_iterator end() const { return const_iterator::fromImpl(m_impl.cend()); }
-            const_iterator cend() const { return const_iterator::fromImpl(m_impl.cend()); }
-            reference operator [](size_type index) { return m_impl[index]; }
-            const_reference operator [](size_type index) const { return m_impl[index]; }
-            reference front() { return m_impl.front(); }
-            const_reference front() const { return m_impl.front(); }
-            reference back() { return m_impl.back(); }
-            const_reference back() const { return m_impl.back(); }
-            size_type size() const { return m_impl.size(); }
-            bool empty() const { return m_impl.empty(); }
-            void clear() { m_impl.clear(); }
-            iterator insert(iterator pos, const T &value) { return iterator::fromImpl(m_impl.insert(*static_cast<const typename C::iterator*>(pos.getImpl()), value)); }
-            void push_back(const T &value) { m_impl.push_back(value); }
-            void pop_back() { m_impl.pop_back(); }
-            iterator erase(iterator pos) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(pos.getImpl()))); }
-            iterator erase(iterator it1, iterator it2) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
-            bool operator ==(const PimplBase &other) const { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.push_back(*i); return m_impl == copy.m_impl; }
+            PimplBase *clone() const override { return new Pimpl(*this); }
+            PimplBase *cloneEmpty() const override { return new Pimpl(C()); }
+            iterator begin() override { return iterator::fromImpl(m_impl.begin()); }
+            const_iterator begin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
+            const_iterator cbegin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
+            iterator end() override { return iterator::fromImpl(m_impl.end()); }
+            const_iterator end() const override { return const_iterator::fromImpl(m_impl.cend()); }
+            const_iterator cend() const override { return const_iterator::fromImpl(m_impl.cend()); }
+            reference operator [](size_type index) override { return m_impl[index]; }
+            const_reference operator [](size_type index) const override { return m_impl[index]; }
+            reference front() override { return m_impl.front(); }
+            const_reference front() const override { return m_impl.front(); }
+            reference back() override { return m_impl.back(); }
+            const_reference back() const override { return m_impl.back(); }
+            size_type size() const override { return m_impl.size(); }
+            bool empty() const override { return m_impl.empty(); }
+            void clear() override { m_impl.clear(); }
+            iterator insert(iterator pos, const T &value) override { return iterator::fromImpl(m_impl.insert(*static_cast<const typename C::iterator*>(pos.getImpl()), value)); }
+            void push_back(const T &value) override { m_impl.push_back(value); }
+            void pop_back() override { m_impl.pop_back(); }
+            iterator erase(iterator pos) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(pos.getImpl()))); }
+            iterator erase(iterator it1, iterator it2) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
+            bool operator ==(const PimplBase &other) const override { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.push_back(*i); return m_impl == copy.m_impl; }
         private:
             C m_impl;
         };