diff --git a/src/pvxs/sharedArray.h b/src/pvxs/sharedArray.h
index e5479bf..28cdb0b 100644
--- a/src/pvxs/sharedArray.h
+++ b/src/pvxs/sharedArray.h
@@ -178,6 +178,9 @@ public:
 PVXS_API
 std::ostream& operator<<(std::ostream& strm, const Limiter&);
 
+PVXS_API
+void _throw_bad_cast(ArrayType from, ArrayType to);
+
 } // namespace detail
 
 /** std::vector-like contigious array of items passed by reference.
@@ -379,23 +382,48 @@ public:
     }
 
 #if _DOXYGEN_
-    //! Cast to other type, preserving const-ness.
+    /** Cast to/from void, preserving const-ness.
+     *
+     * Allowed casts depend upon two aspects of type parameter E.
+     *
+     * Whether the base type is void or non-void.
+     * And whether or not the const qualifier is present.
+     *
+     * Type E may always be cast to itself.
+     *
+     * Casts must preseve const-ness.
+     * Either both of E and TO, or neither, must be const qualified.
+     *
+     * At most one of E or TO may have different non-void base type.
+     */
     template<typename TO>
     shared_array<TO>
     castTo() const;
 #endif
 
+    template<typename TO, typename std::enable_if<std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
+    shared_array<TO>
+    castTo() const {
+        return shared_array<TO>(this->_data, this->_data.get(), this->_count); // implied cast to void*
+    }
+
+    template<typename TO, typename std::enable_if<std::is_same<TO, E>{}, int>::type =0>
+    shared_array<TO>
+    castTo() const {
+        return *this;
+    }
+
     // static_cast<TO>() to non-void, preserving const-ness
     template<typename TO, typename std::enable_if<!std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
     shared_array<TO>
-    castTo() const {
+    castToUnsafe() const {
         return shared_array<TO>(this->_data, static_cast<TO*>(this->_data.get()), this->_count);
     }
 
     // static_cast<TO>() to void, preserving const-ness
     template<typename TO, typename std::enable_if<std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
     shared_array<TO>
-    castTo() const {
+    castToUnsafe() const {
         return shared_array<TO>(this->_data, this->_data.get(), this->_count); // implied cast to void*
     }
 
@@ -519,13 +547,29 @@ public:
     template<typename TO, typename std::enable_if<!std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
     shared_array<TO>
     castTo() const {
+        if(this->_data && _type!=detail::CaptureCode<typename std::remove_cv<TO>::type>::code) {
+            detail::_throw_bad_cast(_type, detail::CaptureCode<typename std::remove_cv<TO>::type>::code);
+        }
+        return shared_array<TO>(this->_data, static_cast<TO*>(this->_data.get()), this->_count);
+    }
+
+    template<typename TO, typename std::enable_if<std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
+    shared_array<TO>
+    castTo() const {
+        return *this;
+    }
+
+    // static_cast<TO>() to non-void, preserving const-ness
+    template<typename TO, typename std::enable_if<!std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
+    shared_array<TO>
+    castToUnsafe() const {
         return shared_array<TO>(this->_data, static_cast<TO*>(this->_data.get()), this->_count);
     }
 
     // static_cast<TO>() to void, preserving const-ness
     template<typename TO, typename std::enable_if<std::is_void<TO>{} && (std::is_const<E>{} == std::is_const<TO>{}), int>::type =0>
     shared_array<TO>
-    castTo() const {
+    castToUnsafe() const {
         // in reality this is either void -> void, or const void -> const void
         // aka. simple copy
         return *this;
diff --git a/src/util.cpp b/src/util.cpp
index 9010164..854fd14 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -203,6 +203,11 @@ std::ostream& operator<<(std::ostream& strm, const Limiter& lim)
     return strm;
 }
 
+void _throw_bad_cast(ArrayType from, ArrayType to)
+{
+    throw std::logic_error(SB()<<"Unable to cast array from "<<from<<" to "<<to);
+}
+
 Escaper::Escaper(const char* v)
     :val(v)
     ,count(v ? strlen(v) : 0)
diff --git a/test/testshared.cpp b/test/testshared.cpp
index f8fc20b..c8a007a 100644
--- a/test/testshared.cpp
+++ b/test/testshared.cpp
@@ -135,11 +135,58 @@ void testComplex()
     testEq(*X[0], 4u);
 }
 
+void testCast()
+{
+    testDiag("%s", __func__);
+
+    shared_array<void> Void;
+
+    (void)Void.castTo<void>();
+    (void)Void.castTo<uint32_t>();
+    // not allowed
+    //(void)Void.castTo<const void>();
+    //(void)Void.castTo<const uint32_t>();
+
+    shared_array<const void> CVoid;
+
+    (void)CVoid.castTo<const void>();
+    (void)CVoid.castTo<const uint32_t>();
+    // not allowed
+    //(void)CVoid.castTo<void>();
+    //(void)CVoid.castTo<uint32_t>();
+
+    shared_array<uint32_t> Int;
+
+    (void)Int.castTo<uint32_t>();
+    (void)Int.castTo<void>();
+    // not allowed
+    //(void)Int.castTo<const uint32_t>();
+    //(void)Int.castTo<const void>();
+
+    shared_array<const uint32_t> CInt;
+
+    (void)CInt.castTo<const uint32_t>();
+    (void)CInt.castTo<const void>();
+    // not allowed
+    //(void)CInt.castTo<uint32_t>();
+    //(void)CInt.castTo<void>();
+
+    shared_array<double> Double({1.0, 2.0});
+    Void = Double.castTo<void>();
+    testThrows<std::logic_error>([&Void](){
+        (void)Void.castTo<uint32_t>();
+    })<<"Attempt cast to wrong type";
+
+    Void.clear();
+    // now doesn't throw
+    (void)Void.castTo<uint32_t>();
+}
+
 } // namespace
 
 MAIN(testshared)
 {
-    testPlan(93);
+    testPlan(94);
     testEmpty<void>();
     testEmpty<const void>();
     testEmpty<int32_t>();
@@ -151,5 +198,6 @@ MAIN(testshared)
     testFreeze();
     testFreezeError();
     testComplex();
+    testCast();
     return testDone();
 }