diff --git a/Property_map/include/CGAL/Dynamic_property_map.h b/Property_map/include/CGAL/Dynamic_property_map.h
index 949eed33382..c9d5df75ad6 100644
--- a/Property_map/include/CGAL/Dynamic_property_map.h
+++ b/Property_map/include/CGAL/Dynamic_property_map.h
@@ -20,6 +20,7 @@
 
 #include <memory>
 
+#include <type_traits>
 #include <unordered_map>
 
 namespace CGAL {
@@ -154,108 +155,133 @@ struct Dynamic_with_index
 
 } // namespace internal
 
+struct dynamic_property_t {};
+
 template <typename T>
-struct dynamic_vertex_property_t
+struct dynamic_vertex_property_t : public dynamic_property_t
 {
   dynamic_vertex_property_t()
   {}
+
+  using value_type = T;
+
+  template <typename G>
+  struct property_map {
+    using descriptor = typename boost::graph_traits<G>::vertex_descriptor;
+    using vertex_descriptor = descriptor;
+  };
 };
 
 
 template <typename T>
-struct dynamic_halfedge_property_t
+struct dynamic_halfedge_property_t : public dynamic_property_t
 {
   dynamic_halfedge_property_t()
   {}
+
+  using value_type = T;
+
+  template <typename G>
+  struct property_map {
+    using descriptor = typename boost::graph_traits<G>::halfedge_descriptor;
+    using halfedge_descriptor = descriptor;
+  };
 };
 
 template <typename T>
-struct dynamic_edge_property_t
+struct dynamic_edge_property_t : public dynamic_property_t
 {
   dynamic_edge_property_t()
   {}
+
+  using value_type = T;
+
+  template <typename G>
+  struct property_map {
+    using descriptor = typename boost::graph_traits<G>::edge_descriptor;
+    using edge_descriptor = descriptor;
+  };
 };
 
 
 template <typename T>
-struct dynamic_face_property_t
+struct dynamic_face_property_t : public dynamic_property_t
 {
   dynamic_face_property_t()
   {}
+
+  using value_type = T;
+
+  template <typename G>
+  struct property_map
+  {
+    using descriptor = typename boost::graph_traits<G>::face_descriptor;
+    using face_descriptor = descriptor;
+  };
+};
+
+template <typename T>
+constexpr bool is_dynamic_property_tag()
+{
+  return std::is_base_of_v<CGAL::dynamic_property_t, T>;
+}
+
+template <typename Graph, typename Dynamic_property_tag>
+struct property_map_of_dynamic_property_map : Dynamic_property_tag::template property_map<Graph>
+{
+  using descriptor = typename Dynamic_property_tag::template property_map<Graph>::descriptor;
+  using type = CGAL::internal::Dynamic_property_map<descriptor, typename Dynamic_property_tag::value_type>;
+  using const_type = const type;
 };
 
 } // namespace CGAL
 
 namespace boost {
 
-
 template <typename G, typename T>
 struct property_map<G, CGAL::dynamic_vertex_property_t<T> >
+  : public CGAL::property_map_of_dynamic_property_map<G, CGAL::dynamic_vertex_property_t<T>>
 {
-  typedef typename boost::graph_traits<G>::vertex_descriptor vertex_descriptor;
-  typedef CGAL::internal::Dynamic_property_map<vertex_descriptor,T> type;
-  typedef type const_type;
+  using vertex_descriptor = typename boost::graph_traits<G>::vertex_descriptor;
 };
 
 template <typename G, typename T>
 struct property_map<G, CGAL::dynamic_halfedge_property_t<T> >
+  : public CGAL::property_map_of_dynamic_property_map<G, CGAL::dynamic_halfedge_property_t<T>>
 {
-  typedef typename boost::graph_traits<G>::halfedge_descriptor halfedge_descriptor;
-  typedef CGAL::internal::Dynamic_property_map<halfedge_descriptor,T> type;
-  typedef type const_type;
+  using halfedge_descriptor = typename boost::graph_traits<G>::halfedge_descriptor;
 };
 
 
 template <typename G, typename T>
 struct property_map<G, CGAL::dynamic_edge_property_t<T> >
+  : public CGAL::property_map_of_dynamic_property_map<G, CGAL::dynamic_edge_property_t<T>>
 {
-  typedef typename boost::graph_traits<G>::edge_descriptor edge_descriptor;
-  typedef CGAL::internal::Dynamic_property_map<edge_descriptor,T> type;
-  typedef type const_type;
+  using edge_descriptor = typename boost::graph_traits<G>::edge_descriptor;
 };
 
 template <typename G, typename T>
 struct property_map<G, CGAL::dynamic_face_property_t<T> >
+  : public CGAL::property_map_of_dynamic_property_map<G, CGAL::dynamic_face_property_t<T>>
 {
-  typedef typename boost::graph_traits<G>::face_descriptor face_descriptor;
-  typedef CGAL::internal::Dynamic_property_map<face_descriptor,T> type;
-  typedef type const_type;
+  using face_descriptor = typename boost::graph_traits<G>::face_descriptor;
 };
 
 } // namespace boost
 
 namespace CGAL {
 
-template <typename T, typename G>
-typename boost::property_map<G, dynamic_vertex_property_t<T> >::const_type
-get(const CGAL::dynamic_vertex_property_t<T>&, const G&, const T& default_value = T())
-{
-  typedef typename boost::graph_traits<G>::vertex_descriptor vertex_descriptor;
-  return internal::Dynamic_property_map<vertex_descriptor,T>(default_value);
-}
+template <typename Dynamic_property_tag,
+          typename G,
+          typename = std::enable_if_t<is_dynamic_property_tag<Dynamic_property_tag>()>,
+          typename ...Default_value_args>
 
-template <typename T, typename G>
-typename boost::property_map<G, dynamic_halfedge_property_t<T> >::const_type
-get(const CGAL::dynamic_halfedge_property_t<T>&, const G&, const T& default_value = T())
+auto get(const Dynamic_property_tag&, const G&, Default_value_args&&... default_value_args)
 {
-  typedef typename boost::graph_traits<G>::halfedge_descriptor halfedge_descriptor;
-  return internal::Dynamic_property_map<halfedge_descriptor,T>(default_value);
-}
-
-template <typename T, typename G>
-typename boost::property_map<G, dynamic_edge_property_t<T> >::const_type
-get(const CGAL::dynamic_edge_property_t<T>&, const G&, const T& default_value = T())
-{
-  typedef typename boost::graph_traits<G>::edge_descriptor edge_descriptor;
-  return internal::Dynamic_property_map<edge_descriptor,T>(default_value);
-}
-
-template <typename T, typename G>
-typename boost::property_map<G, dynamic_face_property_t<T> >::const_type
-get(const CGAL::dynamic_face_property_t<T>&, const G&, const T& default_value = T())
-{
-  typedef typename boost::graph_traits<G>::face_descriptor face_descriptor;
-  return internal::Dynamic_property_map<face_descriptor,T>(default_value);
+  using Property_map =
+      internal::Dynamic_property_map<typename Dynamic_property_tag::descriptor,
+                                     typename Dynamic_property_tag::value_type>;
+  return Property_map(std::forward<Default_value_args>(default_value_args)...);
 }
 
 template<typename G, typename Descriptor, typename T>
diff --git a/Property_map/include/CGAL/property_map.h b/Property_map/include/CGAL/property_map.h
index e9868ef6e07..250630763b7 100644
--- a/Property_map/include/CGAL/property_map.h
+++ b/Property_map/include/CGAL/property_map.h
@@ -622,7 +622,8 @@ struct Constant_property_map
   typedef const value_type&                             reference;
   typedef boost::read_write_property_map_tag            category;
 
-  Constant_property_map(const value_type& default_value = value_type()) : default_value (default_value) { }
+  Constant_property_map() : default_value{} { }
+  Constant_property_map(const value_type& default_value) : default_value (default_value) { }
 
   /// Free function that returns `pm.default_value`.
   inline friend
diff --git a/STL_Extension/include/CGAL/utility.h b/STL_Extension/include/CGAL/utility.h
index 88f63fb115b..d356eab10a0 100644
--- a/STL_Extension/include/CGAL/utility.h
+++ b/STL_Extension/include/CGAL/utility.h
@@ -343,6 +343,12 @@ Scope_exit<F> make_scope_exit(F&& f) {
   return Scope_exit<F>(std::forward<F>(f));
 }
 
+template<class... Ts>
+struct overloaded : Ts... {
+  using Ts::operator()...;
+};
+template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
 } //namespace CGAL
 
 namespace std {
diff --git a/Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h b/Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h
index 991d0959489..306313545b3 100644
--- a/Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h
+++ b/Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h
@@ -13,6 +13,7 @@
 #ifndef CGAL_PROPERTIES_SURFACE_MESH_H
 #define CGAL_PROPERTIES_SURFACE_MESH_H
 
+#include <type_traits>
 #ifndef DOXYGEN_RUNNING
 
 #include <CGAL/license/Surface_mesh.h>
@@ -23,6 +24,7 @@
 #include <CGAL/Kernel_traits.h>
 #include <CGAL/squared_distance_3.h>
 #include <CGAL/number_utils.h>
+#include <CGAL/utility.h>
 
 #include <CGAL/boost/graph/properties.h>
 
@@ -351,69 +353,46 @@ struct property_map<CGAL::Surface_mesh<Point>, CGAL::dynamic_edge_property_t<T>
 namespace CGAL {
 
 // get functions for dynamic properties of mutable Surface_mesh
-template <typename Point, typename T>
-typename boost::property_map<CGAL::Surface_mesh<Point>, dynamic_vertex_property_t<T> >::type
-get(dynamic_vertex_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
+template <typename Point,
+          typename Dynamic_property_tag,
+          typename = std::enable_if_t<is_dynamic_property_tag<Dynamic_property_tag>()>,
+          typename ...Default_value_args>
+auto get(Dynamic_property_tag, Surface_mesh<Point>& sm, Default_value_args&&... default_value_args)
 {
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_vertex_property_t<T> >::SMPM SMPM;
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_vertex_property_t<T> >::type DPM;
-  return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Vertex_index, T>(std::string(), default_value).first));
-}
-
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::type
-get(dynamic_face_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::SMPM SMPM;
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::type DPM;
-  return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Face_index, T>(std::string(), default_value).first));
-}
-
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::type
-get(dynamic_edge_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::SMPM SMPM;
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::type DPM;
-  return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Edge_index, T>(std::string(), default_value).first));
-}
-
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::type
-get(dynamic_halfedge_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::SMPM SMPM;
-  typedef typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::type DPM;
-  return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Halfedge_index, T>(std::string(), default_value).first));
+  using BPM = typename boost::property_map<Surface_mesh<Point>, Dynamic_property_tag>;
+  using descriptor = typename Dynamic_property_tag::template property_map<Surface_mesh<Point>>::descriptor;
+  using value_type = typename Dynamic_property_tag::value_type;
+  using SMPM = typename BPM::SMPM;
+  using DPM = typename BPM::type;
+  auto&& [sm_property_map, ok] = sm.template add_property_map<descriptor, value_type>(
+      std::string(),
+      std::forward<Default_value_args>(default_value_args)...);
+  CGAL_assume(ok);
+  return DPM(sm, new SMPM(std::forward<decltype(sm_property_map)>(sm_property_map)));
 }
 
 // get functions for dynamic properties of const Surface_mesh
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_vertex_property_t<T> >::const_type
-get(dynamic_vertex_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Vertex_index, T>(num_vertices(sm), default_value);
-}
-
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::const_type
-get(dynamic_face_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Face_index, T>(num_faces(sm), default_value);
-}
-
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::const_type
-get(dynamic_halfedge_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Halfedge_index, T>(num_halfedges(sm), default_value);
-}
-
-template <typename Point, typename T>
-typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::const_type
-get(dynamic_edge_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
-{
-  return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Edge_index, T>(num_edges(sm), default_value);
+template <typename Point,
+          typename Dynamic_property_tag,
+          typename = std::enable_if_t<is_dynamic_property_tag<Dynamic_property_tag>()>,
+          typename... Default_value_args>
+auto get(Dynamic_property_tag, const Surface_mesh<Point>& sm, Default_value_args&&... default_value_args) {
+  using graph_traits = boost::graph_traits<Surface_mesh<Point>>;
+  using vertex_descriptor = typename graph_traits::vertex_descriptor;
+  using face_descriptor = typename graph_traits::face_descriptor;
+  using edge_descriptor = typename graph_traits::edge_descriptor;
+  using halfedge_descriptor = typename graph_traits::halfedge_descriptor;
+  auto num_elements = CGAL::overloaded{
+    [&](vertex_descriptor) { return num_vertices(sm); },
+    [&](halfedge_descriptor) { return num_halfedges(sm); },
+    [&](edge_descriptor) { return num_edges(sm); },
+    [&](face_descriptor) { return num_faces(sm); }
+  };
+  using descriptor = typename Dynamic_property_tag::template property_map<Surface_mesh<Point>>::descriptor;
+  using value_type = typename Dynamic_property_tag::value_type;
+  return CGAL::internal::Dynamic_with_index<descriptor, value_type>(
+      num_elements(descriptor{}),
+      std::forward<Default_value_args>(default_value_args)...);
 }
 
 // implementation detail: required by Dynamic_property_map_deleter