diff --git a/cpp/src/arrow/array/array_base.cc b/cpp/src/arrow/array/array_base.cc
index 2a0a7b7b6338c..682bc781cf2f5 100644
--- a/cpp/src/arrow/array/array_base.cc
+++ b/cpp/src/arrow/array/array_base.cc
@@ -69,7 +69,7 @@ struct ScalarFromArraySlotImpl {
     return Finish(a.Value(index_));
   }
 
-  #define DECL_DECIMAL_VISIT(width)                    \
+#define DECL_DECIMAL_VISIT(width)                      \
   Status Visit(const Decimal##width##Array& a) {       \
     return Finish(Decimal##width(a.GetValue(index_))); \
   }
@@ -80,7 +80,7 @@ struct ScalarFromArraySlotImpl {
   DECL_DECIMAL_VISIT(128)
   DECL_DECIMAL_VISIT(256)
 
-  #undef DECL_DECIMAL_VISIT
+#undef DECL_DECIMAL_VISIT
 
   template <typename T>
   Status Visit(const BaseBinaryArray<T>& a) {
diff --git a/cpp/src/arrow/array/array_decimal.cc b/cpp/src/arrow/array/array_decimal.cc
index 5e7c6c85beab8..3d0187bd2ebec 100644
--- a/cpp/src/arrow/array/array_decimal.cc
+++ b/cpp/src/arrow/array/array_decimal.cc
@@ -32,14 +32,13 @@ namespace arrow {
 
 using internal::checked_cast;
 
-
-template<uint32_t width>
+template <uint32_t width>
 BaseDecimalArray<width>::BaseDecimalArray(const std::shared_ptr<ArrayData>& data)
     : FixedSizeBinaryArray(data) {
   ARROW_CHECK_EQ(data->type->id(), DecimalTypeTraits<width>::Id);
 }
 
-template<uint32_t width>
+template <uint32_t width>
 std::string BaseDecimalArray<width>::FormatValue(int64_t i) const {
   const auto& type_ = checked_cast<const TypeClass&>(*type());
   const ValueType value(GetValue(i));
diff --git a/cpp/src/arrow/array/array_decimal.h b/cpp/src/arrow/array/array_decimal.h
index b7c8515304863..7a35da7fa7aa2 100644
--- a/cpp/src/arrow/array/array_decimal.h
+++ b/cpp/src/arrow/array/array_decimal.h
@@ -22,15 +22,15 @@
 #include <string>
 
 #include "arrow/array/array_binary.h"
-#include "arrow/util/decimal_type_traits.h"
 #include "arrow/array/data.h"
 #include "arrow/type.h"
+#include "arrow/util/decimal_type_traits.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
 
 /// Template Array class for decimal data
-template<uint32_t width>
+template <uint32_t width>
 class ARROW_EXPORT BaseDecimalArray : public FixedSizeBinaryArray {
  public:
   using TypeClass = typename DecimalTypeTraits<width>::TypeClass;
@@ -47,5 +47,4 @@ class ARROW_EXPORT BaseDecimalArray : public FixedSizeBinaryArray {
 // Backward compatibility
 using DecimalArray = Decimal128Array;
 
-
 }  // namespace arrow
diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 38c19e4c50109..0f9b8fda85ef0 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -2408,17 +2408,19 @@ class DecimalTest : public ::testing::TestWithParam<int> {
   }
 
   void InitNoNullsTest(int32_t precision) {
-    std::vector<DecimalValue> draw = {DecimalValue(1), DecimalValue(-2), DecimalValue(2389),
-                                      DecimalValue(4), DecimalValue(-12348)};
+    std::vector<DecimalValue> draw = {DecimalValue(1), DecimalValue(-2),
+                                      DecimalValue(2389), DecimalValue(4),
+                                      DecimalValue(-12348)};
     std::vector<uint8_t> valid_bytes = {true, true, true, true, true};
     this->TestCreate(precision, draw, valid_bytes, 0);
     this->TestCreate(precision, draw, valid_bytes, 2);
   }
 
-  void InitWithNullsTest(int32_t precision, std::string big_value, std::string big_negate_value) {
+  void InitWithNullsTest(int32_t precision, std::string big_value,
+                         std::string big_negate_value) {
     std::vector<DecimalValue> draw = {DecimalValue(1), DecimalValue(2),  DecimalValue(-1),
-                                     DecimalValue(4), DecimalValue(-1), DecimalValue(1),
-                                     DecimalValue(2)};
+                                      DecimalValue(4), DecimalValue(-1), DecimalValue(1),
+                                      DecimalValue(2)};
     DecimalValue big;
     ASSERT_OK_AND_ASSIGN(big, DecimalValue::FromString(big_value));
     draw.push_back(big);
@@ -2542,10 +2544,11 @@ TEST_P(Decimal256Test, NoNulls) {
 
 TEST_P(Decimal256Test, WithNulls) {
   int32_t precision = GetParam();
-  this->InitWithNullsTest(precision, "578960446186580977117854925043439539266."
-                                     "34992332820282019728792003956564819967",
-                                     "-578960446186580977117854925043439539266."
-                                     "34992332820282019728792003956564819968");
+  this->InitWithNullsTest(precision,
+                          "578960446186580977117854925043439539266."
+                          "34992332820282019728792003956564819967",
+                          "-578960446186580977117854925043439539266."
+                          "34992332820282019728792003956564819968");
 }
 
 INSTANTIATE_TEST_SUITE_P(Decimal256Test, Decimal256Test,
diff --git a/cpp/src/arrow/array/builder_decimal.cc b/cpp/src/arrow/array/builder_decimal.cc
index ad49cc2466a92..19e5ddd8b5a8d 100644
--- a/cpp/src/arrow/array/builder_decimal.cc
+++ b/cpp/src/arrow/array/builder_decimal.cc
@@ -35,32 +35,32 @@ class MemoryPool;
 // ----------------------------------------------------------------------
 // BaseDecimalBuilder
 
-template<uint32_t width>
+template <uint32_t width>
 BaseDecimalBuilder<width>::BaseDecimalBuilder(const std::shared_ptr<DataType>& type,
-                                     MemoryPool* pool)
+                                              MemoryPool* pool)
     : FixedSizeBinaryBuilder(type, pool),
       decimal_type_(internal::checked_pointer_cast<TypeClass>(type)) {}
 
-template<uint32_t width>
+template <uint32_t width>
 Status BaseDecimalBuilder<width>::Append(ValueType value) {
   RETURN_NOT_OK(FixedSizeBinaryBuilder::Reserve(1));
   UnsafeAppend(value);
   return Status::OK();
 }
 
-template<uint32_t width>
+template <uint32_t width>
 void BaseDecimalBuilder<width>::UnsafeAppend(ValueType value) {
   value.ToBytes(GetMutableValue(length()));
   byte_builder_.UnsafeAdvance((width >> 3));
   UnsafeAppendToBitmap(true);
 }
 
-template<uint32_t width>
+template <uint32_t width>
 void BaseDecimalBuilder<width>::UnsafeAppend(util::string_view value) {
   FixedSizeBinaryBuilder::UnsafeAppend(value);
 }
 
-template<uint32_t width>
+template <uint32_t width>
 Status BaseDecimalBuilder<width>::FinishInternal(std::shared_ptr<ArrayData>* out) {
   std::shared_ptr<Buffer> data;
   RETURN_NOT_OK(byte_builder_.Finish(&data));
diff --git a/cpp/src/arrow/array/builder_decimal.h b/cpp/src/arrow/array/builder_decimal.h
index 4c27fc0cf1b64..ebad9127d86d6 100644
--- a/cpp/src/arrow/array/builder_decimal.h
+++ b/cpp/src/arrow/array/builder_decimal.h
@@ -23,16 +23,16 @@
 #include "arrow/array/builder_base.h"
 #include "arrow/array/builder_binary.h"
 #include "arrow/array/data.h"
-#include "arrow/util/decimal_type_traits.h"
 #include "arrow/status.h"
 #include "arrow/type.h"
+#include "arrow/util/decimal_type_traits.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
 
-template<uint32_t width>
+template <uint32_t width>
 class ARROW_EXPORT BaseDecimalBuilder : public FixedSizeBinaryBuilder {
-public:
+ public:
   using TypeClass = typename DecimalTypeTraits<width>::TypeClass;
   using ArrayType = typename DecimalTypeTraits<width>::ArrayType;
   using ValueType = typename DecimalTypeTraits<width>::ValueType;
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 691d7e4ad939f..47f5309c3c8ea 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -62,7 +62,7 @@ struct ValidateArrayImpl {
     return Status::OK();
   }
 
-  template<uint32_t width>
+  template <uint32_t width>
   Status Visit(const BaseDecimalArray<width>& array) {
     if (array.length() > 0 && array.values() == nullptr) {
       return Status::Invalid("values is null");
diff --git a/cpp/src/arrow/ipc/json_simple.cc b/cpp/src/arrow/ipc/json_simple.cc
index 5cb903c8ccfe8..1a7a142f9f873 100644
--- a/cpp/src/arrow/ipc/json_simple.cc
+++ b/cpp/src/arrow/ipc/json_simple.cc
@@ -332,9 +332,11 @@ class DecimalConverter final
   const DecimalSubtype* decimal_type_;
 };
 
-#define DECL_DECIMAL_CONVERTER(width)                                                                  \
-template <typename BuilderType = typename TypeTraits<Decimal##width##Type>::BuilderType>               \
-using Decimal##width##Converter = DecimalConverter<Decimal##width##Type, Decimal##width, BuilderType>;
+#define DECL_DECIMAL_CONVERTER(width)                                   \
+  template <typename BuilderType =                                      \
+                typename TypeTraits<Decimal##width##Type>::BuilderType> \
+  using Decimal##width##Converter =                                     \
+      DecimalConverter<Decimal##width##Type, Decimal##width, BuilderType>;
 
 DECL_DECIMAL_CONVERTER(16)
 DECL_DECIMAL_CONVERTER(32)
diff --git a/cpp/src/arrow/ipc/json_simple_test.cc b/cpp/src/arrow/ipc/json_simple_test.cc
index 3967f5f54c0e4..b44a17ce09dc1 100644
--- a/cpp/src/arrow/ipc/json_simple_test.cc
+++ b/cpp/src/arrow/ipc/json_simple_test.cc
@@ -501,7 +501,9 @@ TEST(TestFixedSizeBinary, Dictionary) {
 
 template <typename T>
 class TestDecimal : public testing::Test {};
-using DecimalTypes = ::testing::Types<DecimalTypeTraits<16>, DecimalTypeTraits<32>, DecimalTypeTraits<64>, DecimalTypeTraits<128>, DecimalTypeTraits<256>>; 
+using DecimalTypes =
+    ::testing::Types<DecimalTypeTraits<16>, DecimalTypeTraits<32>, DecimalTypeTraits<64>,
+                     DecimalTypeTraits<128>, DecimalTypeTraits<256>>;
 
 TYPED_TEST_SUITE(TestDecimal, DecimalTypes);
 
@@ -559,8 +561,7 @@ TYPED_TEST(TestDecimal, Errors) {
 TYPED_TEST(TestDecimal, Dictionary) {
   using TypeClass = typename TypeParam::TypeClass;
   auto type = std::make_shared<TypeClass>(5, 2);
-  AssertJSONDictArray(int32(), type,
-                      R"(["123.45", "-78.90", "-78.90", null, "123.45"])",
+  AssertJSONDictArray(int32(), type, R"(["123.45", "-78.90", "-78.90", null, "123.45"])",
                       /*indices=*/"[0, 1, 1, null, 0]",
                       /*values=*/R"(["123.45", "-78.90"])");
 }
diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc
index ab69a7e782752..078bd5abccd61 100644
--- a/cpp/src/arrow/pretty_print_test.cc
+++ b/cpp/src/arrow/pretty_print_test.cc
@@ -502,7 +502,8 @@ TEST_F(TestPrettyPrint, DecimalTypes) {
   int32_t p = 5;
   int32_t s = 4;
 
-  for (auto type : {decimal16(p, s), decimal32(p, s), decimal64(p, s), decimal128(p, s), decimal256(p, s)}) {
+  for (auto type : {decimal16(p, s), decimal32(p, s), decimal64(p, s), decimal128(p, s),
+                    decimal256(p, s)}) {
     auto array = ArrayFromJSON(type, "[\"1.4567\", \"3.2765\", null]");
 
     static const char* ex = "[\n  1.4567,\n  3.2765,\n  null\n]";
diff --git a/cpp/src/arrow/python/arrow_to_pandas.cc b/cpp/src/arrow/python/arrow_to_pandas.cc
index 665df75df6a08..27903edc00c77 100644
--- a/cpp/src/arrow/python/arrow_to_pandas.cc
+++ b/cpp/src/arrow/python/arrow_to_pandas.cc
@@ -1024,7 +1024,9 @@ struct ObjectWriterVisitor {
   }
 
   template <typename Type>
-  enable_if_t<(is_base_binary_type<Type>::value || is_fixed_size_binary_type<Type>::value) && !is_decimal_type<Type>::value,
+  enable_if_t<(is_base_binary_type<Type>::value ||
+               is_fixed_size_binary_type<Type>::value) &&
+                  !is_decimal_type<Type>::value,
               Status>
   Visit(const Type& type) {
     auto WrapValue = [](const util::string_view& view, PyObject** out) {
@@ -1106,7 +1108,8 @@ struct ObjectWriterVisitor {
     PyObject* decimal_constructor = Decimal.obj();
 
     for (int c = 0; c < data.num_chunks(); c++) {
-      const auto& arr = checked_cast<const arrow::BaseDecimalArray<width>&>(*data.chunk(c));
+      const auto& arr =
+          checked_cast<const arrow::BaseDecimalArray<width>&>(*data.chunk(c));
 
       for (int64_t i = 0; i < arr.length(); ++i) {
         if (arr.IsNull(i)) {
diff --git a/cpp/src/arrow/python/decimal.cc b/cpp/src/arrow/python/decimal.cc
index 25d8af59ee15e..8f36812da26c0 100644
--- a/cpp/src/arrow/python/decimal.cc
+++ b/cpp/src/arrow/python/decimal.cc
@@ -171,8 +171,7 @@ Status DecimalFromPythonDecimal(PyObject* python_decimal, const DecimalType& arr
   return InternalDecimalFromPythonDecimal(python_decimal, arrow_type, out);
 }
 
-Status DecimalFromPyObject(PyObject* obj, const DecimalType& arrow_type,
-                           Decimal16* out) {
+Status DecimalFromPyObject(PyObject* obj, const DecimalType& arrow_type, Decimal16* out) {
   return InternalDecimalFromPyObject(obj, arrow_type, out);
 }
 
@@ -181,8 +180,7 @@ Status DecimalFromPythonDecimal(PyObject* python_decimal, const DecimalType& arr
   return InternalDecimalFromPythonDecimal(python_decimal, arrow_type, out);
 }
 
-Status DecimalFromPyObject(PyObject* obj, const DecimalType& arrow_type,
-                           Decimal32* out) {
+Status DecimalFromPyObject(PyObject* obj, const DecimalType& arrow_type, Decimal32* out) {
   return InternalDecimalFromPyObject(obj, arrow_type, out);
 }
 
@@ -191,8 +189,7 @@ Status DecimalFromPythonDecimal(PyObject* python_decimal, const DecimalType& arr
   return InternalDecimalFromPythonDecimal(python_decimal, arrow_type, out);
 }
 
-Status DecimalFromPyObject(PyObject* obj, const DecimalType& arrow_type,
-                           Decimal64* out) {
+Status DecimalFromPyObject(PyObject* obj, const DecimalType& arrow_type, Decimal64* out) {
   return InternalDecimalFromPyObject(obj, arrow_type, out);
 }
 
diff --git a/cpp/src/arrow/python/decimal.h b/cpp/src/arrow/python/decimal.h
index 08ce344f86469..5a7698a3929b5 100644
--- a/cpp/src/arrow/python/decimal.h
+++ b/cpp/src/arrow/python/decimal.h
@@ -24,7 +24,7 @@
 
 namespace arrow {
 
-template<uint32_t width>
+template <uint32_t width>
 class DecimalAnyWidth;
 
 using Decimal16 = DecimalAnyWidth<16>;
diff --git a/cpp/src/arrow/python/python_test.cc b/cpp/src/arrow/python/python_test.cc
index b4a45831f6b9b..799b7c1d4098a 100644
--- a/cpp/src/arrow/python/python_test.cc
+++ b/cpp/src/arrow/python/python_test.cc
@@ -360,11 +360,11 @@ TEST_F(DecimalTest, FromPythonDecimalRescaleNotTruncateable) {
   // We fail when truncating values that would lose data if cast to a decimal type with
   // lower scale
   DecimalTestFromPythonDecimalRescale<Decimal16>(::arrow::decimal16(5, 2),
-                                                  this->CreatePythonDecimal("1.001"), {});
+                                                 this->CreatePythonDecimal("1.001"), {});
   DecimalTestFromPythonDecimalRescale<Decimal32>(::arrow::decimal32(10, 2),
-                                                  this->CreatePythonDecimal("1.001"), {});
+                                                 this->CreatePythonDecimal("1.001"), {});
   DecimalTestFromPythonDecimalRescale<Decimal64>(::arrow::decimal64(10, 2),
-                                                  this->CreatePythonDecimal("1.001"), {});
+                                                 this->CreatePythonDecimal("1.001"), {});
   DecimalTestFromPythonDecimalRescale<Decimal128>(::arrow::decimal128(10, 2),
                                                   this->CreatePythonDecimal("1.001"), {});
   DecimalTestFromPythonDecimalRescale<Decimal256>(::arrow::decimal256(10, 2),
@@ -374,12 +374,12 @@ TEST_F(DecimalTest, FromPythonDecimalRescaleNotTruncateable) {
 TEST_F(DecimalTest, FromPythonDecimalRescaleTruncateable) {
   // We allow truncation of values that do not lose precision when dividing by 10 * the
   // difference between the scales, e.g., 1.000 -> 1.00
-  DecimalTestFromPythonDecimalRescale<Decimal16>(
-      ::arrow::decimal16(5, 2), this->CreatePythonDecimal("1.000"), 100);
-  DecimalTestFromPythonDecimalRescale<Decimal32>(
-      ::arrow::decimal32(10, 2), this->CreatePythonDecimal("1.000"), 100);
-  DecimalTestFromPythonDecimalRescale<Decimal64>(
-      ::arrow::decimal64(10, 2), this->CreatePythonDecimal("1.000"), 100);
+  DecimalTestFromPythonDecimalRescale<Decimal16>(::arrow::decimal16(5, 2),
+                                                 this->CreatePythonDecimal("1.000"), 100);
+  DecimalTestFromPythonDecimalRescale<Decimal32>(::arrow::decimal32(10, 2),
+                                                 this->CreatePythonDecimal("1.000"), 100);
+  DecimalTestFromPythonDecimalRescale<Decimal64>(::arrow::decimal64(10, 2),
+                                                 this->CreatePythonDecimal("1.000"), 100);
   DecimalTestFromPythonDecimalRescale<Decimal128>(
       ::arrow::decimal128(10, 2), this->CreatePythonDecimal("1.000"), 100);
   DecimalTestFromPythonDecimalRescale<Decimal256>(
@@ -399,9 +399,11 @@ TEST_F(DecimalTest, FromPythonNegativeDecimalRescale) {
       ::arrow::decimal256(10, 9), this->CreatePythonDecimal("-1.000"), -1000000000);
 }
 
-template<typename T>
+template <typename T>
 class DecimalTestConversion : public testing::Test {};
-using DecimalTypes = ::testing::Types<DecimalTypeTraits<16>, DecimalTypeTraits<32>, DecimalTypeTraits<64>, DecimalTypeTraits<128>, DecimalTypeTraits<256>>; 
+using DecimalTypes =
+    ::testing::Types<DecimalTypeTraits<16>, DecimalTypeTraits<32>, DecimalTypeTraits<64>,
+                     DecimalTypeTraits<128>, DecimalTypeTraits<256>>;
 
 TYPED_TEST_SUITE(DecimalTestConversion, DecimalTypes);
 
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
index 351e115e00f44..4c01c38adca06 100644
--- a/cpp/src/arrow/scalar.cc
+++ b/cpp/src/arrow/scalar.cc
@@ -69,8 +69,8 @@ struct ScalarHashImpl {
     return StdHash(s.value.days) & StdHash(s.value.days);
   }
 
-  template <uint32_t width>
-  typename std::enable_if<width <= 64, Status>::type Visit(const BaseDecimalScalar<width>& s) {
+  template <uint32_t width, typename = typename std::enable_if<width <= 64, void>::type>
+  Status Visit(const BaseDecimalScalar<width>& s) {
     return StdHash(s.value.Value());
   }
 
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index c91239f495d58..01decf9637cd6 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -340,7 +340,7 @@ struct ARROW_EXPORT DurationScalar : public TemporalScalar<DurationType> {
   using TemporalScalar<DurationType>::TemporalScalar;
 };
 
-template<uint32_t width>
+template <uint32_t width>
 struct BaseDecimalScalar : public Scalar {
   using Scalar::Scalar;
   using TypeClass = typename DecimalTypeTraits<width>::TypeClass;
diff --git a/cpp/src/arrow/scalar_test.cc b/cpp/src/arrow/scalar_test.cc
index 159fa725e0202..64c2a5aa234d5 100644
--- a/cpp/src/arrow/scalar_test.cc
+++ b/cpp/src/arrow/scalar_test.cc
@@ -329,10 +329,11 @@ TYPED_TEST(TestRealScalar, StructOf) { this->TestStructOf(); }
 
 TYPED_TEST(TestRealScalar, ListOf) { this->TestListOf(); }
 
-
-template<typename T>
+template <typename T>
 class TestDecimalScalar : public testing::Test {};
-using DecimalTypes = ::testing::Types<DecimalTypeTraits<16>, DecimalTypeTraits<32>, DecimalTypeTraits<64>, DecimalTypeTraits<128>, DecimalTypeTraits<256>>; 
+using DecimalTypes =
+    ::testing::Types<DecimalTypeTraits<16>, DecimalTypeTraits<32>, DecimalTypeTraits<64>,
+                     DecimalTypeTraits<128>, DecimalTypeTraits<256>>;
 
 TYPED_TEST_SUITE(TestDecimalScalar, DecimalTypes);
 
diff --git a/cpp/src/arrow/testing/json_internal.cc b/cpp/src/arrow/testing/json_internal.cc
index 4211c91f60e2f..5ebc887b69a6f 100644
--- a/cpp/src/arrow/testing/json_internal.cc
+++ b/cpp/src/arrow/testing/json_internal.cc
@@ -541,7 +541,7 @@ class ArrayWriter {
     }
   }
 
-  template<uint32_t width>
+  template <uint32_t width>
   void WriteDataValues(const BaseDecimalArray<width>& arr) {
     static const char null_string[] = "0";
     for (int64_t i = 0; i < arr.length(); ++i) {
@@ -851,7 +851,7 @@ Status GetDecimal(const RjObject& json_type, std::shared_ptr<DataType>* type) {
       break;
     default:
       return Status::Invalid("Only 128 bit and 256 Decimals are supported. Received",
-                          bit_width);
+                             bit_width);
   }
 
   return Status::OK();
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index ca083ad72e8d8..20d71818a683d 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -35,6 +35,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal_type_traits.h"
 #include "arrow/util/hash_util.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/key_value_metadata.h"
@@ -42,7 +43,6 @@
 #include "arrow/util/make_unique.h"
 #include "arrow/util/range.h"
 #include "arrow/util/vector.h"
-#include "arrow/util/decimal_type_traits.h"
 #include "arrow/visitor_inline.h"
 
 namespace arrow {
@@ -806,16 +806,16 @@ int32_t DecimalType::DecimalSize(int32_t precision) {
 // ----------------------------------------------------------------------
 // Decimal type
 
-
-template<uint32_t width>
+template <uint32_t width>
 BaseDecimalType<width>::BaseDecimalType(int32_t precision, int32_t scale)
     : DecimalType(DecimalTypeTraits<width>::Id, (width >> 3), precision, scale) {
   ARROW_CHECK_GE(precision, kMinPrecision);
   ARROW_CHECK_LE(precision, kMaxPrecision);
 }
 
-template<uint32_t width>
-Result<std::shared_ptr<DataType>> BaseDecimalType<width>::Make(int32_t precision, int32_t scale) {
+template <uint32_t width>
+Result<std::shared_ptr<DataType>> BaseDecimalType<width>::Make(int32_t precision,
+                                                               int32_t scale) {
   if (precision < kMinPrecision || precision > kMaxPrecision) {
     return Status::Invalid("Decimal precision out of range: ", precision);
   }
@@ -2212,7 +2212,7 @@ std::shared_ptr<DataType> decimal256(int32_t precision, int32_t scale) {
   return std::make_shared<Decimal256Type>(precision, scale);
 }
 
-template<uint32_t width>
+template <uint32_t width>
 std::string BaseDecimalType<width>::ToString() const {
   std::stringstream s;
   s << type_name() << "(" << precision_ << ", " << scale_ << ")";
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index 86d1715e21172..edfcde60bc25a 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -30,10 +30,10 @@
 #include "arrow/result.h"
 #include "arrow/type_fwd.h"  // IWYU pragma: export
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal_meta.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/variant.h"
 #include "arrow/util/visibility.h"
-#include "arrow/util/decimal_meta.h"
 #include "arrow/visitor.h"  // IWYU pragma: keep
 
 namespace arrow {
@@ -894,7 +894,7 @@ class ARROW_EXPORT DecimalType : public FixedSizeBinaryType {
 };
 
 /// \brief Template type class for decimal data
-template<uint32_t width>
+template <uint32_t width>
 class ARROW_EXPORT BaseDecimalType : public DecimalType {
  public:
   static constexpr const char* type_name() { return DecimalMeta<width>::name; }
@@ -915,35 +915,35 @@ class ARROW_EXPORT BaseDecimalType : public DecimalType {
 
 /// \brief Concrete type class for decimal 16-bit data
 class ARROW_EXPORT Decimal16Type : public BaseDecimalType<16> {
-public:
+ public:
   static constexpr Type::type type_id = Type::DECIMAL16;
   using BaseDecimalType<16>::BaseDecimalType;
 };
 
 /// \brief Concrete type class for decimal 32-bit data
 class ARROW_EXPORT Decimal32Type : public BaseDecimalType<32> {
-public:
+ public:
   static constexpr Type::type type_id = Type::DECIMAL32;
   using BaseDecimalType<32>::BaseDecimalType;
 };
 
 /// \brief Concrete type class for decimal 64-bit data
 class ARROW_EXPORT Decimal64Type : public BaseDecimalType<64> {
-public:
+ public:
   static constexpr Type::type type_id = Type::DECIMAL64;
   using BaseDecimalType<64>::BaseDecimalType;
 };
 
 /// \brief Concrete type class for decimal 128-bit data
 class ARROW_EXPORT Decimal128Type : public BaseDecimalType<128> {
-public:
+ public:
   static constexpr Type::type type_id = Type::DECIMAL128;
   using BaseDecimalType<128>::BaseDecimalType;
 };
 
 /// \brief Concrete type class for decimal 256-bit data
 class ARROW_EXPORT Decimal256Type : public BaseDecimalType<256> {
-public:
+ public:
   static constexpr Type::type type_id = Type::DECIMAL256;
   using BaseDecimalType<256>::BaseDecimalType;
 };
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index 5f85ce462e96d..ca917cde7beba 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -145,16 +145,16 @@ struct StructScalar;
 
 class DecimalType;
 
-template<uint32_t width>
+template <uint32_t width>
 class DecimalAnyWidth;
 
-template<uint32_t width>
+template <uint32_t width>
 class BaseDecimalArray;
 
-template<uint32_t width>
+template <uint32_t width>
 class BaseDecimalBuilder;
 
-template<uint32_t width>
+template <uint32_t width>
 struct BaseDecimalScalar;
 
 using Decimal16 = DecimalAnyWidth<16>;
@@ -163,11 +163,11 @@ using Decimal64 = DecimalAnyWidth<64>;
 class Decimal128;
 class Decimal256;
 
-#define DECIMAL_DECL(width)                                \
-class Decimal##width##Type;                                \
-using Decimal##width##Array = BaseDecimalArray<width>;     \
-using Decimal##width##Builder = BaseDecimalBuilder<width>; \
-using Decimal##width##Scalar = BaseDecimalScalar<width>;
+#define DECIMAL_DECL(width)                                  \
+  class Decimal##width##Type;                                \
+  using Decimal##width##Array = BaseDecimalArray<width>;     \
+  using Decimal##width##Builder = BaseDecimalBuilder<width>; \
+  using Decimal##width##Scalar = BaseDecimalScalar<width>;
 
 DECIMAL_DECL(16)
 DECIMAL_DECL(32)
@@ -177,7 +177,6 @@ DECIMAL_DECL(256)
 
 #undef DECIMAL_DECL
 
-
 struct UnionMode {
   enum type { SPARSE, DENSE };
 };
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 8865175785536..b1312219af0de 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -284,15 +284,14 @@ struct TypeTraits<HalfFloatType> {
   static inline std::shared_ptr<DataType> type_singleton() { return float16(); }
 };
 
-
-#define DECIMAL_TYPE_TRAITS_DEF(width)             \
-template <>                                        \
-struct TypeTraits<Decimal##width##Type> {          \
-  using ArrayType = Decimal##width##Array;         \
-  using BuilderType = Decimal##width##Builder;     \
-  using ScalarType = Decimal##width##Scalar;       \
-  constexpr static bool is_parameter_free = false; \
-};
+#define DECIMAL_TYPE_TRAITS_DEF(width)               \
+  template <>                                        \
+  struct TypeTraits<Decimal##width##Type> {          \
+    using ArrayType = Decimal##width##Array;         \
+    using BuilderType = Decimal##width##Builder;     \
+    using ScalarType = Decimal##width##Scalar;       \
+    constexpr static bool is_parameter_free = false; \
+  };
 
 DECIMAL_TYPE_TRAITS_DEF(16)
 DECIMAL_TYPE_TRAITS_DEF(32)
diff --git a/cpp/src/arrow/util/basic_decimal.cc b/cpp/src/arrow/util/basic_decimal.cc
index 50e9ffccd769a..ccf7af82c0827 100644
--- a/cpp/src/arrow/util/basic_decimal.cc
+++ b/cpp/src/arrow/util/basic_decimal.cc
@@ -28,10 +28,10 @@
 #include <string>
 
 #include "arrow/util/bit_util.h"
+#include "arrow/util/decimal_meta.h"
+#include "arrow/util/decimal_scale_multipliers.h"
 #include "arrow/util/int128_internal.h"
 #include "arrow/util/int_util_internal.h"
-#include "arrow/util/decimal_scale_multipliers.h"
-#include "arrow/util/decimal_meta.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 
@@ -41,7 +41,6 @@ using internal::SafeLeftShift;
 using internal::SafeSignedAdd;
 using internal::SafeSignedMultiply;
 
-
 static const BasicDecimal256 ScaleMultipliersDecimal256[] = {
     BasicDecimal256({1ULL, 0ULL, 0ULL, 0ULL}),
     BasicDecimal256({10ULL, 0ULL, 0ULL, 0ULL}),
@@ -1119,59 +1118,67 @@ BasicDecimal256 operator/(const BasicDecimal256& left, const BasicDecimal256& ri
 
 /// BasicDecimalAnyWidth
 
-template<uint32_t width>
+template <uint32_t width>
 BasicDecimalAnyWidth<width>::BasicDecimalAnyWidth(const uint8_t* bytes) {
   DCHECK_NE(bytes, nullptr);
   value = *(reinterpret_cast<const ValueType*>(bytes));
-};
+}
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator+=(const BasicDecimalAnyWidth<width>& right) {
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator+=(
+    const BasicDecimalAnyWidth<width>& right) {
   value = SafeSignedAdd<ValueType>(value, right.value);
   return *this;
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator-=(const BasicDecimalAnyWidth<width>& right) {
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator-=(
+    const BasicDecimalAnyWidth<width>& right) {
   value -= right.value;
   return *this;
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator*=(const BasicDecimalAnyWidth<width>& right) {
-  value = value * right.value;
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator*=(
+    const BasicDecimalAnyWidth<width>& right) {
+  value = SafeSignedMultiply<ValueType>(value, right.value);
   return *this;
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator/=(const BasicDecimalAnyWidth<width>& right) {
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator/=(
+    const BasicDecimalAnyWidth<width>& right) {
   BasicDecimalAnyWidth<width> remainder;
   auto s = Divide(right, this, &remainder);
   DCHECK_EQ(s, DecimalStatus::kSuccess);
   return *this;
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator%=(const BasicDecimalAnyWidth<width>& right) {
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::operator%=(
+    const BasicDecimalAnyWidth<width>& right) {
   BasicDecimalAnyWidth<width> result;
   auto s = Divide(right, &result, this);
   DCHECK_EQ(s, DecimalStatus::kSuccess);
   return *this;
 }
 
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::Abs() {
+  return *this < 0 ? Negate() : *this;
+}
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::Abs() { return *this < 0 ? Negate() : *this; }
-
-template<uint32_t width>
-BasicDecimalAnyWidth<width> BasicDecimalAnyWidth<width>::Abs(const BasicDecimalAnyWidth<width>& in) {
+template <uint32_t width>
+BasicDecimalAnyWidth<width> BasicDecimalAnyWidth<width>::Abs(
+    const BasicDecimalAnyWidth<width>& in) {
   BasicDecimalAnyWidth<width> result(in);
   return result.Abs();
 }
 
-template<uint32_t width>
-DecimalStatus BasicDecimalAnyWidth<width>::Divide(const BasicDecimalAnyWidth& divisor, BasicDecimalAnyWidth* result,
-                       BasicDecimalAnyWidth* remainder) const {
+template <uint32_t width>
+DecimalStatus BasicDecimalAnyWidth<width>::Divide(const BasicDecimalAnyWidth& divisor,
+                                                  BasicDecimalAnyWidth* result,
+                                                  BasicDecimalAnyWidth* remainder) const {
   if (divisor.value == 0) {
     return DecimalStatus::kDivideByZero;
   }
@@ -1186,49 +1193,52 @@ DecimalStatus BasicDecimalAnyWidth<width>::Divide(const BasicDecimalAnyWidth& di
   return DecimalStatus::kSuccess;
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width> BasicDecimalAnyWidth<width>::GetScaleMultiplier(int32_t scale) {
+template <uint32_t width>
+BasicDecimalAnyWidth<width> BasicDecimalAnyWidth<width>::GetScaleMultiplier(
+    int32_t scale) {
   DCHECK_GE(scale, 0);
   DCHECK_LE(scale, DecimalMeta<width>::max_precision);
 
   return BasicDecimalAnyWidth<width>(ScaleMultipliersAnyWidth<width>::value[scale]);
 }
 
-template<uint32_t width>
+template <uint32_t width>
 std::array<uint8_t, (width >> 3)> BasicDecimalAnyWidth<width>::ToBytes() const {
   std::array<uint8_t, (width >> 3)> out{{0}};
   ToBytes(out.data());
   return out;
 }
 
-template<uint32_t width>
+template <uint32_t width>
 void BasicDecimalAnyWidth<width>::ToBytes(uint8_t* out) const {
   DCHECK_NE(out, nullptr);
   reinterpret_cast<ValueType*>(out)[0] = value;
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::Negate() { 
-  value = - value;
+template <uint32_t width>
+BasicDecimalAnyWidth<width>& BasicDecimalAnyWidth<width>::Negate() {
+  value = -value;
   return *this;
 }
 
-template<uint32_t width>
-DecimalStatus BasicDecimalAnyWidth<width>::Rescale(int32_t original_scale, int32_t new_scale,
-                      BasicDecimalAnyWidth<width>* out) const {
+template <uint32_t width>
+DecimalStatus BasicDecimalAnyWidth<width>::Rescale(
+    int32_t original_scale, int32_t new_scale, BasicDecimalAnyWidth<width>* out) const {
   return DecimalRescale(*this, original_scale, new_scale, out);
 }
 
-template<uint32_t width>
+template <uint32_t width>
 bool BasicDecimalAnyWidth<width>::FitsInPrecision(int32_t precision) const {
   DCHECK_GT(precision, 0);
   DCHECK_LE(precision, DecimalMeta<width>::max_precision);
-  return BasicDecimalAnyWidth<width>::Abs(*this) < ScaleMultipliersAnyWidth<width>::value[precision];
+  return BasicDecimalAnyWidth<width>::Abs(*this) <
+         ScaleMultipliersAnyWidth<width>::value[precision];
 }
 
-template<uint32_t width>
-void BasicDecimalAnyWidth<width>::GetWholeAndFraction(int scale, BasicDecimalAnyWidth<width>* whole,
-                                          BasicDecimalAnyWidth<width>* fraction) const {
+template <uint32_t width>
+void BasicDecimalAnyWidth<width>::GetWholeAndFraction(
+    int scale, BasicDecimalAnyWidth<width>* whole,
+    BasicDecimalAnyWidth<width>* fraction) const {
   DCHECK_GE(scale, 0);
   DCHECK_LE(scale, DecimalMeta<width>::max_precision);
 
@@ -1237,8 +1247,9 @@ void BasicDecimalAnyWidth<width>::GetWholeAndFraction(int scale, BasicDecimalAny
   DCHECK_EQ(s, DecimalStatus::kSuccess);
 }
 
-template<uint32_t width>
-BasicDecimalAnyWidth<width> BasicDecimalAnyWidth<width>::IncreaseScaleBy(int32_t increase_by) const {
+template <uint32_t width>
+BasicDecimalAnyWidth<width> BasicDecimalAnyWidth<width>::IncreaseScaleBy(
+    int32_t increase_by) const {
   DCHECK_GE(increase_by, 0);
   DCHECK_LE(increase_by, DecimalMeta<width>::max_precision);
 
diff --git a/cpp/src/arrow/util/basic_decimal.h b/cpp/src/arrow/util/basic_decimal.h
index ac2011452ce12..6fc8b6f53d573 100644
--- a/cpp/src/arrow/util/basic_decimal.h
+++ b/cpp/src/arrow/util/basic_decimal.h
@@ -23,10 +23,10 @@
 #include <string>
 #include <type_traits>
 
+#include "arrow/util/decimal_meta.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/type_traits.h"
 #include "arrow/util/visibility.h"
-#include "arrow/util/decimal_meta.h"
 
 namespace arrow {
 
@@ -37,7 +37,7 @@ enum class DecimalStatus {
   kRescaleDataLoss,
 };
 
-template<uint32_t width>
+template <uint32_t width>
 class BasicDecimalAnyWidth;
 
 /// Represents a signed 128-bit integer in two's complement.
@@ -336,8 +336,7 @@ ARROW_EXPORT BasicDecimal256 operator*(const BasicDecimal256& left,
 ARROW_EXPORT BasicDecimal256 operator/(const BasicDecimal256& left,
                                        const BasicDecimal256& right);
 
-
-template<uint32_t width>
+template <uint32_t width>
 class ARROW_EXPORT BasicDecimalAnyWidth {
  public:
   using ValueType = typename IntTypes<width>::signed_type;
@@ -346,13 +345,15 @@ class ARROW_EXPORT BasicDecimalAnyWidth {
 
   /// \brief Convert any integer value into a BasicDecimal.
   template <typename T,
-            typename = typename std::enable_if<
-                std::is_integral<T>::value && 
-                ((sizeof(T) < sizeof(ValueType)) || ((sizeof(T) == sizeof(ValueType)) && std::is_signed<T>::value)
-                || std::is_same<T, int>::value), T>::type>
+            typename = typename std::enable_if<std::is_integral<T>::value &&
+                                                   ((sizeof(T) < sizeof(ValueType)) ||
+                                                    ((sizeof(T) == sizeof(ValueType)) &&
+                                                     std::is_signed<T>::value) ||
+                                                    std::is_same<T, int>::value),
+                                               T>::type>
   constexpr BasicDecimalAnyWidth(T value) noexcept
       : value(static_cast<ValueType>(value)) {}
-  
+
   /// \brief Upcast BasicDecimal with less widths
   template <uint32_t _width,
             typename = typename std::enable_if<_width <= width, void>::type>
@@ -374,7 +375,7 @@ class ARROW_EXPORT BasicDecimalAnyWidth {
 
   DecimalStatus Divide(const BasicDecimalAnyWidth& divisor, BasicDecimalAnyWidth* result,
                        BasicDecimalAnyWidth* remainder) const;
-                      
+
   /// \brief Scale multiplier for given scale value.
   static BasicDecimalAnyWidth GetScaleMultiplier(int32_t scale);
 
@@ -399,15 +400,15 @@ class ARROW_EXPORT BasicDecimalAnyWidth {
   /// \brief separate the integer and fractional parts for the given scale.
   void GetWholeAndFraction(int32_t scale, BasicDecimalAnyWidth* whole,
                            BasicDecimalAnyWidth* fraction) const;
-  
+
   /// \brief Scale up.
   BasicDecimalAnyWidth IncreaseScaleBy(int32_t increase_by) const;
 
-  BasicDecimalAnyWidth& operator +=(const BasicDecimalAnyWidth&);
-  BasicDecimalAnyWidth& operator -=(const BasicDecimalAnyWidth&);
-  BasicDecimalAnyWidth& operator *=(const BasicDecimalAnyWidth&);
-  BasicDecimalAnyWidth& operator /=(const BasicDecimalAnyWidth&);
-  BasicDecimalAnyWidth& operator %=(const BasicDecimalAnyWidth&);
+  BasicDecimalAnyWidth& operator+=(const BasicDecimalAnyWidth&);
+  BasicDecimalAnyWidth& operator-=(const BasicDecimalAnyWidth&);
+  BasicDecimalAnyWidth& operator*=(const BasicDecimalAnyWidth&);
+  BasicDecimalAnyWidth& operator/=(const BasicDecimalAnyWidth&);
+  BasicDecimalAnyWidth& operator%=(const BasicDecimalAnyWidth&);
 
   friend bool operator==(const BasicDecimalAnyWidth& left,
                          const BasicDecimalAnyWidth& right) {
@@ -444,30 +445,31 @@ class ARROW_EXPORT BasicDecimalAnyWidth {
     BasicDecimalAnyWidth result(left);
     result += right;
     return result;
-  };
+  }
 
   friend BasicDecimalAnyWidth operator-(const BasicDecimalAnyWidth& left,
                                         const BasicDecimalAnyWidth& right) {
     BasicDecimalAnyWidth result(left);
     result -= right;
     return result;
-  };
+  }
 
   friend BasicDecimalAnyWidth operator*(const BasicDecimalAnyWidth& left,
                                         const BasicDecimalAnyWidth& right) {
     BasicDecimalAnyWidth result(left);
     result *= right;
     return result;
-  };
+  }
 
   friend BasicDecimalAnyWidth operator/(const BasicDecimalAnyWidth& left,
                                         const BasicDecimalAnyWidth& right) {
     BasicDecimalAnyWidth result = left;
     result /= right;
     return result;
-  };
+  }
 
-  friend BasicDecimalAnyWidth operator%(const BasicDecimalAnyWidth& left, const BasicDecimalAnyWidth& right) {
+  friend BasicDecimalAnyWidth operator%(const BasicDecimalAnyWidth& left,
+                                        const BasicDecimalAnyWidth& right) {
     BasicDecimalAnyWidth result = left;
     result %= right;
     return result;
@@ -477,7 +479,6 @@ class ARROW_EXPORT BasicDecimalAnyWidth {
   ValueType value;
 };
 
-
 using BasicDecimal64 = BasicDecimalAnyWidth<64>;
 using BasicDecimal32 = BasicDecimalAnyWidth<32>;
 using BasicDecimal16 = BasicDecimalAnyWidth<16>;
diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc
index 2de218a076b56..35566f274282d 100644
--- a/cpp/src/arrow/util/decimal.cc
+++ b/cpp/src/arrow/util/decimal.cc
@@ -464,8 +464,8 @@ inline Status ToArrowStatus(DecimalStatus dstatus, int num_bits) {
 }
 
 Status FromStringToArray(const util::string_view& s, DecimalComponents& dec,
-                         uint64_t* out, int32_t array_size,
-                         int32_t* precision, int32_t* scale) {
+                         uint64_t* out, int32_t array_size, int32_t* precision,
+                         int32_t* scale) {
   if (s.empty()) {
     return Status::Invalid("Empty string cannot be converted to decimal");
   }
@@ -497,8 +497,7 @@ Status FromStringToArray(const util::string_view& s, DecimalComponents& dec,
 
   if (out != nullptr) {
     ShiftAndAdd(dec.whole_digits, out, array_size);
-    ShiftAndAdd(dec.fractional_digits, out,
-                array_size);
+    ShiftAndAdd(dec.fractional_digits, out, array_size);
   }
 
   return Status::OK();
@@ -511,13 +510,15 @@ Status Decimal128::FromString(const util::string_view& s, Decimal128* out,
   std::array<uint64_t, 2> little_endian_array = {0, 0};
   DecimalComponents dec;
 
-  auto status = FromStringToArray(s, dec, little_endian_array.data(), 2, precision, scale);
+  auto status =
+      FromStringToArray(s, dec, little_endian_array.data(), 2, precision, scale);
   if (status != Status::OK()) {
     return status;
   }
 
   if (out != nullptr) {
-    *out = Decimal128(static_cast<int64_t>(little_endian_array[1]), little_endian_array[0]);
+    *out =
+        Decimal128(static_cast<int64_t>(little_endian_array[1]), little_endian_array[0]);
 
     if (scale != nullptr && *scale < 0) {
       *out *= GetScaleMultiplier(-*scale);
@@ -666,7 +667,8 @@ Status Decimal256::FromString(const util::string_view& s, Decimal256* out,
   std::array<uint64_t, 4> little_endian_array = {0, 0, 0, 0};
   DecimalComponents dec;
 
-  auto status = FromStringToArray(s, dec, little_endian_array.data(), 4, precision, scale);
+  auto status =
+      FromStringToArray(s, dec, little_endian_array.data(), 4, precision, scale);
   if (status != Status::OK()) {
     return status;
   }
@@ -756,32 +758,34 @@ std::ostream& operator<<(std::ostream& os, const Decimal256& decimal) {
   return os;
 }
 
-template<uint32_t width>
+template <uint32_t width>
 DecimalAnyWidth<width>::DecimalAnyWidth(const std::string& str) : DecimalAnyWidth() {
   *this = DecimalAnyWidth<width>::FromString(str).ValueOrDie();
 }
 
-template<uint32_t width>
+template <uint32_t width>
 std::string DecimalAnyWidth<width>::ToIntegerString() const {
   std::stringstream ss;
   ss << this->Value();
   return ss.str();
 }
 
-template<uint32_t width>
+template <uint32_t width>
 std::string DecimalAnyWidth<width>::ToString(int32_t scale) const {
   std::string str(ToIntegerString());
   AdjustIntegerStringWithScale(scale, &str);
   return str;
 }
 
-template<uint32_t width>
-Status DecimalAnyWidth<width>::FromString(const util::string_view& s, DecimalAnyWidth<width>* out,
-                              int32_t* precision, int32_t* scale) {
+template <uint32_t width>
+Status DecimalAnyWidth<width>::FromString(const util::string_view& s,
+                                          DecimalAnyWidth<width>* out, int32_t* precision,
+                                          int32_t* scale) {
   std::array<uint64_t, 1> little_endian_array = {0};
   DecimalComponents dec;
 
-  auto status = FromStringToArray(s, dec, little_endian_array.data(), 1, precision, scale);
+  auto status =
+      FromStringToArray(s, dec, little_endian_array.data(), 1, precision, scale);
   if (status != Status::OK()) {
     return status;
   }
@@ -808,36 +812,40 @@ Status DecimalAnyWidth<width>::FromString(const util::string_view& s, DecimalAny
   return status;
 }
 
-template<uint32_t width>
-Status DecimalAnyWidth<width>::FromString(const std::string& s, DecimalAnyWidth<width>* out, int32_t* precision,
-                              int32_t* scale) {
+template <uint32_t width>
+Status DecimalAnyWidth<width>::FromString(const std::string& s,
+                                          DecimalAnyWidth<width>* out, int32_t* precision,
+                                          int32_t* scale) {
   return FromString(util::string_view(s), out, precision, scale);
 }
 
-template<uint32_t width>
-Status DecimalAnyWidth<width>::FromString(const char* s, DecimalAnyWidth<width>* out, int32_t* precision,
-                              int32_t* scale) {
+template <uint32_t width>
+Status DecimalAnyWidth<width>::FromString(const char* s, DecimalAnyWidth<width>* out,
+                                          int32_t* precision, int32_t* scale) {
   return FromString(util::string_view(s), out, precision, scale);
 }
 
-template<uint32_t width>
-Result<typename DecimalAnyWidth<width>::_DecimalType> DecimalAnyWidth<width>::FromString(const util::string_view& s) {
+template <uint32_t width>
+Result<typename DecimalAnyWidth<width>::_DecimalType> DecimalAnyWidth<width>::FromString(
+    const util::string_view& s) {
   _DecimalType out;
   RETURN_NOT_OK(FromString(s, &out, nullptr, nullptr));
   return std::move(out);
 }
 
-template<uint32_t width>
-Result<typename DecimalAnyWidth<width>::_DecimalType> DecimalAnyWidth<width>::FromString(const std::string& s) {
+template <uint32_t width>
+Result<typename DecimalAnyWidth<width>::_DecimalType> DecimalAnyWidth<width>::FromString(
+    const std::string& s) {
   return FromString(util::string_view(s));
 }
 
-template<uint32_t width>
-Result<typename DecimalAnyWidth<width>::_DecimalType> DecimalAnyWidth<width>::FromString(const char* s) {
+template <uint32_t width>
+Result<typename DecimalAnyWidth<width>::_DecimalType> DecimalAnyWidth<width>::FromString(
+    const char* s) {
   return FromString(util::string_view(s));
 }
 
-template<uint32_t width>
+template <uint32_t width>
 Status DecimalAnyWidth<width>::ToArrowStatus(DecimalStatus dstatus) const {
   return arrow::ToArrowStatus(dstatus, width);
 }
diff --git a/cpp/src/arrow/util/decimal.h b/cpp/src/arrow/util/decimal.h
index afc089b21333a..0f8f8d3060213 100644
--- a/cpp/src/arrow/util/decimal.h
+++ b/cpp/src/arrow/util/decimal.h
@@ -258,11 +258,9 @@ class ARROW_EXPORT Decimal256 : public BasicDecimal256 {
   Status ToArrowStatus(DecimalStatus dstatus) const;
 };
 
-
-template<uint32_t width>
+template <uint32_t width>
 class ARROW_EXPORT DecimalAnyWidth : public BasicDecimalAnyWidth<width> {
-  public:
-
+ public:
   using _DecimalType = typename DecimalTypeTraits<width>::ValueType;
   using ValueType = typename BasicDecimalAnyWidth<width>::ValueType;
 
@@ -272,7 +270,8 @@ class ARROW_EXPORT DecimalAnyWidth : public BasicDecimalAnyWidth<width> {
   /// \endcond
 
   /// \brief constructor creates a Decimal256 from a BasicDecimal128.
-  constexpr DecimalAnyWidth(const BasicDecimalAnyWidth<width>& value) noexcept : BasicDecimalAnyWidth<width>(value) {}
+  constexpr DecimalAnyWidth(const BasicDecimalAnyWidth<width>& value) noexcept
+      : BasicDecimalAnyWidth<width>(value) {}
 
   /// \brief Parse the number from a base 10 string representation.
   explicit DecimalAnyWidth(const std::string& value);
@@ -308,8 +307,7 @@ class ARROW_EXPORT DecimalAnyWidth : public BasicDecimalAnyWidth<width> {
     return std::move(out);
   }
 
-  friend std::ostream& operator<<(std::ostream& os,
-                                               const DecimalAnyWidth& decimal) {
+  friend std::ostream& operator<<(std::ostream& os, const DecimalAnyWidth& decimal) {
     os << decimal.ToIntegerString();
     return os;
   }
diff --git a/cpp/src/arrow/util/decimal_meta.h b/cpp/src/arrow/util/decimal_meta.h
index 59bb1d2206b23..727890926fdef 100644
--- a/cpp/src/arrow/util/decimal_meta.h
+++ b/cpp/src/arrow/util/decimal_meta.h
@@ -19,48 +19,48 @@
 
 namespace arrow {
 
-template<int bit_width>
+template <int bit_width>
 struct IntTypes {};
 
-#define IntTypes_DECL(bit_width)             \
-template<>                                   \
-struct IntTypes<bit_width>{                  \
-  using signed_type = int##bit_width##_t;    \
-  using unsigned_type = uint##bit_width##_t; \
-};
+#define IntTypes_DECL(bit_width)               \
+  template <>                                  \
+  struct IntTypes<bit_width> {                 \
+    using signed_type = int##bit_width##_t;    \
+    using unsigned_type = uint##bit_width##_t; \
+  };
 
 IntTypes_DECL(64);
 IntTypes_DECL(32);
 IntTypes_DECL(16);
 
-template<uint32_t width>
+template <uint32_t width>
 struct DecimalMeta;
 
-template<>
+template <>
 struct DecimalMeta<16> {
   static constexpr const char* name = "decimal16";
   static constexpr int32_t max_precision = 5;
 };
 
-template<>
+template <>
 struct DecimalMeta<32> {
   static constexpr const char* name = "decimal32";
   static constexpr int32_t max_precision = 10;
 };
 
-template<>
+template <>
 struct DecimalMeta<64> {
   static constexpr const char* name = "decimal64";
   static constexpr int32_t max_precision = 19;
 };
 
-template<>
+template <>
 struct DecimalMeta<128> {
   static constexpr const char* name = "decimal";
   static constexpr int32_t max_precision = 38;
 };
 
-template<>
+template <>
 struct DecimalMeta<256> {
   static constexpr const char* name = "decimal256";
   static constexpr int32_t max_precision = 76;
diff --git a/cpp/src/arrow/util/decimal_scale_multipliers.h b/cpp/src/arrow/util/decimal_scale_multipliers.h
index 23067bc860a02..0efb9d8784f97 100644
--- a/cpp/src/arrow/util/decimal_scale_multipliers.h
+++ b/cpp/src/arrow/util/decimal_scale_multipliers.h
@@ -21,35 +21,34 @@
 
 namespace arrow {
 
-template<uint32_t width>
+template <uint32_t width>
 struct ScaleMultipliersAnyWidth {};
 
 #define DECL_ANY_SCALE_MULTIPLIERS(width)                           \
-template<>                                                          \
-struct ScaleMultipliersAnyWidth<width> {                            \
-  static const int##width##_t value[];                              \
-};                                                                  \
-const int##width##_t ScaleMultipliersAnyWidth<width>::value[] = {   \
-  int##width##_t(1LL),                                              \
-  int##width##_t(10LL),                                             \
-  int##width##_t(100LL),                                            \
-  int##width##_t(1000LL),                                           \
-  int##width##_t(10000LL),                                          \
-  int##width##_t(100000LL),                                         \
-  int##width##_t(1000000LL),                                        \
-  int##width##_t(10000000LL),                                       \
-  int##width##_t(100000000LL),                                      \
-  int##width##_t(1000000000LL),                                     \
-  int##width##_t(10000000000LL),                                    \
-  int##width##_t(100000000000LL),                                   \
-  int##width##_t(1000000000000LL),                                  \
-  int##width##_t(10000000000000LL),                                 \
-  int##width##_t(100000000000000LL),                                \
-  int##width##_t(1000000000000000LL),                               \
-  int##width##_t(10000000000000000LL),                              \
-  int##width##_t(100000000000000000LL),                             \
-  int##width##_t(1000000000000000000LL)                             \
-}; 
+  template <>                                                       \
+  struct ScaleMultipliersAnyWidth<width> {                          \
+    static const int##width##_t value[];                            \
+  };                                                                \
+  const int##width##_t ScaleMultipliersAnyWidth<width>::value[] = { \
+      int##width##_t(1LL),                                          \
+      int##width##_t(10LL),                                         \
+      int##width##_t(100LL),                                        \
+      int##width##_t(1000LL),                                       \
+      int##width##_t(10000LL),                                      \
+      int##width##_t(100000LL),                                     \
+      int##width##_t(1000000LL),                                    \
+      int##width##_t(10000000LL),                                   \
+      int##width##_t(100000000LL),                                  \
+      int##width##_t(1000000000LL),                                 \
+      int##width##_t(10000000000LL),                                \
+      int##width##_t(100000000000LL),                               \
+      int##width##_t(1000000000000LL),                              \
+      int##width##_t(10000000000000LL),                             \
+      int##width##_t(100000000000000LL),                            \
+      int##width##_t(1000000000000000LL),                           \
+      int##width##_t(10000000000000000LL),                          \
+      int##width##_t(100000000000000000LL),                         \
+      int##width##_t(1000000000000000000LL)};
 
 DECL_ANY_SCALE_MULTIPLIERS(16)
 DECL_ANY_SCALE_MULTIPLIERS(32)
@@ -98,7 +97,6 @@ static const BasicDecimal128 ScaleMultipliers128[] = {
     BasicDecimal128(542101086242752217LL, 68739955140067328ULL),
     BasicDecimal128(5421010862427522170LL, 687399551400673280ULL)};
 
-
 static const BasicDecimal128 ScaleMultipliersHalf128[] = {
     BasicDecimal128(0ULL),
     BasicDecimal128(5ULL),
@@ -140,4 +138,4 @@ static const BasicDecimal128 ScaleMultipliersHalf128[] = {
     BasicDecimal128(271050543121376108LL, 9257742014424809472ULL),
     BasicDecimal128(2710505431213761085LL, 343699775700336640ULL)};
 
-} // namespace arrow
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/decimal_test.cc b/cpp/src/arrow/util/decimal_test.cc
index e58f4912f3eae..2065472a99385 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -19,12 +19,12 @@
 #include <array>
 #include <cmath>
 #include <cstdint>
+#include <functional>
 #include <ostream>
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <vector>
-#include <functional>
 
 #include <gtest/gtest.h>
 #include <boost/multiprecision/cpp_int.hpp>
@@ -1567,20 +1567,19 @@ TEST_P(Decimal256ToStringTest, ToString) {
 INSTANTIATE_TEST_SUITE_P(Decimal256ToStringTest, Decimal256ToStringTest,
                          ::testing::ValuesIn(kToStringTestData));
 
-
 // DecimalAnyWidth
 
 template <typename T>
-class DecimalAnyWidthTest : public ::testing::Test { };
+class DecimalAnyWidthTest : public ::testing::Test {};
 
 template <typename T>
-class Decimal16Test : public ::testing::Test { };
+class Decimal16Test : public ::testing::Test {};
 
 template <typename T>
-class Decimal32Test : public ::testing::Test { };
+class Decimal32Test : public ::testing::Test {};
 
 template <typename T>
-class Decimal64Test : public ::testing::Test { };
+class Decimal64Test : public ::testing::Test {};
 
 using DecimalTypes = ::testing::Types<Decimal16, Decimal32, Decimal64>;
 
@@ -1592,12 +1591,11 @@ struct DecimalFromStringParams {
 };
 
 static const std::vector<DecimalFromStringParams> DecimalFromStringParamsList = {
-  {"1234", 1234, 0, 4},
-  {"12.34", 1234, 2, 4},
-  {"+12.34", 1234, 2, 4},
-  {"-12.34", -1234, 2, 4},
-  {".0000", 0, 4, 4}
-};
+    {"1234", 1234, 0, 4},
+    {"12.34", 1234, 2, 4},
+    {"+12.34", 1234, 2, 4},
+    {"-12.34", -1234, 2, 4},
+    {".0000", 0, 4, 4}};
 
 TYPED_TEST_SUITE(DecimalAnyWidthTest, DecimalTypes);
 
@@ -1619,16 +1617,14 @@ TYPED_TEST(DecimalAnyWidthTest, FromBool) {
   ASSERT_EQ(TypeParam(1), TypeParam(true));
 }
 
-using Decimal16Types =
-    ::testing::Types<char, unsigned char, short, int>;
+using Decimal16Types = ::testing::Types<char, unsigned char, short, int>;  // NOLINT
 
 using Decimal32Types =
-    ::testing::Types<char, unsigned char, short, unsigned short, int>;
+    ::testing::Types<char, unsigned char, short, unsigned short, int>;  // NOLINT
 
 using Decimal64Types =
-    ::testing::Types<char, unsigned char, short, unsigned short,
-                     int, unsigned int, long, long long
-                     >;
+    ::testing::Types<char, unsigned char, short, unsigned short, int,  // NOLINT
+                     unsigned int, long, long long>;                   // NOLINT
 
 TYPED_TEST_SUITE(Decimal16Test, Decimal16Types);
 
@@ -1647,8 +1643,7 @@ TYPED_TEST(Decimal16Test, Decimal16Types) {
 
     Decimal16 min_value_d(min_value);
     ASSERT_EQ(static_cast<int16_t>(min_value), min_value_d);
-  }
-  else {
+  } else {
     Decimal16 max_value_d(max_value);
     ASSERT_EQ(max_value, max_value_d);
 
@@ -1691,12 +1686,12 @@ TYPED_TEST(Decimal64Test, Decimal64Types) {
   ASSERT_EQ(min_value, min_value_d);
 }
 
-static const std::vector<int16_t> DecimalAnyWidthValues = { -2, -1, 0, 1, 2};
+static const std::vector<int16_t> DecimalAnyWidthValues = {-2, -1, 0, 1, 2};
 
 TYPED_TEST(DecimalAnyWidthTest, ComparatorTest) {
-  for (size_t i=0; i<DecimalAnyWidthValues.size(); i++){
+  for (size_t i = 0; i < DecimalAnyWidthValues.size(); i++) {
     TypeParam d1(DecimalAnyWidthValues[i]);
-    for (size_t j=0; j<DecimalAnyWidthValues.size(); j++){
+    for (size_t j = 0; j < DecimalAnyWidthValues.size(); j++) {
       TypeParam d2(DecimalAnyWidthValues[j]);
 
       ASSERT_EQ(i == j, d1 == d2);
@@ -1716,35 +1711,38 @@ TYPED_TEST(DecimalAnyWidthTest, UpCast) {
   ASSERT_EQ(d, d64);
 }
 
-template<typename T>
+template <typename T>
 struct DecimalAnyWidthBinaryParams {
   static const std::vector<std::pair<std::string, std::function<T(T, T)>>> value;
 };
 
-template<typename T>
-const std::vector<std::pair<std::string, std::function<T(T, T)>>> DecimalAnyWidthBinaryParams<T>::value = {
-  {"+", [](T x, T y) -> T { return x + y;} },
-  {"-", [](T x, T y) -> T { return x - y;} },
-  {"*", [](T x, T y) -> T { return x * y;} },
-  {"/", [](T x, T y) -> T { return y == 0? 0 : x / y;} },
-  {"%", [](T x, T y) -> T { return y == 0? 0 : x % y;} },
+template <typename T>
+const std::vector<std::pair<std::string, std::function<T(T, T)>>>
+    DecimalAnyWidthBinaryParams<T>::value = {
+        {"+", [](T x, T y) -> T { return x + y; }},
+        {"-", [](T x, T y) -> T { return x - y; }},
+        {"*", [](T x, T y) -> T { return x * y; }},
+        {"/", [](T x, T y) -> T { return y == 0 ? 0 : x / y; }},
+        {"%", [](T x, T y) -> T { return y == 0 ? 0 : x % y; }},
 };
 
 TYPED_TEST(DecimalAnyWidthTest, BinaryOperations) {
-  using ValueType = typename arrow::DecimalAnyWidthTest_BinaryOperations_Test<gtest_TypeParam_>::TypeParam::ValueType;
+  using ValueType = typename arrow::DecimalAnyWidthTest_BinaryOperations_Test<
+      gtest_TypeParam_>::TypeParam::ValueType;
   using ArrowValueType = typename arrow::CTypeTraits<ValueType>::ArrowType;
 
   auto DecimalFns = DecimalAnyWidthBinaryParams<TypeParam>::value;
   auto NumericFns = DecimalAnyWidthBinaryParams<int64_t>::value;
 
-  for (size_t i = 0; i < DecimalFns.size(); i++){
+  for (size_t i = 0; i < DecimalFns.size(); i++) {
     for (auto x : GetRandomNumbers<ArrowValueType>(8)) {
       for (auto y : GetRandomNumbers<ArrowValueType>(8)) {
         TypeParam d1(x), d2(y);
         auto result = DecimalFns[i].second(d1, d2);
         auto reference = static_cast<ValueType>(NumericFns[i].second(x, y));
         ASSERT_EQ(reference, result)
-        << d1 << " " << DecimalFns[i].first << " " << d2 << " " << " != " << result;
+            << d1 << " " << DecimalFns[i].first << " " << d2 << " "
+            << " != " << result;
       }
     }
   }
diff --git a/cpp/src/arrow/util/decimal_type_traits.h b/cpp/src/arrow/util/decimal_type_traits.h
index df06fa9cb2549..e3202d5c3ca70 100644
--- a/cpp/src/arrow/util/decimal_type_traits.h
+++ b/cpp/src/arrow/util/decimal_type_traits.h
@@ -21,19 +21,19 @@
 
 namespace arrow {
 
-template<uint32_t width>
+template <uint32_t width>
 struct DecimalTypeTraits;
 
-#define DECIMAL_TYPE_TRAITS_DECL(width)                  \
-template<>                                               \
-struct DecimalTypeTraits<width> {                        \
-  static constexpr Type::type Id = Type::DECIMAL##width; \
-  using ArrayType = Decimal##width##Array;               \
-  using BuilderType = Decimal##width##Builder;           \
-  using ScalarType = Decimal##width##Scalar;             \
-  using TypeClass = Decimal##width##Type;                \
-  using ValueType = Decimal##width;                      \
-};
+#define DECIMAL_TYPE_TRAITS_DECL(width)                    \
+  template <>                                              \
+  struct DecimalTypeTraits<width> {                        \
+    static constexpr Type::type Id = Type::DECIMAL##width; \
+    using ArrayType = Decimal##width##Array;               \
+    using BuilderType = Decimal##width##Builder;           \
+    using ScalarType = Decimal##width##Scalar;             \
+    using TypeClass = Decimal##width##Type;                \
+    using ValueType = Decimal##width;                      \
+  };
 
 DECIMAL_TYPE_TRAITS_DECL(16)
 DECIMAL_TYPE_TRAITS_DECL(32)