diff --git a/cpp/src/arrow/adapters/orc/util.cc b/cpp/src/arrow/adapters/orc/util.cc
index 91260302abd3..7ab5efafdc1c 100644
--- a/cpp/src/arrow/adapters/orc/util.cc
+++ b/cpp/src/arrow/adapters/orc/util.cc
@@ -295,7 +295,7 @@ Status AppendUnionBatchInternal(const liborc::Type* type,
       RETURN_NOT_OK(AppendBatch(child_type, child_batch, start, /*length=*/1,
                                 builder->child_builder(child_id).get()));
 
-      if constexpr (std::is_same_v<UnionBuilderType, SparseUnionBuilder>) {
+      if constexpr (std::same_as<UnionBuilderType, SparseUnionBuilder>) {
         // Append null value to other child builders for sparse union type.
         for (int8_t field_id = 0; field_id < union_type->num_fields(); field_id++) {
           if (field_id != child_id) {
@@ -844,10 +844,10 @@ Status WriteUnionBatch(const Array& array, int64_t orc_offset,
     int64_t child_array_orc_offset = batch->offsets[running_orc_offset];
     int64_t child_array_arrow_offset;
 
-    if constexpr (std::is_same_v<UnionArrayType, DenseUnionArray>) {
+    if constexpr (std::same_as<UnionArrayType, DenseUnionArray>) {
       child_array_arrow_offset = union_array->value_offset(running_arrow_offset);
     } else {
-      static_assert(std::is_same_v<UnionArrayType, SparseUnionArray>);
+      static_assert(std::same_as<UnionArrayType, SparseUnionArray>);
       child_array_arrow_offset = running_arrow_offset;
     }
     child_batch->resize(child_array_orc_offset + 1);
diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 2cdf94bfab95..655ca9b08f1d 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -2494,10 +2494,10 @@ void CheckFloatApproxEqualsWithUlpDistance() {
   if constexpr (is_half_float_type<TYPE>::value) {
     a.push_back(Float16(1.00097656));
     b.push_back(Float16(0.999511719f));
-  } else if constexpr (std::is_same_v<TYPE, DoubleType>) {
+  } else if constexpr (std::same_as<TYPE, DoubleType>) {
     a.push_back(CType(0.9999999999999999));
     b.push_back(CType(1.0000000000000002));
-  } else if constexpr (std::is_same_v<TYPE, FloatType>) {
+  } else if constexpr (std::same_as<TYPE, FloatType>) {
     a.push_back(CType(1.0000001f));
     b.push_back(CType(0.99999994f));
   }
diff --git a/cpp/src/arrow/array/builder_primitive.h b/cpp/src/arrow/array/builder_primitive.h
index 6d79d6e96499..6b6fc577ffb3 100644
--- a/cpp/src/arrow/array/builder_primitive.h
+++ b/cpp/src/arrow/array/builder_primitive.h
@@ -473,9 +473,9 @@ class ARROW_EXPORT HalfFloatBuilder : public NumericBuilder<HalfFloatType> {
   /// @tparam T arrow::util::Float16 or value_type (uint16_t)
   template <typename T = BaseClass::value_type>
   T GetValue(int64_t index) const {
-    static_assert(std::is_same_v<T, BaseClass::value_type> ||
-                  std::is_same_v<T, arrow::util::Float16>);
-    if constexpr (std::is_same_v<T, BaseClass::value_type>) {
+    static_assert(std::same_as<T, BaseClass::value_type> ||
+                  std::same_as<T, arrow::util::Float16>);
+    if constexpr (std::same_as<T, BaseClass::value_type>) {
       return BaseClass::GetValue(index);
     } else {
       return Float16::FromBits(BaseClass::GetValue(index));
diff --git a/cpp/src/arrow/array/data_test.cc b/cpp/src/arrow/array/data_test.cc
index 9e103207d0f1..1190c15172aa 100644
--- a/cpp/src/arrow/array/data_test.cc
+++ b/cpp/src/arrow/array/data_test.cc
@@ -53,7 +53,7 @@ TEST(ArrayData, GetSpanRespectsOffset) {
                               /*offset=*/1);
   auto span = data->GetSpan<uint16_t>(1, 3);
 
-  const bool is_const_pointer = std::is_same_v<decltype(span)::pointer, const uint16_t*>;
+  const bool is_const_pointer = std::same_as<decltype(span)::pointer, const uint16_t*>;
   ASSERT_TRUE(is_const_pointer);
 
   EXPECT_EQ(span.size(), 3);
@@ -73,7 +73,7 @@ TEST(ArrayData, GetMutableSpanRespectsOffset) {
       ArrayData::Make(uint16(), /*length=*/3, buffers, /*null_count=*/0, /*offset=*/1);
   auto span = data->GetMutableSpan<uint16_t>(1, 3);
 
-  const bool is_mut_pointer = std::is_same_v<decltype(span)::pointer, uint16_t*>;
+  const bool is_mut_pointer = std::same_as<decltype(span)::pointer, uint16_t*>;
   ASSERT_TRUE(is_mut_pointer);
 
   EXPECT_EQ(span.size(), 3);
diff --git a/cpp/src/arrow/array/dict_internal.h b/cpp/src/arrow/array/dict_internal.h
index 8ddc4b448a7e..a8654b98cd82 100644
--- a/cpp/src/arrow/array/dict_internal.h
+++ b/cpp/src/arrow/array/dict_internal.h
@@ -154,7 +154,7 @@ template <typename T>
 struct DictionaryTraits<T, enable_if_binary_view_like<T>> {
   using MemoTableType = typename HashTraits<T>::MemoTableType;
 
-  static_assert(std::is_same_v<MemoTableType, BinaryMemoTable<BinaryBuilder>>);
+  static_assert(std::same_as<MemoTableType, BinaryMemoTable<BinaryBuilder>>);
 
   // Instead of defining a custom memo table for StringView we reuse BinaryType's,
   // then convert to views when we copy data out of the memo table.
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 16bc9187af46..1c56c768066b 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -47,8 +47,8 @@ struct UTF8DataValidator {
 
   template <typename T>
   Status Visit(const T&) {
-    if constexpr (std::is_same_v<T, StringType> || std::is_same_v<T, LargeStringType> ||
-                  std::is_same_v<T, StringViewType>) {
+    if constexpr (std::same_as<T, StringType> || std::same_as<T, LargeStringType> ||
+                  std::same_as<T, StringViewType>) {
       util::InitializeUTF8();
 
       int64_t i = 0;
diff --git a/cpp/src/arrow/c/dlpack.cc b/cpp/src/arrow/c/dlpack.cc
index 1b58b5a503c0..63358042318e 100644
--- a/cpp/src/arrow/c/dlpack.cc
+++ b/cpp/src/arrow/c/dlpack.cc
@@ -121,7 +121,7 @@ DT* ExportBuffer(ExportBufferParams<Vec>&& p) {
   ctx->tensor.dl_tensor.byte_offset = 0;
   // Strides must be non-null when ndim > 0
   ctx->tensor.dl_tensor.strides = ctx->strides.data();
-  if constexpr (std::is_same_v<DT, DLManagedTensorVersioned>) {
+  if constexpr (std::same_as<DT, DLManagedTensorVersioned>) {
     ctx->tensor.version = kVersion;
     ctx->tensor.flags = p.flags;
   }
diff --git a/cpp/src/arrow/c/dlpack_test.cc b/cpp/src/arrow/c/dlpack_test.cc
index 8cbff0692da3..ae7301b95150 100644
--- a/cpp/src/arrow/c/dlpack_test.cc
+++ b/cpp/src/arrow/c/dlpack_test.cc
@@ -111,7 +111,7 @@ void CheckDLTensor(const std::shared_ptr<Array>& arr,
   ASSERT_EQ(DLDeviceType::kDLCPU, device.device_type);
   ASSERT_EQ(0, device.device_id);
 
-  if constexpr (std::is_same_v<decltype(dlmtensor), DLManagedTensorVersioned*>) {
+  if constexpr (std::same_as<decltype(dlmtensor), DLManagedTensorVersioned*>) {
     ASSERT_EQ(DLPACK_MAJOR_VERSION, dlmtensor->version.major);
     ASSERT_EQ(DLPACK_MINOR_VERSION, dlmtensor->version.minor);
     if constexpr (Producer::copy) {
@@ -234,7 +234,7 @@ void CheckDLTensor(const std::shared_ptr<Tensor>& t,
   ASSERT_EQ(DLDeviceType::kDLCPU, device.device_type);
   ASSERT_EQ(0, device.device_id);
 
-  if constexpr (std::is_same_v<decltype(dlmtensor), DLManagedTensorVersioned*>) {
+  if constexpr (std::same_as<decltype(dlmtensor), DLManagedTensorVersioned*>) {
     ASSERT_EQ(DLPACK_MAJOR_VERSION, dlmtensor->version.major);
     ASSERT_EQ(DLPACK_MINOR_VERSION, dlmtensor->version.minor);
     if constexpr (Producer::copy) {
@@ -296,7 +296,7 @@ TYPED_TEST(TestExportTensor, TestTensorReadOnly) {
                        Tensor::Make(float32(), read_only_buffer, shape));
   ASSERT_FALSE(read_only_tensor->is_mutable());
 
-  if constexpr (std::is_same_v<typename TypeParam::ManagedTensor, DLManagedTensor>) {
+  if constexpr (std::same_as<typename TypeParam::ManagedTensor, DLManagedTensor>) {
     ASSERT_RAISES_WITH_MESSAGE(
         NotImplemented,
         "NotImplemented: Legacy DLPack support is not implemented for immutable tensors."
diff --git a/cpp/src/arrow/compare.cc b/cpp/src/arrow/compare.cc
index 06f1d14e73a3..ad33c632f227 100644
--- a/cpp/src/arrow/compare.cc
+++ b/cpp/src/arrow/compare.cc
@@ -1540,7 +1540,7 @@ bool ArrayStatisticsOptionalValueEquals(const std::optional<Type>& left,
                                         const EqualOptions& options) {
   if (!left.has_value() || !right.has_value()) {
     return left.has_value() == right.has_value();
-  } else if constexpr (std::is_same_v<Type, double>) {
+  } else if constexpr (std::same_as<Type, double>) {
     return DoubleEquals(left.value(), right.value(), options);
   } else if (left->index() != right->index()) {
     return false;
@@ -1551,7 +1551,7 @@ bool ArrayStatisticsOptionalValueEquals(const std::optional<Type>& left,
       if constexpr (std::conjunction_v<std::is_same<type_1, double>,
                                        std::is_same<type_2, double>>) {
         return DoubleEquals(v1, v2, options);
-      } else if constexpr (std::is_same_v<type_1, type_2>) {
+      } else if constexpr (std::same_as<type_1, type_2>) {
         return v1 == v2;
       }
       Unreachable("The types are different.");
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
index 3733f415a048..c062822f8d3e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
@@ -274,7 +274,7 @@ struct MeanImpl<ArrowType, SimdLevel,
         (this->count < options.min_count)) {
       out->value = std::make_shared<DoubleScalar>();
     } else {
-      static_assert(std::is_same_v<decltype(this->sum), double>,
+      static_assert(std::same_as<decltype(this->sum), double>,
                     "SumCType must be double for numeric inputs");
       const double mean = this->sum / this->count;
       out->value = std::make_shared<DoubleScalar>(mean);
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 320c40373c5a..5c7c78ef7307 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -729,7 +729,7 @@ template <>
 struct Identity<Add> {
   template <typename Value>
   static constexpr Value value() {
-    if constexpr (std::is_same_v<Float16, Value>) {
+    if constexpr (std::same_as<Float16, Value>) {
       return Float16::zero();
     } else {
       return 0;
@@ -744,7 +744,7 @@ template <>
 struct Identity<Multiply> {
   template <typename Value>
   static constexpr Value value() {
-    if constexpr (std::is_same_v<Float16, Value>) {
+    if constexpr (std::same_as<Float16, Value>) {
       return Float16::one();
     } else {
       return 1;
@@ -762,7 +762,7 @@ struct Identity<Max> {
     // Note that `min()` returns the smallest positive value for
     // floating-point types, and `lowest()` doesn't satisfy the identity
     // property for -inf inputs, so use -infinity for those types.
-    if constexpr (std::is_floating_point_v<Value> || std::is_same_v<Float16, Value>) {
+    if constexpr (std::is_floating_point_v<Value> || std::same_as<Float16, Value>) {
       return -std::numeric_limits<Value>::infinity();
     } else {
       return std::numeric_limits<Value>::lowest();
@@ -775,7 +775,7 @@ struct Identity<Min> {
   template <typename Value>
   static constexpr Value value() {
     // Mirror of Identity<Max>: use +infinity for floating-point types.
-    if constexpr (std::is_floating_point_v<Value> || std::is_same_v<Float16, Value>) {
+    if constexpr (std::is_floating_point_v<Value> || std::same_as<Float16, Value>) {
       return std::numeric_limits<Value>::infinity();
     } else {
       return std::numeric_limits<Value>::max();
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 3a2bcefab0a1..96d524f5b0d3 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -276,7 +276,7 @@ template <typename T, typename R = T>
 using enable_if_not_floating_value = enable_if_t<!std::is_floating_point<T>::value, R>;
 
 template <typename T, typename R = T>
-using enable_if_half_float_value = enable_if_t<std::is_same_v<T, Float16>, R>;
+using enable_if_half_float_value = enable_if_t<std::same_as<T, Float16>, R>;
 
 template <typename T, typename R = T>
 using enable_if_decimal_value =
@@ -492,8 +492,8 @@ void VisitArrayValuesInline(const ArraySpan& arr, VisitFunc&& valid_func,
 }
 
 template <typename T, typename VisitFunc, typename NullFunc>
-  requires std::is_same_v<std::invoke_result_t<VisitFunc, typename GetViewType<T>::T>,
-                          Status>
+  requires std::same_as<std::invoke_result_t<VisitFunc, typename GetViewType<T>::T>,
+                        Status>
 Status VisitArrayValuesInline(const ArraySpan& arr, VisitFunc&& valid_func,
                               NullFunc&& null_func) {
   return VisitArraySpanInline<T>(
@@ -622,7 +622,7 @@ struct OutputAdapter<Type, enable_if_boolean<Type>> {
 
 template <typename Type>
 struct OutputAdapter<Type, enable_if_c_number_or_decimal<Type>> {
-  using T = std::conditional_t<std::is_same_v<Type, HalfFloatType>, Float16,
+  using T = std::conditional_t<std::same_as<Type, HalfFloatType>, Float16,
                                typename TypeTraits<Type>::ScalarType::ValueType>;
 
   template <typename Generator>
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_internal.h b/cpp/src/arrow/compute/kernels/hash_aggregate_internal.h
index 1ba21bd9b89e..d990bb6ce5c1 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_internal.h
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_internal.h
@@ -176,7 +176,7 @@ void VisitGroupedValues(const ExecSpan& batch, ConsumeValue&& valid_func,
 }
 
 template <typename Type, typename ConsumeValue, typename ConsumeNull>
-  requires std::is_same_v<
+  requires std::same_as<
       std::invoke_result_t<ConsumeValue, uint32_t, typename GetViewType<Type>::T>, Status>
 Status VisitGroupedValues(const ExecSpan& batch, ConsumeValue&& valid_func,
                           ConsumeNull&& null_func) {
diff --git a/cpp/src/arrow/compute/kernels/ree_util_internal.h b/cpp/src/arrow/compute/kernels/ree_util_internal.h
index 3e2bf8af87e9..571548e48691 100644
--- a/cpp/src/arrow/compute/kernels/ree_util_internal.h
+++ b/cpp/src/arrow/compute/kernels/ree_util_internal.h
@@ -76,7 +76,7 @@ class ReadWriteValue<ArrowType, in_has_validity_buffer, out_has_validity_buffer,
     if constexpr (in_has_validity_buffer) {
       valid = bit_util::GetBit(input_validity_, read_offset);
     }
-    if constexpr (std::is_same_v<ArrowType, BooleanType>) {
+    if constexpr (std::same_as<ArrowType, BooleanType>) {
       *out = bit_util::GetBit(input_values_, read_offset);
     } else {
       *out = (reinterpret_cast<const ValueRepr*>(input_values_))[read_offset];
@@ -88,7 +88,7 @@ class ReadWriteValue<ArrowType, in_has_validity_buffer, out_has_validity_buffer,
   /// - i and j are valid indices into the values buffer
   /// - the values in i and j are valid
   bool CompareValuesAt(int64_t i, int64_t j) const {
-    if constexpr (std::is_same_v<ArrowType, BooleanType>) {
+    if constexpr (std::same_as<ArrowType, BooleanType>) {
       return bit_util::GetBit(input_values_, i) == bit_util::GetBit(input_values_, j);
     } else {
       return (reinterpret_cast<const ValueRepr*>(input_values_))[i] ==
@@ -111,7 +111,7 @@ class ReadWriteValue<ArrowType, in_has_validity_buffer, out_has_validity_buffer,
       bit_util::SetBitTo(output_validity_, write_offset, valid);
     }
     if (valid) {
-      if constexpr (std::is_same_v<ArrowType, BooleanType>) {
+      if constexpr (std::same_as<ArrowType, BooleanType>) {
         bit_util::SetBitTo(output_values_, write_offset, value);
       } else {
         (reinterpret_cast<ValueRepr*>(output_values_))[write_offset] = value;
@@ -125,7 +125,7 @@ class ReadWriteValue<ArrowType, in_has_validity_buffer, out_has_validity_buffer,
       bit_util::SetBitsTo(output_validity_, write_offset, run_length, valid);
     }
     if (valid) {
-      if constexpr (std::is_same_v<ArrowType, BooleanType>) {
+      if constexpr (std::same_as<ArrowType, BooleanType>) {
         bit_util::SetBitsTo(reinterpret_cast<uint8_t*>(output_values_), write_offset,
                             run_length, value);
       } else {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 11ba956071b1..1d9f6b475a72 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -91,7 +91,7 @@ template <typename T>
 class TestBaseArithmetic : public ::testing::Test {
  protected:
   using ArrowType = T;
-  using CType = std::conditional_t<std::is_same_v<T, HalfFloatType>, Float16,
+  using CType = std::conditional_t<std::same_as<T, HalfFloatType>, Float16,
                                    typename ArrowType::c_type>;
 
   static std::shared_ptr<DataType> type_singleton() {
@@ -104,14 +104,14 @@ class TestBaseArithmetic : public ::testing::Test {
 
   template <typename V>
   std::shared_ptr<Scalar> MakeScalar(V value) {
-    if constexpr (std::is_same_v<T, HalfFloatType>) {
+    if constexpr (std::same_as<T, HalfFloatType>) {
       return std::make_shared<HalfFloatScalar>(Float16(value).bits());
     } else {
       return *arrow::MakeScalar(type_singleton(), value);
     }
   }
 
-  static constexpr bool is_half_float() { return std::is_same_v<T, HalfFloatType>; }
+  static constexpr bool is_half_float() { return std::same_as<T, HalfFloatType>; }
 };
 
 // This has to be a macro, the test wouldn't be skipped from a helper function
@@ -122,7 +122,7 @@ class TestBaseArithmetic : public ::testing::Test {
 
 template <typename T, typename R = void>
 using enable_if_numeric_value =
-    std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, Float16>, R>;
+    std::enable_if_t<std::is_arithmetic_v<T> || std::same_as<T, Float16>, R>;
 
 template <typename T, typename OptionsType>
 class TestBaseUnaryArithmetic : public TestBaseArithmetic<T> {
diff --git a/cpp/src/arrow/compute/kernels/scalar_nested.cc b/cpp/src/arrow/compute/kernels/scalar_nested.cc
index e9c65aff1ce1..854260b2687c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_nested.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_nested.cc
@@ -249,7 +249,7 @@ struct ListSlice {
     RETURN_NOT_OK(MakeBuilder(pool, output_type, &builder));
     auto* list_builder = checked_cast<BuilderType*>(builder.get());
     RETURN_NOT_OK(list_builder->Resize(batch[0].array.length));
-    if constexpr (std::is_same_v<InListType, FixedSizeListType>) {
+    if constexpr (std::same_as<InListType, FixedSizeListType>) {
       RETURN_NOT_OK(BuildArrayFromFixedSizeListType(opts.start, opts.step, opts.stop,
                                                     batch, list_builder));
     } else {
@@ -267,8 +267,8 @@ struct ListSlice {
                                                 std::optional<int64_t> stop,
                                                 const ExecSpan& batch,
                                                 BuilderType* out_list_builder) {
-    static_assert(std::is_same_v<InListType, FixedSizeListType>);
-    constexpr bool kIsFixedSizeOutput = std::is_same_v<BuilderType, FixedSizeListBuilder>;
+    static_assert(std::same_as<InListType, FixedSizeListType>);
+    constexpr bool kIsFixedSizeOutput = std::same_as<BuilderType, FixedSizeListBuilder>;
     const auto& fsl_type = checked_cast<const FixedSizeListType&>(*batch[0].type());
     const ArraySpan& list_array = batch[0].array;
     const ArraySpan& values_array = list_array.child_data[0];
@@ -315,7 +315,7 @@ struct ListSlice {
                                                  const ExecSpan& batch,
                                                  BuilderType* out_list_builder) {
     constexpr bool kIsListViewInput = is_list_view(InListType::type_id);
-    constexpr bool kIsFixedSizeOutput = std::is_same_v<BuilderType, FixedSizeListBuilder>;
+    constexpr bool kIsFixedSizeOutput = std::same_as<BuilderType, FixedSizeListBuilder>;
     const ArraySpan& list_array = batch[0].array;
     const ArraySpan& values_array = list_array.child_data[0];
     ArrayBuilder* value_builder = out_list_builder->value_builder();
diff --git a/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc
index 1e9e0c9d50cf..77b9719c3618 100644
--- a/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc
@@ -1165,7 +1165,7 @@ TYPED_TEST(TestUnaryRoundSigned, Round) {
 
   // Test different rounding mode
   // skip int8 because of its small range
-  if constexpr (!std::is_same_v<TypeParam, Int8Type>) {
+  if constexpr (!std::same_as<TypeParam, Int8Type>) {
     std::string values("[0, 1, -13, -50, 115, -150, -176, 200, 250]");
     this->SetRoundNdigits(-2);
     std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
@@ -1193,14 +1193,14 @@ TYPED_TEST(TestUnaryRoundSigned, Round) {
   this->AssertUnaryOpRaises(Round, "[1]", "out of range");
 
   // Overflow is also treated as error
-  if constexpr (std::is_same_v<TypeParam, Int8Type>) {
+  if constexpr (std::same_as<TypeParam, Int8Type>) {
     this->SetRoundNdigits(-1);
     this->SetRoundMode(RoundMode::DOWN);
     this->AssertUnaryOpRaises(Round, "[-127]", "overflow");
   }
 
   // A larger than double int64 should be correctly handled
-  if constexpr (std::is_same_v<TypeParam, Int64Type>) {
+  if constexpr (std::same_as<TypeParam, Int64Type>) {
     this->SetRoundNdigits(-2);
     this->SetRoundMode(RoundMode::UP);
     auto values = "[1152921504606846976]";  // 2 ^ 60
@@ -1235,7 +1235,7 @@ TYPED_TEST(TestUnaryRoundUnsigned, Round) {
 
   // Test different rounding mode
   // skip uint8 because of its small range
-  if constexpr (!std::is_same_v<TypeParam, UInt8Type>) {
+  if constexpr (!std::same_as<TypeParam, UInt8Type>) {
     std::string values("[0, 1, 13, 50, 115, 150, 176, 200, 250]");
     this->SetRoundNdigits(-2);
     std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
@@ -1263,14 +1263,14 @@ TYPED_TEST(TestUnaryRoundUnsigned, Round) {
   this->AssertUnaryOpRaises(Round, "[1]", "out of range");
 
   // Overflow is also treated as error
-  if constexpr (std::is_same_v<TypeParam, UInt8Type>) {
+  if constexpr (std::same_as<TypeParam, UInt8Type>) {
     this->SetRoundNdigits(-1);
     this->SetRoundMode(RoundMode::UP);
     this->AssertUnaryOpRaises(Round, "[255]", "overflow");
   }
 
   // A larger than double uint64 should be correctly handled
-  if constexpr (std::is_same_v<TypeParam, Int64Type>) {
+  if constexpr (std::same_as<TypeParam, Int64Type>) {
     this->SetRoundNdigits(-2);
     this->SetRoundMode(RoundMode::UP);
     auto values = "[1152921504606846976]";  // 2 ^ 60
@@ -1373,13 +1373,13 @@ TYPED_TEST(TestBinaryRoundSigned, Round) {
   }
 
   // An overly large ndigits would cause an error
-  if constexpr (std::is_same_v<TypeParam, Int8Type>) {
+  if constexpr (std::same_as<TypeParam, Int8Type>) {
     this->SetRoundMode(RoundMode::UP);
     this->AssertBinaryOpRaises(RoundBinary, "[1]", "[-100]", "out of range");
   }
 
   // Overflow is also treated as error
-  if constexpr (std::is_same_v<TypeParam, Int8Type>) {
+  if constexpr (std::same_as<TypeParam, Int8Type>) {
     this->SetRoundMode(RoundMode::DOWN);
     this->AssertBinaryOpRaises(RoundBinary, "[-127]", "[-1]", "overflow");
   }
@@ -1432,13 +1432,13 @@ TYPED_TEST(TestBinaryRoundUnsigned, Round) {
   }
 
   // An overly large ndigits would cause an error
-  if constexpr (std::is_same_v<TypeParam, UInt8Type>) {
+  if constexpr (std::same_as<TypeParam, UInt8Type>) {
     this->SetRoundMode(RoundMode::UP);
     this->AssertBinaryOpRaises(RoundBinary, "[1]", "[-100]", "out of range");
   }
 
   // Overflow is also treated as error
-  if constexpr (std::is_same_v<TypeParam, UInt8Type>) {
+  if constexpr (std::same_as<TypeParam, UInt8Type>) {
     this->SetRoundMode(RoundMode::UP);
     this->AssertBinaryOpRaises(RoundBinary, "[255]", "[-1]", "overflow");
   }
@@ -1544,7 +1544,7 @@ TYPED_TEST(TestUnaryRoundToMultipleSigned, RoundToMultiple) {
                         ArrayFromJSON(this->type_singleton(), pair.second));
   }
 
-  if constexpr (std::is_same_v<TypeParam, Int32Type>) {
+  if constexpr (std::same_as<TypeParam, Int32Type>) {
     // Test overflow handling
     this->SetRoundMultiple(10);
     auto input = "[-2147483645]";
@@ -1621,7 +1621,7 @@ TYPED_TEST(TestUnaryRoundToMultipleUnsigned, RoundToMultiple) {
                         ArrayFromJSON(this->type_singleton(), pair.second));
   }
 
-  if constexpr (std::is_same_v<TypeParam, UInt32Type>) {
+  if constexpr (std::same_as<TypeParam, UInt32Type>) {
     // Test overflow handling
     this->SetRoundMultiple(10);
     auto input = "[4294967295]";
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
index 74a29081ae86..0981aba279b5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
@@ -180,7 +180,7 @@ struct TemporalComponentExtractRound
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const RoundTemporalOptions& options = RoundTemporalState::Get(ctx);
 
-    if constexpr (std::is_same_v<InType, DurationType>) {
+    if constexpr (std::same_as<InType, DurationType>) {
       if (options.calendar_based_origin) {
         return Status::Invalid(
             "calendar_based_origin is not supported for duration inputs");
diff --git a/cpp/src/arrow/compute/kernels/scalar_validity.cc b/cpp/src/arrow/compute/kernels/scalar_validity.cc
index 5913b756f1c0..8e6037caf69c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_validity.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_validity.cc
@@ -63,7 +63,7 @@ Status IsValidExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
 struct IsFiniteOperator {
   template <typename OutType, typename InType>
   static constexpr OutType Call(KernelContext*, const InType& value, Status*) {
-    if constexpr (std::is_same_v<InType, Float16>) {
+    if constexpr (std::same_as<InType, Float16>) {
       return value.is_finite();
     } else {
       return std::isfinite(value);
@@ -74,7 +74,7 @@ struct IsFiniteOperator {
 struct IsInfOperator {
   template <typename OutType, typename InType>
   static constexpr OutType Call(KernelContext*, const InType& value, Status*) {
-    if constexpr (std::is_same_v<InType, Float16>) {
+    if constexpr (std::same_as<InType, Float16>) {
       return value.is_infinity();
     } else {
       return std::isinf(value);
@@ -89,7 +89,7 @@ static void SetNanBits(const ArraySpan& arr, uint8_t* out_bitmap, int64_t out_of
   const T* data = arr.GetValues<T>(1);
   for (int64_t i = 0; i < arr.length; ++i) {
     bool is_nan(false);
-    if constexpr (std::is_same_v<T, uint16_t>) {
+    if constexpr (std::same_as<T, uint16_t>) {
       is_nan = Float16::FromBits(data[i]).is_nan();
     } else {
       is_nan = std::isnan(data[i]);
@@ -143,7 +143,7 @@ Status IsNullExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
 struct IsNanOperator {
   template <typename OutType, typename InType>
   static constexpr OutType Call(KernelContext*, const InType& value, Status*) {
-    if constexpr (std::is_same_v<InType, Float16>) {
+    if constexpr (std::same_as<InType, Float16>) {
       return value.is_nan();
     } else {
       return std::isnan(value);
diff --git a/cpp/src/arrow/field_ref_test.cc b/cpp/src/arrow/field_ref_test.cc
index 25c8aa0b7162..dd776adaf13b 100644
--- a/cpp/src/arrow/field_ref_test.cc
+++ b/cpp/src/arrow/field_ref_test.cc
@@ -48,13 +48,13 @@ struct FieldPathTestCase {
 
     template <typename T>
     const auto& OutputAs() const {
-      if constexpr (std::is_same_v<T, Field>) {
+      if constexpr (std::same_as<T, Field>) {
         return field;
-      } else if constexpr (std::is_same_v<T, Array>) {
+      } else if constexpr (std::same_as<T, Array>) {
         return array;
-      } else if constexpr (std::is_same_v<T, ArrayData>) {
+      } else if constexpr (std::same_as<T, ArrayData>) {
         return array->data();
-      } else if constexpr (std::is_same_v<T, ChunkedArray>) {
+      } else if constexpr (std::same_as<T, ChunkedArray>) {
         return chunked_array;
       }
     }
@@ -79,19 +79,19 @@ struct FieldPathTestCase {
 
   template <typename T>
   const auto& InputAs() const {
-    if constexpr (std::is_same_v<T, Schema>) {
+    if constexpr (std::same_as<T, Schema>) {
       return schema;
-    } else if constexpr (std::is_same_v<T, DataType>) {
+    } else if constexpr (std::same_as<T, DataType>) {
       return type;
-    } else if constexpr (std::is_same_v<T, Array>) {
+    } else if constexpr (std::same_as<T, Array>) {
       return array;
-    } else if constexpr (std::is_same_v<T, ArrayData>) {
+    } else if constexpr (std::same_as<T, ArrayData>) {
       return array->data();
-    } else if constexpr (std::is_same_v<T, RecordBatch>) {
+    } else if constexpr (std::same_as<T, RecordBatch>) {
       return record_batch;
-    } else if constexpr (std::is_same_v<T, ChunkedArray>) {
+    } else if constexpr (std::same_as<T, ChunkedArray>) {
       return chunked_array;
-    } else if constexpr (std::is_same_v<T, Table>) {
+    } else if constexpr (std::same_as<T, Table>) {
       return table;
     }
   }
@@ -246,7 +246,7 @@ class FieldPathTestFixture : public ::testing::Test {
     // they're reused to create the input Table (which has a distinct chunking per
     // column). However, if the input was the ChunkedArray, the returned outputs should
     // always have the same num_chunks as the input.
-    if constexpr (std::is_same_v<I, ChunkedArray>) {
+    if constexpr (std::same_as<I, ChunkedArray>) {
       EXPECT_EQ(case_->chunked_array->num_chunks(), actual->num_chunks());
     } else {
       EXPECT_EQ(expected->num_chunks(), actual->num_chunks());
@@ -287,7 +287,7 @@ class TestFieldPath : public FieldPathTestFixture {
     using O = OutputType<I>;
     auto result = DoGet<Flattened>(*case_->InputAs<I>(), FieldPath({1, 1, 2}));
     std::string substr = "index out of range. indices=[ 1 1 >2< ] ";
-    if constexpr (std::is_same_v<O, Field>) {
+    if constexpr (std::same_as<O, Field>) {
       substr += "fields: { a: float, a: bool, }";
     } else {
       substr += "column types: { float, bool, }";
diff --git a/cpp/src/arrow/filesystem/s3_internal.h b/cpp/src/arrow/filesystem/s3_internal.h
index 6f2780ddc05d..24e838fd5d50 100644
--- a/cpp/src/arrow/filesystem/s3_internal.h
+++ b/cpp/src/arrow/filesystem/s3_internal.h
@@ -84,7 +84,7 @@ inline bool IsConnectError(const Aws::Client::AWSError<Error>& error) {
 template <typename ErrorType>
 inline std::optional<std::string> BucketRegionFromError(
     const Aws::Client::AWSError<ErrorType>& error) {
-  if constexpr (std::is_same_v<ErrorType, Aws::S3::S3Errors>) {
+  if constexpr (std::same_as<ErrorType, Aws::S3::S3Errors>) {
     const auto& headers = error.GetResponseHeaders();
     const auto it = headers.find("x-amz-bucket-region");
     if (it != headers.end()) {
diff --git a/cpp/src/arrow/flight/flight_internals_test.cc b/cpp/src/arrow/flight/flight_internals_test.cc
index a66ac210b861..f3a394a037d3 100644
--- a/cpp/src/arrow/flight/flight_internals_test.cc
+++ b/cpp/src/arrow/flight/flight_internals_test.cc
@@ -69,8 +69,8 @@ void TestRoundtrip(const std::vector<FlightType>& values,
 
     ASSERT_OK_AND_ASSIGN(std::string serialized, values[i].SerializeToString());
     ASSERT_OK_AND_ASSIGN(auto deserialized, FlightType::Deserialize(serialized));
-    if constexpr (std::is_same_v<FlightType, FlightInfo> ||
-                  std::is_same_v<FlightType, PollInfo>) {
+    if constexpr (std::same_as<FlightType, FlightInfo> ||
+                  std::same_as<FlightType, PollInfo>) {
       ARROW_SCOPED_TRACE("Deserialized = ", deserialized->ToString());
       EXPECT_EQ(values[i], *deserialized);
     } else {
@@ -83,11 +83,11 @@ void TestRoundtrip(const std::vector<FlightType>& values,
     PbType pb_value;
     ASSERT_OK(internal::ToProto(values[i], &pb_value));
 
-    if constexpr (std::is_same_v<FlightType, FlightInfo>) {
+    if constexpr (std::same_as<FlightType, FlightInfo>) {
       FlightInfo::Data info_data;
       ASSERT_OK(internal::FromProto(pb_value, &info_data));
       EXPECT_EQ(values[i], FlightInfo{std::move(info_data)});
-    } else if constexpr (std::is_same_v<FlightType, SchemaResult>) {
+    } else if constexpr (std::same_as<FlightType, SchemaResult>) {
       SchemaResult value;
       ASSERT_OK(internal::FromProto(pb_value, &value));
       EXPECT_EQ(values[i], value);
diff --git a/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc b/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc
index ba8b883aac47..7ed5ba631d27 100644
--- a/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc
+++ b/cpp/src/arrow/flight/sql/odbc/tests/statement_test.cc
@@ -1058,9 +1058,9 @@ TYPED_TEST(StatementTest, DISABLED_TestSQLExecDirectFloatTruncation) {
   // Test is disabled until float truncation is supported.
   // GH-46985: return warning message instead of error on float truncation case
   std::wstring wsql;
-  if constexpr (std::is_same_v<TypeParam, StatementMockTest>) {
+  if constexpr (std::same_as<TypeParam, StatementMockTest>) {
     wsql = L"SELECT CAST(1.234 AS REAL) AS float_val";
-  } else if constexpr (std::is_same_v<TypeParam, StatementRemoteTest>) {
+  } else if constexpr (std::same_as<TypeParam, StatementRemoteTest>) {
     wsql = L"SELECT CAST(1.234 AS FLOAT) AS float_val";
   }
   std::vector<SQLWCHAR> sql0(wsql.begin(), wsql.end());
diff --git a/cpp/src/arrow/record_batch_test.cc b/cpp/src/arrow/record_batch_test.cc
index fea47244daf1..a59c88abf93a 100644
--- a/cpp/src/arrow/record_batch_test.cc
+++ b/cpp/src/arrow/record_batch_test.cc
@@ -1933,7 +1933,7 @@ class TestRecordBatchMakeStatisticsArrayBinary : public ::testing::Test {
   }
 
   std::shared_ptr<::arrow::DataType> type() {
-    if constexpr (std::is_same_v<DataType, FixedSizeBinaryType>) {
+    if constexpr (std::same_as<DataType, FixedSizeBinaryType>) {
       return fixed_size_binary(1);
     } else {
       return TypeTraits<DataType>::type_singleton();
diff --git a/cpp/src/arrow/result_test.cc b/cpp/src/arrow/result_test.cc
index ad92841a6e70..3bcae805862e 100644
--- a/cpp/src/arrow/result_test.cc
+++ b/cpp/src/arrow/result_test.cc
@@ -642,18 +642,18 @@ TEST(ResultTest, MapFunctionToStatus) {
   const Result<MoveOnlyDataType> const_result(MoveOnlyDataType{kIntElement});
   auto const_mapped =
       const_result.Map([](const MoveOnlyDataType& m) -> Status { return Status::OK(); });
-  static_assert(std::is_same_v<decltype(const_mapped), Status>);
+  static_assert(std::same_as<decltype(const_mapped), Status>);
   EXPECT_TRUE(const_mapped.ok());
 
   auto move_mapped = Result<MoveOnlyDataType>(MoveOnlyDataType{kIntElement})
                          .Map([](MoveOnlyDataType m) -> Status { return Status::OK(); });
-  static_assert(std::is_same_v<decltype(move_mapped), Status>);
+  static_assert(std::same_as<decltype(move_mapped), Status>);
   EXPECT_TRUE(move_mapped.ok());
 
   const Result<MoveOnlyDataType> error_result(error);
   auto error_mapped =
       error_result.Map([](const MoveOnlyDataType& m) -> Status { return Status::OK(); });
-  static_assert(std::is_same_v<decltype(error_mapped), Status>);
+  static_assert(std::same_as<decltype(error_mapped), Status>);
   EXPECT_FALSE(error_mapped.ok());
   EXPECT_EQ(error_mapped, error);
 }
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index 3e79d25d629c..153aebbc5b5c 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -1001,7 +1001,7 @@ struct MakeScalarImpl {
   // This isn't captured by the generic case above because `util::Float16` isn't implicity
   // convertible to `uint16_t` (HalfFloat's ValueType)
   template <typename T>
-  std::enable_if_t<std::is_same_v<std::decay_t<ValueRef>, util::Float16> &&
+  std::enable_if_t<std::same_as<std::decay_t<ValueRef>, util::Float16> &&
                        is_half_float_type<T>::value,
                    Status>
   Visit(const T& t) {
diff --git a/cpp/src/arrow/tensor.cc b/cpp/src/arrow/tensor.cc
index 8b3137d66a35..34a9811d5083 100644
--- a/cpp/src/arrow/tensor.cc
+++ b/cpp/src/arrow/tensor.cc
@@ -264,7 +264,7 @@ struct ConvertArrayToTensorVisitor {
       auto in_values = ArraySpan(in_data).GetSpan<In>(1, in_data.length);
 
       if (in_data.null_count == 0) {
-        if constexpr (std::is_same_v<In, Out>) {
+        if constexpr (std::same_as<In, Out>) {
           memcpy(out_values, in_values.data(), in_values.size_bytes());
           out_values += in_values.size();
         } else {
@@ -274,7 +274,7 @@ struct ConvertArrayToTensorVisitor {
         }
       } else {
         for (int64_t i = 0; i < in_data.length; ++i) {
-          if constexpr (T::type_id == Type::HALF_FLOAT && std::is_same_v<Out, uint16_t>) {
+          if constexpr (T::type_id == Type::HALF_FLOAT && std::same_as<Out, uint16_t>) {
             *out_values++ = in_data.IsNull(i)
                                 ? std::numeric_limits<util::Float16>::quiet_NaN().bits()
                                 : static_cast<Out>(in_values[i]);
@@ -312,7 +312,7 @@ struct ConvertArrayToTensorRowMajorVisitor {
         }
       } else {
         for (int64_t i = 0; i < in_data.length; ++i) {
-          if constexpr (T::type_id == Type::HALF_FLOAT && std::is_same_v<Out, uint16_t>) {
+          if constexpr (T::type_id == Type::HALF_FLOAT && std::same_as<Out, uint16_t>) {
             out_values[base + i * num_cols] =
                 in_data.IsNull(i) ? std::numeric_limits<util::Float16>::quiet_NaN().bits()
                                   : static_cast<Out>(in_values[i]);
@@ -338,7 +338,7 @@ inline void ConvertColumnsToTensor(const Container& container, uint8_t* out,
   const int num_columns = container.num_columns();
 
   for (int col_idx = 0; col_idx < num_columns; ++col_idx) {
-    if constexpr (std::is_same_v<Container, Table>) {
+    if constexpr (std::same_as<Container, Table>) {
       int64_t chunk_idx = 0;
 
       for (const auto& chunk : container.columns()[col_idx]->chunks()) {
@@ -352,7 +352,7 @@ inline void ConvertColumnsToTensor(const Container& container, uint8_t* out,
           DCHECK_OK(VisitTypeInline(*chunk->type(), &visitor));
         }
       }
-    } else if constexpr (std::is_same_v<Container, RecordBatch>) {
+    } else if constexpr (std::same_as<Container, RecordBatch>) {
       const auto& array_data = container.column_data()[col_idx];
 
       if (row_major) {
@@ -379,9 +379,9 @@ Status ToTensorImpl(const Container& container, bool null_to_nan, bool row_major
   // if null_to_nan conversion is set to false
   for (int i = 0; i < container.num_columns(); ++i) {
     int64_t null_count = 0;
-    if constexpr (std::is_same_v<Container, Table>) {
+    if constexpr (std::same_as<Container, Table>) {
       null_count = container.column(i)->null_count();
-    } else if constexpr (std::is_same_v<Container, RecordBatch>) {
+    } else if constexpr (std::same_as<Container, RecordBatch>) {
       null_count = container.column_data(i)->GetNullCount();
     }
     if (null_count > 0 && !null_to_nan) {
diff --git a/cpp/src/arrow/testing/math.cc b/cpp/src/arrow/testing/math.cc
index df65544f0690..95da55b19a74 100644
--- a/cpp/src/arrow/testing/math.cc
+++ b/cpp/src/arrow/testing/math.cc
@@ -32,7 +32,7 @@ namespace {
 
 template <typename Float>
 bool WithinUlpGeneric(Float left, Float right, int32_t n_ulps) {
-  if constexpr (std::is_same_v<Float, util::Float16>) {
+  if constexpr (std::same_as<Float, util::Float16>) {
     if (left.is_nan() || right.is_nan()) {
       return left.is_nan() == right.is_nan();
     }
diff --git a/cpp/src/arrow/testing/random.cc b/cpp/src/arrow/testing/random.cc
index db7a60e4400f..28dfd3a28118 100644
--- a/cpp/src/arrow/testing/random.cc
+++ b/cpp/src/arrow/testing/random.cc
@@ -93,7 +93,7 @@ struct GeneratorFactory<Float16, DistributionType> {
 
 template <typename ValueType, typename DistributionType>
 struct GenerateOptions {
-  static constexpr bool kIsHalfFloat = std::is_same_v<ValueType, Float16>;
+  static constexpr bool kIsHalfFloat = std::same_as<ValueType, Float16>;
   using PhysicalType = std::conditional_t<kIsHalfFloat, HalfFloatType::c_type, ValueType>;
   using FactoryType = GeneratorFactory<ValueType, DistributionType>;
 
@@ -408,7 +408,7 @@ struct SmallDecimalGenerator {
   std::shared_ptr<Array> MakeRandomArray(int64_t size, double null_probability,
                                          int64_t alignment, MemoryPool* memory_pool) {
     static constexpr int32_t kMaxDigitsInInteger =
-        std::is_same_v<DecimalType, Decimal32Type> ? 9 : 18;
+        std::same_as<DecimalType, Decimal32Type> ? 9 : 18;
     static_assert(
         kMaxDigitsInInteger >= DecimalType::kByteWidth,
         "inconsistent decimal metadata: kMaxPrecision doesn't match kByteWidth");
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index e841f0918097..c7471c8ce5c1 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -1621,7 +1621,7 @@ struct NestedSelectorUtil {
 
   template <typename T>
   static const DataType* GetType(const T& input) {
-    if constexpr (std::is_same_v<T, ArrayData>) {
+    if constexpr (std::same_as<T, ArrayData>) {
       return input.type.get();
     } else {
       return input.type().get();
@@ -1658,7 +1658,7 @@ class NestedSelector {
       const DataType* type = Util::GetType(*parent);
       // We avoid this check for schema fields since it's inconsequential (plus there are
       // tests elsewhere that rely on it not happening)
-      if constexpr (!std::is_same_v<T, Field>) {
+      if constexpr (!std::same_as<T, Field>) {
         if (ARROW_PREDICT_FALSE(type->id() != Type::STRUCT)) {
           return Util::NonStructError();
         }
@@ -1681,7 +1681,7 @@ class NestedSelector {
   }
 
   template <typename OStream, typename U = T>
-  std::enable_if_t<std::is_same_v<U, Field>> Summarize(OStream* os) const {
+  std::enable_if_t<std::same_as<U, Field>> Summarize(OStream* os) const {
     const FieldVector* fields = get_children();
     if (!fields && get_parent()) {
       fields = &get_parent()->type()->fields();
@@ -1696,7 +1696,7 @@ class NestedSelector {
   }
 
   template <typename OStream, typename U = T>
-  std::enable_if_t<!std::is_same_v<U, Field>> Summarize(OStream* os) const {
+  std::enable_if_t<!std::same_as<U, Field>> Summarize(OStream* os) const {
     *os << "column types: { ";
     if (auto children = get_children()) {
       for (const auto& child : *children) {
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index 133afbfa0c58..b25755983f87 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -1494,17 +1494,17 @@ PRIMITIVE_TEST(DoubleType, double, DOUBLE, "double");
 PRIMITIVE_TEST(BooleanType, bool, BOOL, "bool");
 
 TEST(TypesTest, DecimalTraits) {
-  static_assert(std::is_same_v<TypeTraits<Decimal32Type>::CType, Decimal32>);
-  static_assert(std::is_same_v<CTypeTraits<Decimal32>::ArrowType, Decimal32Type>);
+  static_assert(std::same_as<TypeTraits<Decimal32Type>::CType, Decimal32>);
+  static_assert(std::same_as<CTypeTraits<Decimal32>::ArrowType, Decimal32Type>);
 
-  static_assert(std::is_same_v<TypeTraits<Decimal64Type>::CType, Decimal64>);
-  static_assert(std::is_same_v<CTypeTraits<Decimal64>::ArrowType, Decimal64Type>);
+  static_assert(std::same_as<TypeTraits<Decimal64Type>::CType, Decimal64>);
+  static_assert(std::same_as<CTypeTraits<Decimal64>::ArrowType, Decimal64Type>);
 
-  static_assert(std::is_same_v<TypeTraits<Decimal128Type>::CType, Decimal128>);
-  static_assert(std::is_same_v<CTypeTraits<Decimal128>::ArrowType, Decimal128Type>);
+  static_assert(std::same_as<TypeTraits<Decimal128Type>::CType, Decimal128>);
+  static_assert(std::same_as<CTypeTraits<Decimal128>::ArrowType, Decimal128Type>);
 
-  static_assert(std::is_same_v<TypeTraits<Decimal256Type>::CType, Decimal256>);
-  static_assert(std::is_same_v<CTypeTraits<Decimal256>::ArrowType, Decimal256Type>);
+  static_assert(std::same_as<TypeTraits<Decimal256Type>::CType, Decimal256>);
+  static_assert(std::same_as<CTypeTraits<Decimal256>::ArrowType, Decimal256Type>);
 }
 
 TEST(TestBinaryType, ToString) {
diff --git a/cpp/src/arrow/util/basic_decimal.h b/cpp/src/arrow/util/basic_decimal.h
index 638c4870f1de..540ade4eabd9 100644
--- a/cpp/src/arrow/util/basic_decimal.h
+++ b/cpp/src/arrow/util/basic_decimal.h
@@ -171,7 +171,7 @@ template <typename DigitType>
 class ARROW_EXPORT SmallBasicDecimal {
  public:
   static_assert(
-      std::is_same_v<DigitType, int32_t> || std::is_same_v<DigitType, int64_t>,
+      std::same_as<DigitType, int32_t> || std::same_as<DigitType, int64_t>,
       "for bitwidths larger than 64 bits use BasicDecimal128 and BasicDecimal256");
 
   static constexpr int kMaxPrecision = std::numeric_limits<DigitType>::digits10;
diff --git a/cpp/src/arrow/util/bit_stream_utils_internal.h b/cpp/src/arrow/util/bit_stream_utils_internal.h
index 10176e4257a8..7cd164c59539 100644
--- a/cpp/src/arrow/util/bit_stream_utils_internal.h
+++ b/cpp/src/arrow/util/bit_stream_utils_internal.h
@@ -281,7 +281,7 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) {
       .max_read_bytes = max_bytes_ - byte_offset_,
   };
 
-  if constexpr (std::is_same_v<T, bool>) {
+  if constexpr (std::same_as<T, bool>) {
     ::arrow::internal::unpack(buffer_ + byte_offset_, v, opts);
 
   } else {
@@ -307,7 +307,7 @@ inline bool BitReader::GetAligned(int num_bytes, T* v) {
 
   // Advance byte_offset to next unread byte and read num_bytes
   byte_offset_ += bytes_read;
-  if constexpr (std::is_same_v<T, bool>) {
+  if constexpr (std::same_as<T, bool>) {
     // ARROW-18031: if we're trying to get an aligned bool, just check
     // the LSB of the next byte and move on. If we memcpy + FromLittleEndian
     // as usual, we have potential undefined behavior for bools if the value
diff --git a/cpp/src/arrow/util/bitmap_ops.cc b/cpp/src/arrow/util/bitmap_ops.cc
index 5f76fa4e33d9..d751c1657126 100644
--- a/cpp/src/arrow/util/bitmap_ops.cc
+++ b/cpp/src/arrow/util/bitmap_ops.cc
@@ -237,7 +237,7 @@ void MapBitmapUnary(const uint8_t* data, int64_t offset, int64_t length,
     const uint8_t trail_mask = (1U << (8 - trailing_bits)) - 1;
     uint8_t last_data;
 
-    if constexpr (std::is_same_v<std::decay_t<Op>, Identity>) {
+    if constexpr (std::same_as<std::decay_t<Op>, Identity>) {
       std::memcpy(dest, data, static_cast<size_t>(num_bytes - 1));
       last_data = data[num_bytes - 1];
     } else {
diff --git a/cpp/src/arrow/util/bpacking_dispatch_internal.h b/cpp/src/arrow/util/bpacking_dispatch_internal.h
index 6ea6adee1800..976bea4500f1 100644
--- a/cpp/src/arrow/util/bpacking_dispatch_internal.h
+++ b/cpp/src/arrow/util/bpacking_dispatch_internal.h
@@ -253,7 +253,7 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 
 template <template <typename, int> typename Unpacker, typename UnpackedUint>
 static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt) {
-  if constexpr (std::is_same_v<UnpackedUint, bool>) {
+  if constexpr (std::same_as<UnpackedUint, bool>) {
     switch (opt.bit_width) {
       case 0:
         return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
diff --git a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
index 83a969cca643..9c76974765a6 100644
--- a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
@@ -313,7 +313,7 @@ template <typename UnpackedUint, int kPackedBitSize, typename Arch>
 struct KernelTraits {
   using unpacked_type = UnpackedUint;
   /// The integer type to work with, `unpacked_type` or an appropriate type for bool.
-  using uint_type = std::conditional_t<std::is_same_v<unpacked_type, bool>,
+  using uint_type = std::conditional_t<std::same_as<unpacked_type, bool>,
                                        SizedUint<sizeof(bool)>, unpacked_type>;
   using arch_type = Arch;
   using simd_batch = xsimd::batch<uint_type, arch_type>;
@@ -661,7 +661,7 @@ struct MediumKernel {
     // can use the fallback on these platforms.
     const auto shifted = right_shift_by_excess(words, kRightShifts);
     const auto vals = shifted & kMask;
-    if constexpr (std::is_same_v<unpacked_type, bool>) {
+    if constexpr (std::same_as<unpacked_type, bool>) {
       const xsimd::batch_bool<uint_type, arch_type> bools = vals != 0;
       bools.store_unaligned(out + kOutOffset);
     } else {
diff --git a/cpp/src/arrow/util/bpacking_test.cc b/cpp/src/arrow/util/bpacking_test.cc
index 52c67dbd7986..f9c0af0d5b2b 100644
--- a/cpp/src/arrow/util/bpacking_test.cc
+++ b/cpp/src/arrow/util/bpacking_test.cc
@@ -55,7 +55,7 @@ std::vector<Uint> GenerateRandomValuesForPacking(int num_values, int bit_width)
     return out;
   }
 
-  if constexpr (std::is_same_v<Uint, bool>) {
+  if constexpr (std::same_as<Uint, bool>) {
     random_is_valid(num_values, 0.5, &out, kSeed);
   } else {
     const uint64_t max = bit_util::LeastSignificantBitMask<uint64_t, true>(bit_width);
@@ -68,7 +68,7 @@ std::vector<Uint> GenerateRandomValuesForPacking(int num_values, int bit_width)
 template <typename Int>
 std::vector<Int> UnpackValues(const uint8_t* packed, const UnpackOptions& opts,
                               UnpackFunc<Int> unpack) {
-  if constexpr (std::is_same_v<Int, bool>) {
+  if constexpr (std::same_as<Int, bool>) {
     // Using dynamic array to avoid std::vector<bool>
     auto buffer = std::make_unique<Int[]>(opts.batch_size);
     unpack(packed, buffer.get(), opts);
@@ -149,7 +149,7 @@ class TestUnpack : public ::testing::Test {
 
     // Generate bit_width ones
     Int expected_value = 0;
-    if constexpr (std::is_same_v<Int, bool>) {
+    if constexpr (std::same_as<Int, bool>) {
       expected_value = static_cast<bool>(opts.bit_width);
     } else {
       for (int i = 0; i < opts.bit_width; ++i) {
@@ -196,7 +196,7 @@ class TestUnpack : public ::testing::Test {
     for (int num_values_base : {64, 128, 2048}) {
       SCOPED_TRACE(::testing::Message() << "Testing num_values=" << num_values_base);
 
-      constexpr int kMaxBitWidth = std::is_same_v<Int, bool> ? 1 : 8 * sizeof(Int);
+      constexpr int kMaxBitWidth = std::same_as<Int, bool> ? 1 : 8 * sizeof(Int);
 
       // Given how many edge cases there are in unpacking integers, it is best to test all
       // bit widths.
@@ -260,11 +260,11 @@ using UnpackTypes = ::testing::Types<bool, uint8_t, uint16_t, uint32_t, uint64_t
 struct UnpackTypeNames {
   template <typename T>
   static std::string GetName(int) {
-    if constexpr (std::is_same_v<T, bool>) return "bool";
-    if constexpr (std::is_same_v<T, uint8_t>) return "uint8_t";
-    if constexpr (std::is_same_v<T, uint16_t>) return "uint16_t";
-    if constexpr (std::is_same_v<T, uint32_t>) return "uint32_t";
-    if constexpr (std::is_same_v<T, uint64_t>) return "uint64_t";
+    if constexpr (std::same_as<T, bool>) return "bool";
+    if constexpr (std::same_as<T, uint8_t>) return "uint8_t";
+    if constexpr (std::same_as<T, uint16_t>) return "uint16_t";
+    if constexpr (std::same_as<T, uint32_t>) return "uint32_t";
+    if constexpr (std::same_as<T, uint64_t>) return "uint64_t";
   }
 };
 
diff --git a/cpp/src/arrow/util/decimal.h b/cpp/src/arrow/util/decimal.h
index bae0c4dd248c..75bc4f211e93 100644
--- a/cpp/src/arrow/util/decimal.h
+++ b/cpp/src/arrow/util/decimal.h
@@ -149,9 +149,9 @@ class ARROW_EXPORT Decimal32 : public BasicDecimal32 {
   /// \brief Convert to a floating-point number (scaled)
   template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
   T ToReal(int32_t scale) const {
-    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+    static_assert(std::same_as<T, float> || std::same_as<T, double>,
                   "Unexpected floating-point type");
-    if constexpr (std::is_same_v<T, float>) {
+    if constexpr (std::same_as<T, float>) {
       return ToFloat(scale);
     } else {
       return ToDouble(scale);
@@ -255,9 +255,9 @@ class ARROW_EXPORT Decimal64 : public BasicDecimal64 {
   /// \brief Convert to a floating-point number (scaled)
   template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
   T ToReal(int32_t scale) const {
-    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+    static_assert(std::same_as<T, float> || std::same_as<T, double>,
                   "Unexpected floating-point type");
-    if constexpr (std::is_same_v<T, float>) {
+    if constexpr (std::same_as<T, float>) {
       return ToFloat(scale);
     } else {
       return ToDouble(scale);
@@ -383,9 +383,9 @@ class ARROW_EXPORT Decimal128 : public BasicDecimal128 {
   /// \brief Convert to a floating-point number (scaled)
   template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
   T ToReal(int32_t scale) const {
-    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+    static_assert(std::same_as<T, float> || std::same_as<T, double>,
                   "Unexpected floating-point type");
-    if constexpr (std::is_same_v<T, float>) {
+    if constexpr (std::same_as<T, float>) {
       return ToFloat(scale);
     } else {
       return ToDouble(scale);
@@ -484,9 +484,9 @@ class ARROW_EXPORT Decimal256 : public BasicDecimal256 {
   /// \brief Convert to a floating-point number (scaled)
   template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
   T ToReal(int32_t scale) const {
-    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+    static_assert(std::same_as<T, float> || std::same_as<T, double>,
                   "Unexpected floating-point type");
-    if constexpr (std::is_same_v<T, float>) {
+    if constexpr (std::same_as<T, float>) {
       return ToFloat(scale);
     } else {
       return ToDouble(scale);
diff --git a/cpp/src/arrow/util/decimal_test.cc b/cpp/src/arrow/util/decimal_test.cc
index 7022c8117802..5725f4467b0f 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -1022,7 +1022,7 @@ class TestDecimalFromRealDouble : public ::testing::Test {
                             "9999999987.0000000000000000000000000000"},
     };
     std::vector<FromDoubleTestParam> type_dependent_values;
-    if (std::is_same_v<T, Decimal128>) {
+    if (std::same_as<T, Decimal128>) {
       // clang-format off
       type_dependent_values = {
         // 1 - 2**-52
@@ -1034,7 +1034,7 @@ class TestDecimalFromRealDouble : public ::testing::Test {
         FromDoubleTestParam{0.9999999999999998, 16, 16, "0.9999999999999998"},
       };
       // clang-format on
-    } else if (std::is_same_v<T, Decimal256>) {
+    } else if (std::same_as<T, Decimal256>) {
       // clang-format off
       type_dependent_values = {
         // 1 - 2**-52
@@ -1494,7 +1494,7 @@ TYPED_TEST(TestBasicDecimalFunctionality, Multiply) {
           << " x: " << x << " y: " << y;
 
       // for Decimal128
-      if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+      if constexpr (std::same_as<TypeParam, Decimal128>) {
         // Test by multiplying with an additional 32 bit factor, then additional
         // factor of 2^30 to test results in the range of -2^123 to 2^123 without
         // overflow.
@@ -1509,7 +1509,7 @@ TYPED_TEST(TestBasicDecimalFunctionality, Multiply) {
   }
 
   // Test edge cases for Decimal128
-  if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+  if constexpr (std::same_as<TypeParam, Decimal128>) {
     for (auto x :
          std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
       for (auto y :
@@ -1547,7 +1547,7 @@ TYPED_TEST(TestBasicDecimalFunctionality, Divide) {
   }
 
   // Edge cases for Decimal128
-  if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+  if constexpr (std::same_as<TypeParam, Decimal128>) {
     for (auto x :
          std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
       for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
@@ -1569,9 +1569,9 @@ TYPED_TEST(TestBasicDecimalFunctionality, Rescale) {
   ASSERT_RAISES(Invalid, TypeParam(555555).Rescale(6, 1));
 
   using OrigScaleType =
-      std::conditional_t<std::is_same_v<TypeParam, Decimal32>, Int8Type, Int16Type>;
+      std::conditional_t<std::same_as<TypeParam, Decimal32>, Int8Type, Int16Type>;
   using ValueType =
-      std::conditional_t<std::is_same_v<TypeParam, Decimal32>, Int16Type, Int32Type>;
+      std::conditional_t<std::same_as<TypeParam, Decimal32>, Int16Type, Int32Type>;
 
   // Test some random numbers.
   for (auto original_scale : GetRandomNumbers<OrigScaleType>(16)) {
@@ -1624,7 +1624,7 @@ TYPED_TEST(TestBasicDecimalFunctionality, Mod) {
   }
 
   // Edge cases for Decimal128
-  if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+  if constexpr (std::same_as<TypeParam, Decimal128>) {
     // Test some edge cases
     for (auto x :
          std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
diff --git a/cpp/src/arrow/util/dispatch_internal.h b/cpp/src/arrow/util/dispatch_internal.h
index 36e5152ee650..9cd1fde6f340 100644
--- a/cpp/src/arrow/util/dispatch_internal.h
+++ b/cpp/src/arrow/util/dispatch_internal.h
@@ -66,7 +66,7 @@ inline constexpr bool is_std_array_v<std::array<T, N>> = true;
 template <typename Arr, typename FunctionType>
 concept DynamicDispatchTargets =
     detail::is_std_array_v<Arr> &&
-    std::is_same_v<typename Arr::value_type, DynamicDispatchTarget<FunctionType>>;
+    std::same_as<typename Arr::value_type, DynamicDispatchTarget<FunctionType>>;
 
 /// Return whether a given dispatch level is static.
 ///
diff --git a/cpp/src/arrow/util/float16.cc b/cpp/src/arrow/util/float16.cc
index d3dc91b849a5..1708bb637772 100644
--- a/cpp/src/arrow/util/float16.cc
+++ b/cpp/src/arrow/util/float16.cc
@@ -43,7 +43,7 @@ namespace {
 
 template <typename T>
 struct BinaryConverter {
-  static_assert(std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t>);
+  static_assert(std::same_as<T, uint32_t> || std::same_as<T, uint64_t>);
 
   static constexpr int kNumBits = sizeof(T) * 8;
   static constexpr int kMantNumBits = (kNumBits == 32) ? 23 : 52;
diff --git a/cpp/src/arrow/util/formatting_util_test.cc b/cpp/src/arrow/util/formatting_util_test.cc
index 186e5a8b4331..ffeda6834480 100644
--- a/cpp/src/arrow/util/formatting_util_test.cc
+++ b/cpp/src/arrow/util/formatting_util_test.cc
@@ -389,7 +389,7 @@ void TestDecimalFormatter() {
       continue;
     }
 
-    if constexpr (std::is_same_v<T, Decimal32Type>) {
+    if constexpr (std::same_as<T, Decimal32Type>) {
       if (data.test_value > 999999999 || data.test_value < -999999999) {
         continue;
       }
diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h
index c29b6c211d77..fe8bb85a7562 100644
--- a/cpp/src/arrow/util/hashing.h
+++ b/cpp/src/arrow/util/hashing.h
@@ -146,7 +146,7 @@ struct ScalarHelper<Scalar, AlgNum, enable_if_t<std::is_floating_point<Scalar>::
 
 template <typename Scalar, uint64_t AlgNum>
 struct ScalarHelper<Scalar, AlgNum,
-                    enable_if_t<std::is_same_v<Scalar, ::arrow::util::Float16>>>
+                    enable_if_t<std::same_as<Scalar, ::arrow::util::Float16>>>
     : public ScalarHelperBase<Scalar, AlgNum> {
   // ScalarHelper specialization for Float16
 
diff --git a/cpp/src/arrow/util/iterator.h b/cpp/src/arrow/util/iterator.h
index aaf6531dfefe..8fa0d01fb380 100644
--- a/cpp/src/arrow/util/iterator.h
+++ b/cpp/src/arrow/util/iterator.h
@@ -520,7 +520,7 @@ struct FilterIterator {
 template <typename Fn, typename From,
           typename Ret = typename std::invoke_result_t<Fn&, From>::ValueType,
           typename To = std::tuple_element_t<0, Ret>>
-  requires std::is_same_v<std::tuple_element_t<1, Ret>, FilterIterator::Action>
+  requires std::same_as<std::tuple_element_t<1, Ret>, FilterIterator::Action>
 Iterator<To> MakeFilterIterator(Fn filter, Iterator<From> it) {
   return Iterator<To>(
       FilterIterator::Impl<Fn, From, To>(std::move(filter), std::move(it)));
diff --git a/cpp/src/arrow/util/range.h b/cpp/src/arrow/util/range.h
index 449a1fbd80ce..4a5e1185824e 100644
--- a/cpp/src/arrow/util/range.h
+++ b/cpp/src/arrow/util/range.h
@@ -164,8 +164,8 @@ LazyRange<Generator> MakeLazyRange(Generator&& gen, int64_t length) {
 /// const std::vector<SomeTable>& tables = ...
 /// std::function<std::vector<std::string>()> GetNames = ...
 /// for (auto [table, name] : Zip(tables, GetNames())) {
-///   static_assert(std::is_same_v<decltype(table), const SomeTable&>);
-///   static_assert(std::is_same_v<decltype(name), std::string&>);
+///   static_assert(std::same_as<decltype(table), const SomeTable&>);
+///   static_assert(std::same_as<decltype(name), std::string&>);
 ///   // temporaries (like this vector of strings) are kept alive for the
 ///   // duration of a loop and are safely movable).
 ///   RegisterTableWithName(std::move(name), &table);
diff --git a/cpp/src/arrow/util/range_test.cc b/cpp/src/arrow/util/range_test.cc
index 282c5594384d..647270da7e1c 100644
--- a/cpp/src/arrow/util/range_test.cc
+++ b/cpp/src/arrow/util/range_test.cc
@@ -81,15 +81,15 @@ TEST(Zip, TupleTypes) {
            Enumerate<int>)) {     // 6. Enumerate
                                   //    (const lvalue range dereferencing to non ref)
     static_assert(
-        std::is_same_v<decltype(tuple),
-                       std::tuple<char&,               // 1. mutable lvalue ref binding
-                                  const std::string&,  // 2. const lvalue ref binding
-                                  float&,              // 3. mutable lvalue ref binding
-                                  std::vector<bool>::reference,  // 4. by-value non ref
-                                                                 // binding (thanks STL)
-                                  int  // 5. by-value non ref binding
-                                       //    (that's fine they're just ints)
-                                  >>);
+        std::same_as<decltype(tuple),
+                     std::tuple<char&,               // 1. mutable lvalue ref binding
+                                const std::string&,  // 2. const lvalue ref binding
+                                float&,              // 3. mutable lvalue ref binding
+                                std::vector<bool>::reference,  // 4. by-value non ref
+                                                               // binding (thanks STL)
+                                int  // 5. by-value non ref binding
+                                     //    (that's fine they're just ints)
+                                >>);
   }
 
   static size_t max_count;
@@ -120,7 +120,7 @@ TEST(Zip, TupleTypes) {
       // Putting a const reference to range into Zip results in no copies and the
       // corresponding tuple element will also be a const reference
       EXPECT_EQ(count, 3);
-      static_assert(std::is_same_v<decltype(e), const Counted&>);
+      static_assert(std::same_as<decltype(e), const Counted&>);
     }
     EXPECT_EQ(count, 3);
   }
@@ -134,7 +134,7 @@ TEST(Zip, TupleTypes) {
       // Putting a mutable reference to range into Zip results in no copies and the
       // corresponding tuple element will also be a mutable reference
       EXPECT_EQ(count, 3);
-      static_assert(std::is_same_v<decltype(e), Counted&>);
+      static_assert(std::same_as<decltype(e), Counted&>);
     }
     EXPECT_EQ(count, 3);
   }
@@ -147,7 +147,7 @@ TEST(Zip, TupleTypes) {
       // alive as a mutable vector so that we can move out of it if we might reuse the
       // elements:
       EXPECT_EQ(count, 3);
-      static_assert(std::is_same_v<decltype(e), Counted&>);
+      static_assert(std::same_as<decltype(e), Counted&>);
     }
     EXPECT_EQ(count, 0);
   }
@@ -156,8 +156,8 @@ TEST(Zip, TupleTypes) {
     std::vector<bool> v{false, false, false, false};
     for (auto [i, e] : Zip(Enumerate<int>, v)) {
       // Testing with a range whose references aren't actually references
-      static_assert(std::is_same_v<decltype(e), decltype(v)::reference>);
-      static_assert(std::is_same_v<decltype(e), decltype(v[0])>);
+      static_assert(std::same_as<decltype(e), decltype(v)::reference>);
+      static_assert(std::same_as<decltype(e), decltype(v[0])>);
       static_assert(!std::is_reference_v<decltype(e)>);
       e = (i % 2 == 0);
     }
@@ -180,7 +180,7 @@ TEST(Zip, Enumerate) {
   std::vector<std::string> vec(3);
 
   for (auto [i, s] : Zip(Enumerate<>, vec)) {
-    static_assert(std::is_same_v<decltype(s), std::string&>);
+    static_assert(std::same_as<decltype(s), std::string&>);
     s = std::to_string(i + 7);
   }
 
diff --git a/cpp/src/arrow/util/ree_util.h b/cpp/src/arrow/util/ree_util.h
index 5c759f2e80dc..053711639442 100644
--- a/cpp/src/arrow/util/ree_util.h
+++ b/cpp/src/arrow/util/ree_util.h
@@ -192,12 +192,12 @@ struct PhysicalIndexFinder {
   /// \param i the logical index into the REE array
   /// \return the physical index into the values array
   int64_t FindPhysicalIndex(int64_t i) {
-    if constexpr (std::is_same_v<RunEndCType, int16_t>) {
+    if constexpr (std::same_as<RunEndCType, int16_t>) {
       return FindPhysicalIndexImpl16(*this, i);
-    } else if constexpr (std::is_same_v<RunEndCType, int32_t>) {
+    } else if constexpr (std::same_as<RunEndCType, int32_t>) {
       return FindPhysicalIndexImpl32(*this, i);
     } else {
-      static_assert(std::is_same_v<RunEndCType, int64_t>, "Unsupported RunEndCType.");
+      static_assert(std::same_as<RunEndCType, int64_t>, "Unsupported RunEndCType.");
       return FindPhysicalIndexImpl64(*this, i);
     }
   }
diff --git a/cpp/src/arrow/util/rle_encoding_internal.h b/cpp/src/arrow/util/rle_encoding_internal.h
index 4bd08fd65306..c6bbd73726a3 100644
--- a/cpp/src/arrow/util/rle_encoding_internal.h
+++ b/cpp/src/arrow/util/rle_encoding_internal.h
@@ -287,7 +287,7 @@ class RleRunDecoder {
 
   void Reset(const RunType& run, rle_size_t value_bit_width) noexcept {
     remaining_count_ = run.values_count();
-    if constexpr (std::is_same_v<value_type, bool>) {
+    if constexpr (std::same_as<value_type, bool>) {
       // ARROW-18031:  just check the LSB of the next byte and move on.
       // If we memcpy + FromLittleEndian, we have potential undefined behavior
       // if the bool value isn't 0 or 1.
@@ -432,7 +432,7 @@ class BitPackedRunDecoder {
         /* .max_read_bytes= */ static_cast<int>(max_read_bytes_ - bytes_fully_read),
     };
 
-    if constexpr (std::is_same_v<T, bool>) {
+    if constexpr (std::same_as<T, bool>) {
       ::arrow::internal::unpack(unread_data, out, opts);
 
     } else {
diff --git a/cpp/src/arrow/util/simdjson_internal.h b/cpp/src/arrow/util/simdjson_internal.h
index 5c52f7648c6a..42e6a7f6ad28 100644
--- a/cpp/src/arrow/util/simdjson_internal.h
+++ b/cpp/src/arrow/util/simdjson_internal.h
@@ -328,7 +328,7 @@ Result<T> GetJsonField(simdjson::ondemand::object& object, std::string_view key)
     if (field_key == key) {
       auto value = field.value();
 
-      if constexpr (std::is_same_v<T, simdjson::ondemand::value>) {
+      if constexpr (std::same_as<T, simdjson::ondemand::value>) {
         return value;
       } else {
         return GetJsonAs<T>(value);
diff --git a/cpp/src/arrow/util/ulp_distance_test.cc b/cpp/src/arrow/util/ulp_distance_test.cc
index e2c84e25f3ff..c569001fd3f0 100644
--- a/cpp/src/arrow/util/ulp_distance_test.cc
+++ b/cpp/src/arrow/util/ulp_distance_test.cc
@@ -55,7 +55,7 @@ void CheckWithinUlp(Float x, Float y, int n_ulp) {
   for (int exp : {1, -1, 10, -10}) {
     Float x_scaled(0);
     Float y_scaled(0);
-    if constexpr (std::is_same_v<Float, Float16>) {
+    if constexpr (std::same_as<Float, Float16>) {
       x_scaled = Float16(std::ldexp(x.ToFloat(), exp));
       y_scaled = Float16(std::ldexp(y.ToFloat(), exp));
     } else {
@@ -83,7 +83,7 @@ void CheckNotWithinUlp(Float x, Float y, int n_ulp) {
   for (int exp : {1, -1, 10, -10}) {
     Float x_scaled(0);
     Float y_scaled(0);
-    if constexpr (std::is_same_v<Float, Float16>) {
+    if constexpr (std::same_as<Float, Float16>) {
       x_scaled = Float16(std::ldexp(x.ToFloat(), exp));
       y_scaled = Float16(std::ldexp(y.ToFloat(), exp));
     } else {
diff --git a/cpp/src/arrow/visit_data_inline.h b/cpp/src/arrow/visit_data_inline.h
index b7f08bdaeebd..845751feab8c 100644
--- a/cpp/src/arrow/visit_data_inline.h
+++ b/cpp/src/arrow/visit_data_inline.h
@@ -43,7 +43,7 @@ struct ArraySpanInlineVisitor<T, enable_if_has_c_type<T>> {
   template <typename ValidFunc, typename NullFunc>
   static Status VisitStatus(const ArraySpan& arr, ValidFunc&& valid_func,
                             NullFunc&& null_func) {
-    if constexpr (std::is_same_v<T, BooleanType>) {
+    if constexpr (std::same_as<T, BooleanType>) {
       int64_t offset = arr.offset;
       const uint8_t* data = arr.buffers[1].data;
       return VisitBitBlocks(
@@ -61,7 +61,7 @@ struct ArraySpanInlineVisitor<T, enable_if_has_c_type<T>> {
   template <typename ValidFunc, typename NullFunc>
   static void VisitVoid(const ArraySpan& arr, ValidFunc&& valid_func,
                         NullFunc&& null_func) {
-    if constexpr (std::is_same_v<T, BooleanType>) {
+    if constexpr (std::same_as<T, BooleanType>) {
       int64_t offset = arr.offset;
       const uint8_t* data = arr.buffers[1].data;
       VisitBitBlocksVoid(
@@ -227,7 +227,7 @@ struct ArraySpanInlineVisitor<T, enable_if_fixed_size_binary<T>> {
 }  // namespace internal
 
 template <typename T, typename ValidFunc, typename NullFunc>
-  requires std::is_same_v<
+  requires std::same_as<
       std::invoke_result_t<ValidFunc,
                            typename internal::ArraySpanInlineVisitor<T>::c_type>,
       Status>
@@ -280,7 +280,7 @@ struct ArraySpanVisitor {
 // The `NullFunc` should have the same return type as `ValidFunc`.
 
 template <typename ValidFunc, typename NullFunc>
-  requires std::is_same_v<std::invoke_result_t<ValidFunc>, Status>
+  requires std::same_as<std::invoke_result_t<ValidFunc>, Status>
 Status VisitNullBitmapInline(const uint8_t* valid_bits, int64_t valid_bits_offset,
                              int64_t num_values, int64_t null_count,
                              ValidFunc&& valid_func, NullFunc&& null_func) {
diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 2bdbc38b3647..6a5047128604 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -3354,7 +3354,7 @@ void CheckListViewRoundTrip(
   using ViewArrayType = typename ::arrow::TypeTraits<ViewType>::ArrayType;
   using OffsetArrowType = typename ::arrow::TypeTraits<ViewType>::OffsetType;
   using FallbackArrayType =
-      std::conditional_t<std::is_same_v<ViewType, ::arrow::ListViewType>,
+      std::conditional_t<std::same_as<ViewType, ::arrow::ListViewType>,
                          ::arrow::ListArray, ::arrow::LargeListArray>;
 
   auto values = ArrayFromJSON(::arrow::int32(), "[1, 2, 3, 4, 5]");
diff --git a/cpp/src/parquet/arrow/reader.cc b/cpp/src/parquet/arrow/reader.cc
index bb8bacc7751a..8e3cb280e8a0 100644
--- a/cpp/src/parquet/arrow/reader.cc
+++ b/cpp/src/parquet/arrow/reader.cc
@@ -689,7 +689,7 @@ class PARQUET_NO_EXPORT ListViewReader : public ListReader<IndexType> {
   ::arrow::Result<std::shared_ptr<ChunkedArray>> AssembleArray(
       std::shared_ptr<ArrayData> data) final {
     static_assert(::arrow::internal::IsOneOf<IndexType, int32_t, int64_t>::value);
-    constexpr auto expected_type_id = std::is_same_v<IndexType, int32_t>
+    constexpr auto expected_type_id = std::same_as<IndexType, int32_t>
                                           ? ::arrow::Type::LIST_VIEW
                                           : ::arrow::Type::LARGE_LIST_VIEW;
     DCHECK_EQ(this->field()->type()->id(), expected_type_id);
diff --git a/cpp/src/parquet/arrow/reader_internal.cc b/cpp/src/parquet/arrow/reader_internal.cc
index b5207aca253f..16bfff821fca 100644
--- a/cpp/src/parquet/arrow/reader_internal.cc
+++ b/cpp/src/parquet/arrow/reader_internal.cc
@@ -391,7 +391,7 @@ void AttachStatistics(::arrow::ArrayData* data,
           checked_cast<const ::parquet::TypedStatistics<ParquetType>*>(statistics.get());
       const ArrowCType min = typed_statistics->min();
       const ArrowCType max = typed_statistics->max();
-      if constexpr (std::is_same_v<ArrowCType, bool>) {
+      if constexpr (std::same_as<ArrowCType, bool>) {
         array_statistics->min = static_cast<bool>(min);
         array_statistics->max = static_cast<bool>(max);
       } else if constexpr (std::is_floating_point_v<ArrowCType>) {
diff --git a/cpp/src/parquet/arrow/reader_writer_benchmark.cc b/cpp/src/parquet/arrow/reader_writer_benchmark.cc
index 2f288fd2eb0f..3fbcb342b811 100644
--- a/cpp/src/parquet/arrow/reader_writer_benchmark.cc
+++ b/cpp/src/parquet/arrow/reader_writer_benchmark.cc
@@ -111,7 +111,7 @@ std::shared_ptr<ColumnDescriptor> MakeSchema(Repetition::type repetition) {
 
 template <typename ParquetType>
 int64_t BytesForItems(int64_t num_items) {
-  static_assert(!std::is_same_v<ParquetType, FLBAType>,
+  static_assert(!std::same_as<ParquetType, FLBAType>,
                 "BytesForItems unsupported for FLBAType");
   return num_items * sizeof(typename ParquetType::c_type);
 }
diff --git a/cpp/src/parquet/arrow/test_util.h b/cpp/src/parquet/arrow/test_util.h
index 05f6fd24ac03..d635de64d136 100644
--- a/cpp/src/parquet/arrow/test_util.h
+++ b/cpp/src/parquet/arrow/test_util.h
@@ -157,8 +157,8 @@ static void random_decimals(int64_t n, uint32_t seed, int32_t precision, uint8_t
 }
 
 template <typename ArrowType, int32_t precision = ArrowType::precision>
-::arrow::enable_if_t<std::is_same_v<ArrowType, DecimalWithPrecisionAndScale<
-                                                   typename ArrowType::type, precision>>,
+::arrow::enable_if_t<std::same_as<ArrowType, DecimalWithPrecisionAndScale<
+                                                 typename ArrowType::type, precision>>,
                      Status>
 NonNullArray(size_t size, std::shared_ptr<Array>* out) {
   constexpr int32_t kDecimalPrecision = precision;
@@ -326,8 +326,8 @@ ::arrow::enable_if_fixed_size_binary<ArrowType, Status> NullableArray(
 }
 
 template <typename ArrowType, int32_t precision = ArrowType::precision>
-::arrow::enable_if_t<std::is_same_v<ArrowType, DecimalWithPrecisionAndScale<
-                                                   typename ArrowType::type, precision>>,
+::arrow::enable_if_t<std::same_as<ArrowType, DecimalWithPrecisionAndScale<
+                                                 typename ArrowType::type, precision>>,
                      Status>
 NullableArray(size_t size, size_t num_nulls, uint32_t seed,
               std::shared_ptr<::arrow::Array>* out) {
diff --git a/cpp/src/parquet/bloom_filter_benchmark.cc b/cpp/src/parquet/bloom_filter_benchmark.cc
index dea79eed09c7..0e9f394925de 100644
--- a/cpp/src/parquet/bloom_filter_benchmark.cc
+++ b/cpp/src/parquet/bloom_filter_benchmark.cc
@@ -64,11 +64,11 @@ static void BM_ComputeHash(::benchmark::State& state) {
     uint64_t total = 0;
     for (const auto& value : values) {
       uint64_t hash = 0;
-      if constexpr (std::is_same_v<DType, FLBAType>) {
+      if constexpr (std::same_as<DType, FLBAType>) {
         hash = filter->Hash(&value, kDataStringLength);
-      } else if constexpr (std::is_same_v<DType, Int96Type>) {
+      } else if constexpr (std::same_as<DType, Int96Type>) {
         hash = filter->Hash(&value);
-      } else if constexpr (std::is_same_v<DType, ByteArrayType>) {
+      } else if constexpr (std::same_as<DType, ByteArrayType>) {
         hash = filter->Hash(&value);
       } else {
         hash = filter->Hash(value);
@@ -90,7 +90,7 @@ static void BM_BatchComputeHash(::benchmark::State& state) {
   auto filter = CreateBloomFilter(kNumBloomFilterInserts);
   std::vector<uint64_t> hashes(kNumBloomFilterInserts);
   for (auto _ : state) {
-    if constexpr (std::is_same_v<DType, FLBAType>) {
+    if constexpr (std::same_as<DType, FLBAType>) {
       filter->Hashes(values.data(), kDataStringLength, static_cast<int>(values.size()),
                      hashes.data());
     } else {
diff --git a/cpp/src/parquet/bloom_filter_test.cc b/cpp/src/parquet/bloom_filter_test.cc
index 029d955ea04a..11a0862233d5 100644
--- a/cpp/src/parquet/bloom_filter_test.cc
+++ b/cpp/src/parquet/bloom_filter_test.cc
@@ -410,7 +410,7 @@ TYPED_TEST(TestBatchBloomFilter, Basic) {
   std::vector<uint64_t> hashes;
   for (const Type& value : test_data) {
     uint64_t hash = 0;
-    if constexpr (std::is_same_v<Type, FLBA>) {
+    if constexpr (std::same_as<Type, FLBA>) {
       hash = filter.Hash(&value, kGenerateDataFLBALength);
     } else {
       hash = filter.Hash(&value);
@@ -419,7 +419,7 @@ TYPED_TEST(TestBatchBloomFilter, Basic) {
   }
 
   std::vector<uint64_t> batch_hashes(test_data.size());
-  if constexpr (std::is_same_v<Type, FLBA>) {
+  if constexpr (std::same_as<Type, FLBA>) {
     batch_insert_filter.Hashes(test_data.data(), kGenerateDataFLBALength,
                                static_cast<int>(test_data.size()), batch_hashes.data());
   } else {
diff --git a/cpp/src/parquet/bloom_filter_writer.cc b/cpp/src/parquet/bloom_filter_writer.cc
index a52ca25163bf..9fe438bcf294 100644
--- a/cpp/src/parquet/bloom_filter_writer.cc
+++ b/cpp/src/parquet/bloom_filter_writer.cc
@@ -47,7 +47,7 @@ void TypedBloomFilterWriter<ParquetType>::Update(const T* values, int64_t num_va
   std::array<uint64_t, kHashBatchSize> hashes;
   for (int64_t i = 0; i < num_values; i += kHashBatchSize) {
     auto batch_size = static_cast<int>(std::min(kHashBatchSize, num_values - i));
-    if constexpr (std::is_same_v<ParquetType, FLBAType>) {
+    if constexpr (std::same_as<ParquetType, FLBAType>) {
       bloom_filter_->Hashes(values + i, descr_->type_length(), batch_size, hashes.data());
     } else {
       bloom_filter_->Hashes(values + i, batch_size, hashes.data());
@@ -72,7 +72,7 @@ void TypedBloomFilterWriter<ParquetType>::UpdateSpaced(const T* values,
       valid_bits, valid_bits_offset, num_values, [&](int64_t position, int64_t length) {
         for (int64_t i = 0; i < length; i += kHashBatchSize) {
           auto batch_size = static_cast<int>(std::min(kHashBatchSize, length - i));
-          if constexpr (std::is_same_v<ParquetType, FLBAType>) {
+          if constexpr (std::same_as<ParquetType, FLBAType>) {
             bloom_filter_->Hashes(values + i + position, descr_->type_length(),
                                   batch_size, hashes.data());
           } else {
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 653f28f64bde..e4258488b581 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -1825,7 +1825,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl,
 
   // Update the unencoded data bytes for ByteArray only per the specification.
   void UpdateUnencodedDataBytes() const {
-    if constexpr (std::is_same_v<T, ByteArray>) {
+    if constexpr (std::same_as<T, ByteArray>) {
       if (page_size_statistics_ != nullptr) {
         page_size_statistics_->IncrementUnencodedByteArrayDataBytes(
             current_encoder_->ReportUnencodedDataBytes());
@@ -2215,7 +2215,7 @@ struct SerializeFunctor<
   value_type TransferValue(const uint8_t* in) const {
     using DecimalValue = typename ::arrow::TypeTraits<ArrowType>::CType;
     DecimalValue decimal_value(in);
-    if constexpr (std::is_same_v<ArrowType, ::arrow::Decimal256Type>) {
+    if constexpr (std::same_as<ArrowType, ::arrow::Decimal256Type>) {
       // Decimal256 does not provide ToInteger, but we are sure it fits in the target
       // integer type.
       return static_cast<value_type>(decimal_value.low_bits());
@@ -2622,7 +2622,7 @@ struct SerializeFunctor<
 
   FixedLenByteArray FixDecimalEndianness(const uint8_t* in, int64_t offset) {
     auto out = reinterpret_cast<const uint8_t*>(scratch) + offset;
-    if constexpr (std::is_same_v<ArrowType, ::arrow::Decimal32Type>) {
+    if constexpr (std::same_as<ArrowType, ::arrow::Decimal32Type>) {
       const auto* u32_in = reinterpret_cast<const uint32_t*>(in);
       auto p = reinterpret_cast<uint32_t*>(scratch);
       *p++ = ::arrow::bit_util::ToBigEndian(u32_in[0]);
@@ -2630,12 +2630,12 @@ struct SerializeFunctor<
     } else {
       const auto* u64_in = reinterpret_cast<const uint64_t*>(in);
       auto p = reinterpret_cast<uint64_t*>(scratch);
-      if constexpr (std::is_same_v<ArrowType, ::arrow::Decimal64Type>) {
+      if constexpr (std::same_as<ArrowType, ::arrow::Decimal64Type>) {
         *p++ = ::arrow::bit_util::ToBigEndian(u64_in[0]);
-      } else if constexpr (std::is_same_v<ArrowType, ::arrow::Decimal128Type>) {
+      } else if constexpr (std::same_as<ArrowType, ::arrow::Decimal128Type>) {
         *p++ = ::arrow::bit_util::ToBigEndian(u64_in[1]);
         *p++ = ::arrow::bit_util::ToBigEndian(u64_in[0]);
-      } else if constexpr (std::is_same_v<ArrowType, ::arrow::Decimal256Type>) {
+      } else if constexpr (std::same_as<ArrowType, ::arrow::Decimal256Type>) {
         *p++ = ::arrow::bit_util::ToBigEndian(u64_in[3]);
         *p++ = ::arrow::bit_util::ToBigEndian(u64_in[2]);
         *p++ = ::arrow::bit_util::ToBigEndian(u64_in[1]);
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index 69ec07c1b78f..f8c844d53ea8 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -2466,7 +2466,7 @@ TYPED_TEST(TestBloomFilterWriter, Basic) {
 
   // Verify values are found by bloom filter
   for (auto& value : this->values_) {
-    if constexpr (std::is_same_v<TypeParam, FLBAType>) {
+    if constexpr (std::same_as<TypeParam, FLBAType>) {
       EXPECT_TRUE(this->bloom_filter_->FindHash(
           this->bloom_filter_->Hash(&value, this->descr_->type_length())));
     } else {
diff --git a/cpp/src/parquet/decoder.cc b/cpp/src/parquet/decoder.cc
index 47f2b46ebaac..b106e595b095 100644
--- a/cpp/src/parquet/decoder.cc
+++ b/cpp/src/parquet/decoder.cc
@@ -234,9 +234,9 @@ auto DispatchArrowBinaryHelper(typename EncodingTraits<DType>::Accumulator* acc,
                                int64_t length,
                                std::optional<int64_t> estimated_data_length,
                                Function&& func, Args&&... args) {
-  static_assert(std::is_same_v<DType, ByteArrayType> || std::is_same_v<DType, FLBAType>,
+  static_assert(std::same_as<DType, ByteArrayType> || std::same_as<DType, FLBAType>,
                 "unsupported DType");
-  if constexpr (std::is_same_v<DType, ByteArrayType>) {
+  if constexpr (std::same_as<DType, ByteArrayType>) {
     switch (acc->builder->type()->id()) {
       case ::arrow::Type::BINARY:
       case ::arrow::Type::STRING: {
@@ -309,14 +309,14 @@ class TypedDecoderImpl : public DecoderImpl, virtual public TypedDecoder<DType>
  protected:
   TypedDecoderImpl(const ColumnDescriptor* descr, Encoding::type encoding)
       : DecoderImpl(descr, encoding) {
-    if constexpr (std::is_same_v<DType, FLBAType>) {
+    if constexpr (std::same_as<DType, FLBAType>) {
       if (descr_ == nullptr) {
         throw ParquetException(
             "Must pass a ColumnDescriptor when creating a Decoder for "
             "FIXED_LEN_BYTE_ARRAY");
       }
       type_length_ = descr_->type_length();
-    } else if constexpr (std::is_same_v<DType, ByteArrayType>) {
+    } else if constexpr (std::same_as<DType, ByteArrayType>) {
       type_length_ = -1;
     } else {
       type_length_ = sizeof(T);
@@ -2178,7 +2178,7 @@ class DeltaByteArrayDecoderImpl : public TypedDecoderImpl<DType> {
       last_value_in_previous_page_ = last_value_;
     }
 
-    if constexpr (std::is_same_v<DType, FLBAType>) {
+    if constexpr (std::same_as<DType, FLBAType>) {
       // Checks all values
       for (int i = 0; i < max_values; i++) {
         if (buffer[i].len != static_cast<uint32_t>(this->type_length_)) {
diff --git a/cpp/src/parquet/encoder.cc b/cpp/src/parquet/encoder.cc
index 3e469df277b8..104608bf39bd 100644
--- a/cpp/src/parquet/encoder.cc
+++ b/cpp/src/parquet/encoder.cc
@@ -551,7 +551,7 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         });
 
     // Track unencoded bytes based on dictionary value type
-    if constexpr (std::is_same_v<DType, ByteArrayType>) {
+    if constexpr (std::same_as<DType, ByteArrayType>) {
       // For ByteArray, need to look up actual lengths from dictionary
       for (size_t idx =
                buffer_position - static_cast<size_t>(data.length() - data.null_count());
@@ -1041,7 +1041,7 @@ class DeltaBitPackEncoder : public EncoderImpl, virtual public TypedEncoder<DTyp
   // If these constants are changed, then the corresponding values in
   // TestDeltaBitPackEncoding (in `encoding_test.cc`) should be updated too.
   static constexpr uint32_t kValuesPerBlock =
-      std::is_same_v<int32_t, typename DType::c_type> ? 128 : 256;
+      std::same_as<int32_t, typename DType::c_type> ? 128 : 256;
   static constexpr uint32_t kMiniBlocksPerBlock = 4;
 
  public:
diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc
index bea1a5807a2a..8d9ed5c469c2 100644
--- a/cpp/src/parquet/encoding_benchmark.cc
+++ b/cpp/src/parquet/encoding_benchmark.cc
@@ -343,7 +343,7 @@ static void BM_DecodingSpaced(benchmark::State& state, Encoding::type encoding)
 
   auto rand = ::arrow::random::RandomArrayGenerator(1923);
   std::shared_ptr<::arrow::Array> array;
-  if constexpr (std::is_same_v<ParquetType, BooleanType>) {
+  if constexpr (std::same_as<ParquetType, BooleanType>) {
     array = rand.Boolean(num_values, /*true_probability*/ 0.5, null_percent);
   } else {
     array = rand.Numeric<ArrowType>(num_values, -100, 100, null_percent);
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 74b422cb606f..c0360a6e4210 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -274,7 +274,7 @@ class TestEncodingBase : public ::testing::Test {
 
   void InitUnencodedByteArrayDataBytes() {
     // Calculate expected unencoded bytes based on type
-    if constexpr (std::is_same_v<Type, ByteArrayType>) {
+    if constexpr (std::same_as<Type, ByteArrayType>) {
       unencoded_byte_array_data_bytes_ = 0;
       for (int i = 0; i < num_values_; i++) {
         unencoded_byte_array_data_bytes_ += draws_[i].len;
@@ -322,7 +322,7 @@ class TestPlainEncoding : public TestEncodingBase<Type> {
     auto decoder = MakeTypedDecoder<Type>(Encoding::PLAIN, descr_.get());
     encoder->Put(draws_, num_values_);
     encode_buffer_ = encoder->FlushValues();
-    if constexpr (std::is_same_v<Type, ByteArrayType>) {
+    if constexpr (std::same_as<Type, ByteArrayType>) {
       ASSERT_EQ(encoder->ReportUnencodedDataBytes(),
                 this->unencoded_byte_array_data_bytes_);
     }
@@ -411,7 +411,7 @@ class TestDictionaryEncoding : public TestEncodingBase<Type> {
         AllocateBuffer(default_memory_pool(), dict_traits->dict_encoded_size());
     dict_traits->WriteDict(dict_buffer_->mutable_data());
     std::shared_ptr<Buffer> indices = encoder->FlushValues();
-    if constexpr (std::is_same_v<Type, ByteArrayType>) {
+    if constexpr (std::same_as<Type, ByteArrayType>) {
       ASSERT_EQ(encoder->ReportUnencodedDataBytes(),
                 this->unencoded_byte_array_data_bytes_);
     }
@@ -955,11 +955,11 @@ class EncodingAdHocTyped : public ::testing::Test {
   }
 
   void ByteStreamSplit(int seed) {
-    if constexpr (!std::is_same_v<ParquetType, FloatType> &&
-                  !std::is_same_v<ParquetType, DoubleType> &&
-                  !std::is_same_v<ParquetType, Int32Type> &&
-                  !std::is_same_v<ParquetType, Int64Type> &&
-                  !std::is_same_v<ParquetType, FLBAType>) {
+    if constexpr (!std::same_as<ParquetType, FloatType> &&
+                  !std::same_as<ParquetType, DoubleType> &&
+                  !std::same_as<ParquetType, Int32Type> &&
+                  !std::same_as<ParquetType, Int64Type> &&
+                  !std::same_as<ParquetType, FLBAType>) {
       return;
     }
     auto values = GetValues(seed);
@@ -1509,7 +1509,7 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
                    std::span<const U> expected_decoded_data,
                    const ColumnDescriptor* descr = nullptr) {
     static_assert(sizeof(U) == sizeof(c_type));
-    static_assert(std::is_same_v<U, FLBA> == std::is_same_v<c_type, FLBA>);
+    static_assert(std::same_as<U, FLBA> == std::same_as<c_type, FLBA>);
 
     std::unique_ptr<TypedDecoder<Type>> decoder =
         MakeTypedDecoder<Type>(Encoding::BYTE_STREAM_SPLIT, descr);
@@ -1521,7 +1521,7 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
         decoder->Decode(reinterpret_cast<c_type*>(decoded_data.data()), num_elements);
     ASSERT_EQ(num_elements, num_decoded_elements);
     // Compare to expected values
-    if constexpr (std::is_same_v<c_type, FLBA>) {
+    if constexpr (std::same_as<c_type, FLBA>) {
       auto type_length = descr->type_length();
       for (int i = 0; i < num_elements; ++i) {
         ASSERT_TRUE(std::ranges::equal(
@@ -1541,7 +1541,7 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
                    std::span<const uint8_t> expected_encoded_data,
                    const ColumnDescriptor* descr = nullptr) {
     static_assert(sizeof(U) == sizeof(c_type));
-    static_assert(std::is_same_v<U, FLBA> == std::is_same_v<c_type, FLBA>);
+    static_assert(std::same_as<U, FLBA> == std::same_as<c_type, FLBA>);
 
     std::unique_ptr<TypedEncoder<Type>> encoder = MakeTypedEncoder<Type>(
         Encoding::BYTE_STREAM_SPLIT, /*use_dictionary=*/false, descr);
@@ -1556,8 +1556,8 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
   }
 
   int physical_byte_width() const {
-    return std::is_same_v<c_type, FLBA> ? descr_->type_length()
-                                        : static_cast<int>(sizeof(c_type));
+    return std::same_as<c_type, FLBA> ? descr_->type_length()
+                                      : static_cast<int>(sizeof(c_type));
   }
 };
 
@@ -1580,7 +1580,7 @@ std::shared_ptr<ColumnDescriptor> FLBAColumnDescriptor(int type_length) {
 
 template <typename Type>
 void TestByteStreamSplitEncoding<Type>::CheckDecode() {
-  if constexpr (std::is_same_v<c_type, FLBA>) {
+  if constexpr (std::same_as<c_type, FLBA>) {
     // FIXED_LEN_BYTE_ARRAY
     // - type_length = 3
     {
@@ -1623,7 +1623,7 @@ void TestByteStreamSplitEncoding<Type>::CheckDecode() {
 
 template <typename Type>
 void TestByteStreamSplitEncoding<Type>::CheckEncode() {
-  if constexpr (std::is_same_v<c_type, FLBA>) {
+  if constexpr (std::same_as<c_type, FLBA>) {
     // FIXED_LEN_BYTE_ARRAY
     // - type_length = 3
     {
@@ -1909,7 +1909,7 @@ TYPED_TEST(TestDeltaBitPackEncoding, NonZeroPaddedMiniblockBitWidth) {
 
   // Same values as in DeltaBitPackEncoder
   constexpr int kValuesPerBlock =
-      std::is_same_v<int32_t, typename TypeParam::c_type> ? 128 : 256;
+      std::same_as<int32_t, typename TypeParam::c_type> ? 128 : 256;
   constexpr int kMiniBlocksPerBlock = 4;
   constexpr int kValuesPerMiniBlock = kValuesPerBlock / kMiniBlocksPerBlock;
 
@@ -2116,7 +2116,7 @@ class TestDeltaLengthByteArrayEncoding : public TestEncodingBase<Type> {
 
     encoder->Put(draws_, num_values_);
     encode_buffer_ = encoder->FlushValues();
-    if constexpr (std::is_same_v<Type, ByteArrayType>) {
+    if constexpr (std::same_as<Type, ByteArrayType>) {
       ASSERT_EQ(encoder->ReportUnencodedDataBytes(),
                 this->unencoded_byte_array_data_bytes_);
     }
@@ -2444,13 +2444,13 @@ class TestDeltaByteArrayEncodingDirectPut : public TestEncodingBase<Type> {
  public:
   void MakeEncoderDecoder(const ::arrow::DataType& type) {
     schema::NodePtr node;
-    if constexpr (std::is_same_v<Type, FLBAType>) {
+    if constexpr (std::same_as<Type, FLBAType>) {
       node = schema::PrimitiveNode::Make(
           "name", Repetition::OPTIONAL, ::parquet::Type::FIXED_LEN_BYTE_ARRAY,
           ConvertedType::NONE,
           checked_cast<const ::arrow::FixedSizeBinaryType&>(type).byte_width());
     } else {
-      static_assert(std::is_same_v<Type, ByteArrayType>);
+      static_assert(std::same_as<Type, ByteArrayType>);
       node = schema::PrimitiveNode::Make("name", Repetition::OPTIONAL,
                                          ::parquet::Type::BYTE_ARRAY);
     }
diff --git a/cpp/src/parquet/encryption/test_encryption_util.cc b/cpp/src/parquet/encryption/test_encryption_util.cc
index 86951f8264e4..6c394abe996e 100644
--- a/cpp/src/parquet/encryption/test_encryption_util.cc
+++ b/cpp/src/parquet/encryption/test_encryption_util.cc
@@ -336,7 +336,7 @@ void ReadAndVerifyColumn(RowGroupReader* rg_reader, RowGroupMetadata* rg_md,
   if constexpr (std::is_floating_point_v<typename DType::c_type>) {
     ASSERT_EQ(read_col_data.rows(), expected_column_data.rows());
     for (int i = 0; i < read_col_data.rows(); ++i) {
-      if constexpr (std::is_same_v<float, typename DType::c_type>) {
+      if constexpr (std::same_as<float, typename DType::c_type>) {
         EXPECT_FLOAT_EQ(expected_column_data.values[i], read_col_data.values[i]);
       } else {
         EXPECT_DOUBLE_EQ(expected_column_data.values[i], read_col_data.values[i]);
@@ -547,7 +547,7 @@ void AssertColumnIndex(const std::shared_ptr<ColumnIndex>& column_index,
       std::dynamic_pointer_cast<TypedColumnIndex<DType>>(column_index);
   ASSERT_NE(typed_column_index, nullptr);
   ASSERT_EQ(typed_column_index->null_counts(), expected_null_counts);
-  if constexpr (std::is_same_v<FLBAType, DType>) {
+  if constexpr (std::same_as<FLBAType, DType>) {
     ASSERT_EQ(typed_column_index->min_values().size(), expected_min_values.size());
     ASSERT_EQ(typed_column_index->max_values().size(), expected_max_values.size());
     for (size_t i = 0; i < expected_min_values.size(); ++i) {
diff --git a/cpp/src/parquet/page_index.cc b/cpp/src/parquet/page_index.cc
index 69ab0b5f6168..61220cd64f6d 100644
--- a/cpp/src/parquet/page_index.cc
+++ b/cpp/src/parquet/page_index.cc
@@ -851,7 +851,7 @@ class PageIndexBuilderImpl final : public PageIndexBuilder {
     IndexLocations locations;
 
     const auto num_columns = static_cast<size_t>(schema_->num_columns());
-    constexpr int8_t module_type = std::is_same_v<Builder, ColumnIndexBuilder>
+    constexpr int8_t module_type = std::same_as<Builder, ColumnIndexBuilder>
                                        ? encryption::kColumnIndex
                                        : encryption::kOffsetIndex;
 
diff --git a/cpp/src/parquet/page_index_test.cc b/cpp/src/parquet/page_index_test.cc
index bfd5c90bdefc..68161c627b63 100644
--- a/cpp/src/parquet/page_index_test.cc
+++ b/cpp/src/parquet/page_index_test.cc
@@ -127,13 +127,13 @@ void TestReadTypedColumnIndex(const std::string& file_name, int column_id,
     }
     // min/max values are only meaningful for non-null pages.
     if (!null_pages.at(i)) {
-      if constexpr (std::is_same_v<T, double>) {
+      if constexpr (std::same_as<T, double>) {
         ASSERT_DOUBLE_EQ(min_values.at(i), typed_column_index->min_values().at(page_id));
         ASSERT_DOUBLE_EQ(max_values.at(i), typed_column_index->max_values().at(page_id));
-      } else if constexpr (std::is_same_v<T, float>) {
+      } else if constexpr (std::same_as<T, float>) {
         ASSERT_FLOAT_EQ(min_values.at(i), typed_column_index->min_values().at(page_id));
         ASSERT_FLOAT_EQ(max_values.at(i), typed_column_index->max_values().at(page_id));
-      } else if constexpr (std::is_same_v<T, FLBA>) {
+      } else if constexpr (std::same_as<T, FLBA>) {
         auto len = descr->type_length();
         ASSERT_EQ(0, ::memcmp(min_values.at(i).ptr,
                               typed_column_index->min_values().at(page_id).ptr, len));
diff --git a/cpp/src/parquet/reader_test.cc b/cpp/src/parquet/reader_test.cc
index d223ce0db645..143d1c87c3cb 100644
--- a/cpp/src/parquet/reader_test.cc
+++ b/cpp/src/parquet/reader_test.cc
@@ -158,7 +158,7 @@ template <typename ValueType>
 void AssertColumnValuesEqual(const ColumnDescriptor* descr,
                              const std::vector<ValueType>& left_values,
                              const std::vector<ValueType>& right_values) {
-  if constexpr (std::is_same_v<ValueType, FLBA>) {
+  if constexpr (std::same_as<ValueType, FLBA>) {
     // operator== for FLBA in test_util.h is unusable (it hard-codes length to 12)
     const auto length = descr->type_length();
     for (const auto& [left, right] : Zip(left_values, right_values)) {
diff --git a/python/pyarrow/src/arrow/python/common.h b/python/pyarrow/src/arrow/python/common.h
index a81782330b5e..d650d77363ad 100644
--- a/python/pyarrow/src/arrow/python/common.h
+++ b/python/pyarrow/src/arrow/python/common.h
@@ -88,7 +88,7 @@ T GetResultValue(Result<T> result) {
 /// \return A new Python reference, or NULL if an exception occurred
 template <typename T, typename PyWrapper = PyObject* (*)(T)>
 PyObject* WrapResult(Result<T> result, PyWrapper&& py_wrapper) {
-  static_assert(std::is_same_v<PyObject*, decltype(py_wrapper(std::declval<T>()))>,
+  static_assert(std::same_as<PyObject*, decltype(py_wrapper(std::declval<T>()))>,
                 "PyWrapper argument to WrapResult should return a PyObject* "
                 "when called with a T*");
   Status st = result.status();
diff --git a/r/src/altrep.cpp b/r/src/altrep.cpp
index 385d2ec9ff37..7ba29212d6da 100644
--- a/r/src/altrep.cpp
+++ b/r/src/altrep.cpp
@@ -194,12 +194,12 @@ struct AltrepVectorPrimitive : public AltrepVectorBase<AltrepVectorPrimitive<sex
       SEXP copy = PROTECT(Rf_allocVector(sexp_type, size));
 
       // copy the data from the array, through Get_region
-      if constexpr (std::is_same_v<c_type, double>) {
+      if constexpr (std::same_as<c_type, double>) {
         Get_region(alt, 0, size, REAL(copy));
-      } else if constexpr (std::is_same_v<c_type, int>) {
+      } else if constexpr (std::same_as<c_type, int>) {
         Get_region(alt, 0, size, INTEGER(copy));
       } else {
-        static_assert(std::is_same_v<c_type, double> || std::is_same_v<c_type, int>,
+        static_assert(std::same_as<c_type, double> || std::same_as<c_type, int>,
                       "ALTREP not implemented for this c_type");
       }
 
@@ -250,12 +250,12 @@ struct AltrepVectorPrimitive : public AltrepVectorBase<AltrepVectorPrimitive<sex
     }
 
     // Otherwise we have to materialize and hand the pointer to data2
-    if constexpr (std::is_same_v<c_type, double>) {
+    if constexpr (std::same_as<c_type, double>) {
       return REAL(Materialize(alt));
-    } else if constexpr (std::is_same_v<c_type, int>) {
+    } else if constexpr (std::same_as<c_type, int>) {
       return INTEGER(Materialize(alt));
     } else {
-      static_assert(std::is_same_v<c_type, double> || std::is_same_v<c_type, int>,
+      static_assert(std::same_as<c_type, double> || std::same_as<c_type, int>,
                     "ALTREP not implemented for this c_type");
     }
   }
@@ -263,12 +263,12 @@ struct AltrepVectorPrimitive : public AltrepVectorBase<AltrepVectorPrimitive<sex
   // The value at position i
   static c_type Elt(SEXP alt, R_xlen_t i) {
     if (IsMaterialized(alt)) {
-      if constexpr (std::is_same_v<c_type, double>) {
+      if constexpr (std::same_as<c_type, double>) {
         return REAL(Representation(alt))[i];
-      } else if constexpr (std::is_same_v<c_type, int>) {
+      } else if constexpr (std::same_as<c_type, int>) {
         return INTEGER(Representation(alt))[i];
       } else {
-        static_assert(std::is_same_v<c_type, double> || std::is_same_v<c_type, int>,
+        static_assert(std::same_as<c_type, double> || std::same_as<c_type, int>,
                       "ALTREP not implemented for this c_type");
       }
     }
diff --git a/r/src/array_to_vector.cpp b/r/src/array_to_vector.cpp
index f5f16433f230..d46af5d9cb43 100644
--- a/r/src/array_to_vector.cpp
+++ b/r/src/array_to_vector.cpp
@@ -259,7 +259,7 @@ class Converter_Double : public Converter {
     }
     auto p_data = REAL(data) + start;
     auto ingest_one = [&](R_xlen_t i) {
-      if constexpr (std::is_same_v<Type, HalfFloatType>) {
+      if constexpr (std::same_as<Type, HalfFloatType>) {
         p_data[i] = arrow::util::Float16::FromBits(p_values[i]).ToDouble();
       } else {
         p_data[i] = static_cast<value_type>(p_values[i]);