Added static assert asserting custom types have no overloaded operator new (#2954)

Signed-off-by: Ivo Ivanov <[email protected]>

Author: iv461

rclcpp/include/rclcpp/publisher.hpp

@@ -574,6 +574,13 @@ class Publisher : public PublisherBase
   std::unique_ptr<PublishedType, PublishedTypeDeleter>
   duplicate_type_adapt_message_as_unique_ptr(const PublishedType & msg)
   {
+    /// Assert that the published type has no overloaded operator new since this leads to
+    /// new/delete mismatch (see https://github.com/ros2/rclcpp/issues/2951)
+    static_assert(!detail::has_overloaded_operator_new_v<PublishedType>,
+        "When publishing by value (i.e. when calling publish(const T& msg)), the published "
+    "message type must not have an overloaded operator new. In this case, please use the "
+    "publish(std::unique_ptr<T> msg) method instead.");
+
     auto ptr = PublishedTypeAllocatorTraits::allocate(published_type_allocator_, 1);
     PublishedTypeAllocatorTraits::construct(published_type_allocator_, ptr, msg);
     return std::unique_ptr<PublishedType, PublishedTypeDeleter>(ptr, published_type_deleter_);

rclcpp/include/rclcpp/type_adapter.hpp

@@ -16,6 +16,7 @@
 #define RCLCPP__TYPE_ADAPTER_HPP_
 
 #include <type_traits>
+#include <new>
 
 namespace rclcpp
 {
@@ -128,6 +129,24 @@ struct assert_type_pair_is_specialized_type_adapter
     "No type adapter for this custom type/ros message type pair");
 };
 
+template<typename, typename = void>
+struct has_overloaded_operator_new : std::false_type {};
+template<typename T>
+struct has_overloaded_operator_new<T, std::void_t<
+    decltype(T::operator new(std::size_t()))
+  >>: std::true_type {};
+
+template<typename, typename = void>
+struct has_overloaded_aligned_operator_new : std::false_type {};
+template<typename T>
+struct has_overloaded_aligned_operator_new<T,
+  std::void_t<decltype( T::operator new(std::size_t(), std::align_val_t()) )>>
+  : std::true_type {};
+
+template<typename T>
+inline constexpr bool has_overloaded_operator_new_v = has_overloaded_operator_new<T>::value ||
+  has_overloaded_aligned_operator_new<T>::value;
+
 }  // namespace detail
 
 /// Template metafunction that can make the type being adapted explicit.