diff --git a/lemon/maps.h b/lemon/maps.h
--- a/lemon/maps.h
+++ b/lemon/maps.h
@@ -163,21 +163,23 @@
   ///This is essentially a wrapper for \c std::map with addition that
   ///you can specify a default value different from \c Value().
   template <typename K, typename T, typename Compare = std::less<K> >
-  class StdMap {
+  class StdMap : public MapBase<K, T> {
     template <typename K1, typename T1, typename C1>
     friend class StdMap;
   public:
 
-    typedef True ReferenceMapTag;
+    typedef MapBase<K, T> Parent;
     ///\e
-    typedef K Key;
+    typedef typename Parent::Key Key;
     ///\e
-    typedef T Value;
+    typedef typename Parent::Value Value;
     ///\e
     typedef T& Reference;
     ///\e
     typedef const T& ConstReference;
 
+    typedef True ReferenceMapTag;
+
   private:
     
     typedef std::map<K, T, Compare> Map;
@@ -239,6 +241,27 @@
     }    
 
   };
+  
+  ///Returns a \ref StdMap class
+
+  ///This function just returns a \ref StdMap class with specified 
+  ///default value.
+  ///\relates StdMap
+  template<typename K, typename V, typename Compare = std::less<K> > 
+  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
+    return StdMap<K, V, Compare>(value);
+  }
+
+  ///Returns a \ref StdMap class created from an appropriate std::map
+
+  ///This function just returns a \ref StdMap class created from an 
+  ///appropriate std::map.
+  ///\relates StdMap
+  template<typename K, typename V, typename Compare = std::less<K> > 
+  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, 
+                                       const V& value = V() ) {
+    return StdMap<K, V, Compare>(map, value);
+  }
 
   /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
   ///
@@ -249,23 +272,25 @@
   ///
   /// \todo Revise its name
   template <typename T>
-  class IntegerMap {
+  class IntegerMap : public MapBase<int, T> {
 
     template <typename T1>
     friend class IntegerMap;
 
   public:
 
-    typedef True ReferenceMapTag;
+    typedef MapBase<int, T> Parent;
     ///\e
-    typedef int Key;
+    typedef typename Parent::Key Key;
     ///\e
-    typedef T Value;
+    typedef typename Parent::Value Value;
     ///\e
     typedef T& Reference;
     ///\e
     typedef const T& ConstReference;
 
+    typedef True ReferenceMapTag;
+
   private:
     
     typedef std::vector<T> Vector;
@@ -313,6 +338,15 @@
     }
 
   };
+  
+  ///Returns an \ref IntegerMap class
+
+  ///This function just returns an \ref IntegerMap class.
+  ///\relates IntegerMap
+  template<typename T>
+  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
+    return IntegerMap<T>(size, value);
+  }
 
   /// @}
 
@@ -405,6 +439,15 @@
     ///\e
     Value operator[](Key k) const {return m[k];}
   };
+  
+  ///Returns a \ref SimpleMap class
+
+  ///This function just returns a \ref SimpleMap class.
+  ///\relates SimpleMap
+  template<typename M>
+  inline SimpleMap<M> simpleMap(const M &m) {
+    return SimpleMap<M>(m);
+  }
 
   ///Simple writable wrapping of a map
 
@@ -433,6 +476,15 @@
     void set(Key k, const Value& c) { m.set(k, c); }
   };
 
+  ///Returns a \ref SimpleWriteMap class
+
+  ///This function just returns a \ref SimpleWriteMap class.
+  ///\relates SimpleWriteMap
+  template<typename M>
+  inline SimpleWriteMap<M> simpleWriteMap(M &m) {
+    return SimpleWriteMap<M>(m);
+  }
+
   ///Sum of two maps
 
   ///This \c concepts::ReadMap "read only map" returns the sum of the two