diff --git a/cpp/src/arrow/acero/asof_join_benchmark.cc b/cpp/src/arrow/acero/asof_join_benchmark.cc
index ed2ac2258eb6..f2cd10468e64 100644
--- a/cpp/src/arrow/acero/asof_join_benchmark.cc
+++ b/cpp/src/arrow/acero/asof_join_benchmark.cc
@@ -54,7 +54,7 @@ static void TableJoinOverhead(benchmark::State& state,
                               TableGenerationProperties right_table_properties,
                               int batch_size, int num_right_tables,
                               std::string factory_name,
-                              std::shared_ptr<ExecNodeOptions> options) {
+                              const std::shared_ptr<ExecNodeOptions>& options) {
   left_table_properties.column_prefix = "lt";
   left_table_properties.seed = 0;
   ASSERT_OK_AND_ASSIGN(TableStats left_table_stats, MakeTable(left_table_properties));
diff --git a/cpp/src/arrow/acero/asof_join_node.cc b/cpp/src/arrow/acero/asof_join_node.cc
index 3970050e5022..02160135e620 100644
--- a/cpp/src/arrow/acero/asof_join_node.cc
+++ b/cpp/src/arrow/acero/asof_join_node.cc
@@ -238,7 +238,7 @@ struct MemoStore {
     Entry() = default;
 
     Entry(OnType time, std::shared_ptr<arrow::RecordBatch> batch, row_index_t row)
-        : time(time), batch(batch), row(row) {}
+        : time(time), batch(std::move(batch)), row(row) {}
 
     void swap(Entry& other) {
       std::swap(time, other.time);
diff --git a/cpp/src/arrow/acero/asof_join_node_test.cc b/cpp/src/arrow/acero/asof_join_node_test.cc
index 59a9b4ebba12..6356a93b1307 100644
--- a/cpp/src/arrow/acero/asof_join_node_test.cc
+++ b/cpp/src/arrow/acero/asof_join_node_test.cc
@@ -1398,7 +1398,7 @@ struct BackpressureCountingNode : public MapNode {
   BackpressureCountingNode(ExecPlan* plan, std::vector<ExecNode*> inputs,
                            std::shared_ptr<Schema> output_schema,
                            const BackpressureCountingNodeOptions& options)
-      : MapNode(plan, inputs, output_schema), counters(options.counters) {}
+      : MapNode(plan, inputs, std::move(output_schema)), counters(options.counters) {}
 
   static Result<ExecNode*> Make(ExecPlan* plan, std::vector<ExecNode*> inputs,
                                 const ExecNodeOptions& options) {
diff --git a/cpp/src/arrow/acero/hash_aggregate_test.cc b/cpp/src/arrow/acero/hash_aggregate_test.cc
index 2f498f3a7bb2..ad66481db4a9 100644
--- a/cpp/src/arrow/acero/hash_aggregate_test.cc
+++ b/cpp/src/arrow/acero/hash_aggregate_test.cc
@@ -227,7 +227,7 @@ Result<Datum> NaiveGroupBy(std::vector<Datum> arguments, std::vector<Datum> keys
 }
 
 Result<Datum> MakeGroupByOutput(const std::vector<ExecBatch>& output_batches,
-                                const std::shared_ptr<Schema> output_schema,
+                                const std::shared_ptr<Schema>& output_schema,
                                 size_t num_aggregates, size_t num_keys, bool naive) {
   ArrayVector out_arrays(num_aggregates + num_keys);
   for (size_t i = 0; i < out_arrays.size(); ++i) {
diff --git a/cpp/src/arrow/acero/source_node.cc b/cpp/src/arrow/acero/source_node.cc
index ed3723d249da..525ade97d7c8 100644
--- a/cpp/src/arrow/acero/source_node.cc
+++ b/cpp/src/arrow/acero/source_node.cc
@@ -301,7 +301,7 @@ struct SourceNode : ExecNode, public TracedNode {
 };
 
 struct TableSourceNode : public SourceNode {
-  TableSourceNode(ExecPlan* plan, std::shared_ptr<Table> table, int64_t batch_size)
+  TableSourceNode(ExecPlan* plan, const std::shared_ptr<Table>& table, int64_t batch_size)
       : SourceNode(plan, table->schema(), TableGenerator(*table, batch_size),
                    Ordering::Implicit()) {}
 
@@ -319,7 +319,7 @@ struct TableSourceNode : public SourceNode {
 
   const char* kind_name() const override { return "TableSourceNode"; }
 
-  static arrow::Status ValidateTableSourceNodeInput(const std::shared_ptr<Table> table,
+  static arrow::Status ValidateTableSourceNodeInput(const std::shared_ptr<Table>& table,
                                                     const int64_t batch_size) {
     if (table == nullptr) {
       return Status::Invalid("TableSourceNode requires table which is not null");
@@ -372,7 +372,7 @@ template <typename This, typename Options>
 struct SchemaSourceNode : public SourceNode {
   SchemaSourceNode(ExecPlan* plan, std::shared_ptr<Schema> schema,
                    arrow::AsyncGenerator<std::optional<ExecBatch>> generator)
-      : SourceNode(plan, schema, generator, Ordering::Implicit()) {}
+      : SourceNode(plan, std::move(schema), generator, Ordering::Implicit()) {}
 
   static Result<ExecNode*> Make(ExecPlan* plan, std::vector<ExecNode*> inputs,
                                 const ExecNodeOptions& options) {
@@ -408,7 +408,7 @@ struct SchemaSourceNode : public SourceNode {
 struct RecordBatchReaderSourceNode : public SourceNode {
   RecordBatchReaderSourceNode(ExecPlan* plan, std::shared_ptr<Schema> schema,
                               arrow::AsyncGenerator<std::optional<ExecBatch>> generator)
-      : SourceNode(plan, schema, generator, Ordering::Implicit()) {}
+      : SourceNode(plan, std::move(schema), generator, Ordering::Implicit()) {}
 
   static Result<ExecNode*> Make(ExecPlan* plan, std::vector<ExecNode*> inputs,
                                 const ExecNodeOptions& options) {
diff --git a/cpp/src/arrow/acero/source_node_test.cc b/cpp/src/arrow/acero/source_node_test.cc
index 79ff5852815c..d6364dd7d197 100644
--- a/cpp/src/arrow/acero/source_node_test.cc
+++ b/cpp/src/arrow/acero/source_node_test.cc
@@ -37,7 +37,7 @@ struct PauseThenStopNode : public MapNode {
   PauseThenStopNode(ExecPlan* plan, std::vector<ExecNode*> inputs,
                     std::shared_ptr<Schema> output_schema,
                     const PauseThenStopNodeOptions& options)
-      : MapNode(plan, inputs, output_schema), num_pass(options.num_pass) {}
+      : MapNode(plan, inputs, std::move(output_schema)), num_pass(options.num_pass) {}
 
   static Result<ExecNode*> Make(ExecPlan* plan, std::vector<ExecNode*> inputs,
                                 const ExecNodeOptions& options) {
diff --git a/cpp/src/arrow/acero/test_nodes.cc b/cpp/src/arrow/acero/test_nodes.cc
index d95c22ca4510..47dc02ef9283 100644
--- a/cpp/src/arrow/acero/test_nodes.cc
+++ b/cpp/src/arrow/acero/test_nodes.cc
@@ -275,7 +275,7 @@ struct GatedNode : public ExecNode, public TracedNode {
 
   GatedNode(ExecPlan* plan, std::vector<ExecNode*> inputs,
             std::shared_ptr<Schema> output_schema, const GatedNodeOptions& options)
-      : ExecNode(plan, inputs, {"input"}, output_schema),
+      : ExecNode(plan, inputs, {"input"}, std::move(output_schema)),
         TracedNode(this),
         gate_(options.gate) {}
 
diff --git a/cpp/src/arrow/acero/unmaterialized_table_internal.h b/cpp/src/arrow/acero/unmaterialized_table_internal.h
index 86b1a763a603..e1331fb96208 100644
--- a/cpp/src/arrow/acero/unmaterialized_table_internal.h
+++ b/cpp/src/arrow/acero/unmaterialized_table_internal.h
@@ -242,7 +242,7 @@ class UnmaterializedSliceBuilder {
       UnmaterializedCompositeTable<MAX_COMPOSITE_TABLES>* table_)
       : table(table_) {}
 
-  void AddEntry(std::shared_ptr<RecordBatch> rb, uint64_t start, uint64_t end) {
+  void AddEntry(const std::shared_ptr<RecordBatch>& rb, uint64_t start, uint64_t end) {
     if (rb) {
       table->AddRecordBatchRef(rb);
     }
diff --git a/cpp/src/arrow/adapters/orc/adapter.cc b/cpp/src/arrow/adapters/orc/adapter.cc
index 51cca497485c..e40269c9ce0d 100644
--- a/cpp/src/arrow/adapters/orc/adapter.cc
+++ b/cpp/src/arrow/adapters/orc/adapter.cc
@@ -137,7 +137,7 @@ class OrcStripeReader : public RecordBatchReader {
   OrcStripeReader(std::unique_ptr<liborc::RowReader> row_reader,
                   std::shared_ptr<Schema> schema, int64_t batch_size, MemoryPool* pool)
       : row_reader_(std::move(row_reader)),
-        schema_(schema),
+        schema_(std::move(schema)),
         pool_(pool),
         batch_size_{batch_size} {}
 
diff --git a/cpp/src/arrow/adapters/orc/adapter_test.cc b/cpp/src/arrow/adapters/orc/adapter_test.cc
index 3cbb6d7828f1..ef1038fc7c5a 100644
--- a/cpp/src/arrow/adapters/orc/adapter_test.cc
+++ b/cpp/src/arrow/adapters/orc/adapter_test.cc
@@ -103,7 +103,7 @@ std::shared_ptr<Buffer> GenerateFixedDifferenceBuffer(int32_t fixed_length,
 }
 
 std::shared_ptr<Array> CastFixedSizeBinaryArrayToBinaryArray(
-    std::shared_ptr<Array> array) {
+    const std::shared_ptr<Array>& array) {
   auto fixed_size_binary_array = checked_pointer_cast<FixedSizeBinaryArray>(array);
   std::shared_ptr<Buffer> value_offsets = GenerateFixedDifferenceBuffer(
       fixed_size_binary_array->byte_width(), array->length() + 1);
@@ -114,7 +114,7 @@ std::shared_ptr<Array> CastFixedSizeBinaryArrayToBinaryArray(
 
 template <typename TargetArrayType>
 std::shared_ptr<Array> CastInt64ArrayToTemporalArray(
-    const std::shared_ptr<DataType>& type, std::shared_ptr<Array> array) {
+    const std::shared_ptr<DataType>& type, const std::shared_ptr<Array>& array) {
   std::shared_ptr<ArrayData> new_array_data =
       ArrayData::Make(type, array->length(), array->data()->buffers);
   return std::make_shared<TargetArrayType>(new_array_data);
@@ -128,7 +128,7 @@ Result<std::shared_ptr<Array>> GenerateRandomDate64Array(int64_t size,
 }
 
 Result<std::shared_ptr<Array>> GenerateRandomTimestampArray(
-    int64_t size, std::shared_ptr<TimestampType> type, double null_probability) {
+    int64_t size, const std::shared_ptr<TimestampType>& type, double null_probability) {
   random::RandomArrayGenerator rand(kRandomSeed);
   switch (type->unit()) {
     case TimeUnit::type::SECOND: {
@@ -1049,7 +1049,7 @@ namespace {
 // read them back and compare equality in the unit test). Because the orc reader
 // fills unselected values to nulls when reading from the file. So flattening
 // the SparseUnionArray before writing makes it easy for the array equality check.
-std::shared_ptr<Array> FlattenSparseUnionArray(std::shared_ptr<Array> array) {
+std::shared_ptr<Array> FlattenSparseUnionArray(const std::shared_ptr<Array>& array) {
   auto union_array = checked_pointer_cast<SparseUnionArray>(array);
   ArrayVector children;
   for (int i = 0; i < array->num_fields(); ++i) {
@@ -1061,7 +1061,7 @@ std::shared_ptr<Array> FlattenSparseUnionArray(std::shared_ptr<Array> array) {
                                             union_array->type_codes(), array->offset());
 }
 
-void TestUnionConversion(std::shared_ptr<Array> array) {
+void TestUnionConversion(const std::shared_ptr<Array>& array) {
   auto length = array->length();
   auto orc_type = liborc::Type::buildTypeFromString("uniontype<string,int>");
 
diff --git a/cpp/src/arrow/array/array_dict_test.cc b/cpp/src/arrow/array/array_dict_test.cc
index 23335ebb008a..e846ca0a9369 100644
--- a/cpp/src/arrow/array/array_dict_test.cc
+++ b/cpp/src/arrow/array/array_dict_test.cc
@@ -873,7 +873,7 @@ TEST(TestFixedSizeBinaryDictionaryBuilder, AppendArrayInvalidType) {
 #endif
 
 template <typename DecimalValue>
-void TestDecimalDictionaryBuilderBasic(std::shared_ptr<DataType> decimal_type) {
+void TestDecimalDictionaryBuilderBasic(const std::shared_ptr<DataType>& decimal_type) {
   // Build the dictionary Array
   DictionaryBuilder<FixedSizeBinaryType> builder(decimal_type);
 
@@ -903,7 +903,8 @@ TEST(TestDecimal256DictionaryBuilder, Basic) {
 }
 
 void TestDecimalDictionaryBuilderDoubleTableSize(
-    std::shared_ptr<DataType> decimal_type, FixedSizeBinaryBuilder& decimal_builder) {
+    const std::shared_ptr<DataType>& decimal_type,
+    FixedSizeBinaryBuilder& decimal_builder) {
   // Build the dictionary Array
   DictionaryBuilder<FixedSizeBinaryType> dict_builder(decimal_type);
 
diff --git a/cpp/src/arrow/array/array_nested.cc b/cpp/src/arrow/array/array_nested.cc
index 6849aca089b7..9ff303125537 100644
--- a/cpp/src/arrow/array/array_nested.cc
+++ b/cpp/src/arrow/array/array_nested.cc
@@ -130,7 +130,7 @@ Result<std::shared_ptr<typename TypeTraits<TYPE>::ArrayType>> ListArrayFromArray
   if (offsets.null_count() > 0) {
     ARROW_ASSIGN_OR_RAISE(auto buffers,
                           CleanListOffsets<TYPE>(null_bitmap, offsets, pool));
-    auto data = ArrayData::Make(type, offsets.length() - 1, std::move(buffers),
+    auto data = ArrayData::Make(std::move(type), offsets.length() - 1, std::move(buffers),
                                 {values.data()}, offsets.null_count(), /*offset=*/0);
     return std::make_shared<ArrayType>(std::move(data));
   }
@@ -138,7 +138,7 @@ Result<std::shared_ptr<typename TypeTraits<TYPE>::ArrayType>> ListArrayFromArray
   using OffsetArrayType = typename TypeTraits<OffsetArrowType>::ArrayType;
   const auto& typed_offsets = checked_cast<const OffsetArrayType&>(offsets);
   auto buffers = BufferVector({std::move(null_bitmap), typed_offsets.values()});
-  auto data = ArrayData::Make(type, offsets.length() - 1, std::move(buffers),
+  auto data = ArrayData::Make(std::move(type), offsets.length() - 1, std::move(buffers),
                               {values.data()}, null_count, offsets.offset());
   return std::make_shared<ArrayType>(std::move(data));
 }
@@ -209,8 +209,8 @@ Result<std::shared_ptr<typename TypeTraits<TYPE>::ArrayType>> ListViewArrayFromA
       typed_offsets.values(),
       typed_sizes.values(),
   });
-  auto data = ArrayData::Make(type, sizes.length(), std::move(buffers), {values.data()},
-                              null_count, array_offset);
+  auto data = ArrayData::Make(std::move(type), sizes.length(), std::move(buffers),
+                              {values.data()}, null_count, array_offset);
   return std::make_shared<ArrayType>(std::move(data));
 }
 
diff --git a/cpp/src/arrow/array/array_run_end_test.cc b/cpp/src/arrow/array/array_run_end_test.cc
index 6cf50ccade19..b81fdfae7cde 100644
--- a/cpp/src/arrow/array/array_run_end_test.cc
+++ b/cpp/src/arrow/array/array_run_end_test.cc
@@ -68,7 +68,7 @@ class TestRunEndEncodedArray
   }
 
   std::shared_ptr<RunEndEncodedArray> RunEndEncodedArrayFromJSON(
-      int64_t logical_length, std::shared_ptr<DataType> value_type,
+      int64_t logical_length, const std::shared_ptr<DataType>& value_type,
       std::string_view run_ends_json, std::string_view values_json,
       int64_t logical_offset = 0) {
     auto run_ends = ArrayFromJSON(run_end_type, run_ends_json);
diff --git a/cpp/src/arrow/array/builder_run_end.cc b/cpp/src/arrow/array/builder_run_end.cc
index 2edeaff504d2..0e71df72f63e 100644
--- a/cpp/src/arrow/array/builder_run_end.cc
+++ b/cpp/src/arrow/array/builder_run_end.cc
@@ -167,7 +167,8 @@ RunEndEncodedBuilder::ValueRunBuilder::ValueRunBuilder(
 RunEndEncodedBuilder::RunEndEncodedBuilder(
     MemoryPool* pool, const std::shared_ptr<ArrayBuilder>& run_end_builder,
     const std::shared_ptr<ArrayBuilder>& value_builder, std::shared_ptr<DataType> type)
-    : ArrayBuilder(pool), type_(internal::checked_pointer_cast<RunEndEncodedType>(type)) {
+    : ArrayBuilder(pool),
+      type_(internal::checked_pointer_cast<RunEndEncodedType>(std::move(type))) {
   auto value_run_builder =
       std::make_shared<ValueRunBuilder>(pool, value_builder, type_->value_type(), *this);
   value_run_builder_ = value_run_builder.get();
diff --git a/cpp/src/arrow/array/diff_test.cc b/cpp/src/arrow/array/diff_test.cc
index 76f4202992f3..958ba10ffdaf 100644
--- a/cpp/src/arrow/array/diff_test.cc
+++ b/cpp/src/arrow/array/diff_test.cc
@@ -115,7 +115,7 @@ class DiffTest : public ::testing::Test {
                       /*verbose=*/true);
   }
 
-  void BaseAndTargetFromRandomFilter(std::shared_ptr<Array> values,
+  void BaseAndTargetFromRandomFilter(const std::shared_ptr<Array>& values,
                                      double filter_probability) {
     std::shared_ptr<Array> base_filter, target_filter;
     do {
diff --git a/cpp/src/arrow/buffer_test.cc b/cpp/src/arrow/buffer_test.cc
index 4dd210076ed1..15c3300ab96c 100644
--- a/cpp/src/arrow/buffer_test.cc
+++ b/cpp/src/arrow/buffer_test.cc
@@ -87,7 +87,8 @@ class MyDevice : public Device {
 
 class MyMemoryManager : public MemoryManager {
  public:
-  explicit MyMemoryManager(std::shared_ptr<Device> device) : MemoryManager(device) {}
+  explicit MyMemoryManager(const std::shared_ptr<Device>& device)
+      : MemoryManager(device) {}
 
   bool allow_copy() const {
     return checked_cast<const MyDevice&>(*device()).allow_copy();
@@ -135,7 +136,7 @@ class MyBuffer : public Buffer {
   MyBuffer(std::shared_ptr<MemoryManager> mm, const std::shared_ptr<Buffer>& parent)
       : Buffer(parent->data(), parent->size()) {
     parent_ = parent;
-    SetMemoryManager(mm);
+    SetMemoryManager(std::move(mm));
   }
 };
 
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index 184be3ab8eb9..ddd09de0658b 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -1509,7 +1509,8 @@ class ImportedBuffer : public Buffer {
   ImportedBuffer(const uint8_t* data, int64_t size, std::shared_ptr<MemoryManager> mm,
                  DeviceAllocationType device_type,
                  std::shared_ptr<ImportedArrayData> import)
-      : Buffer(data, size, mm, nullptr, device_type), import_(std::move(import)) {}
+      : Buffer(data, size, std::move(mm), nullptr, device_type),
+        import_(std::move(import)) {}
 
   ~ImportedBuffer() override = default;
 
@@ -2288,22 +2289,22 @@ class ArrayStreamReader {
 
   Result<std::shared_ptr<RecordBatch>> ImportRecordBatchInternal(
       struct ArrowArray* array, std::shared_ptr<Schema> schema) {
-    return ImportRecordBatch(array, schema);
+    return ImportRecordBatch(array, std::move(schema));
   }
 
   Result<std::shared_ptr<RecordBatch>> ImportRecordBatchInternal(
       struct ArrowDeviceArray* array, std::shared_ptr<Schema> schema) {
-    return ImportDeviceRecordBatch(array, schema, mapper_);
+    return ImportDeviceRecordBatch(array, std::move(schema), mapper_);
   }
 
   Result<std::shared_ptr<Array>> ImportArrayInternal(
       struct ArrowArray* array, std::shared_ptr<arrow::DataType> type) {
-    return ImportArray(array, type);
+    return ImportArray(array, std::move(type));
   }
 
   Result<std::shared_ptr<Array>> ImportArrayInternal(
       struct ArrowDeviceArray* array, std::shared_ptr<arrow::DataType> type) {
-    return ImportDeviceArray(array, type, mapper_);
+    return ImportDeviceArray(array, std::move(type), mapper_);
   }
 
   Result<std::shared_ptr<Schema>> ReadSchema() {
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 9a4d104d0004..44a1ea9a57c7 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -681,7 +681,7 @@ class TestArrayExport : public ::testing::Test {
   void SetUp() override { pool_ = default_memory_pool(); }
 
   static std::function<Result<std::shared_ptr<Array>>()> JSONArrayFactory(
-      std::shared_ptr<DataType> type, const char* json) {
+      const std::shared_ptr<DataType>& type, const char* json) {
     return [=]() { return ArrayFromJSON(type, json); };
   }
 
@@ -1458,14 +1458,14 @@ class TestDeviceArrayExport : public ::testing::Test {
   }
 
   static std::function<Result<std::shared_ptr<Array>>()> JSONArrayFactory(
-      const std::shared_ptr<MemoryManager>& mm, std::shared_ptr<DataType> type,
+      const std::shared_ptr<MemoryManager>& mm, const std::shared_ptr<DataType>& type,
       const char* json) {
     return [=]() { return ToDevice(mm, *ArrayFromJSON(type, json)->data()); };
   }
 
 #ifdef ARROW_COMPUTE
   static std::function<Result<std::shared_ptr<Array>>()> JSONREEArrayFactory(
-      const std::shared_ptr<MemoryManager>& mm, std::shared_ptr<DataType> type,
+      const std::shared_ptr<MemoryManager>& mm, const std::shared_ptr<DataType>& type,
       const char* json) {
     return [=]() -> Result<std::shared_ptr<Array>> {
       ARROW_ASSIGN_OR_RAISE(auto result, REEFromJSON(type, json));
@@ -3912,7 +3912,8 @@ class TestArrayRoundtrip : public ::testing::Test {
 
   void SetUp() override { pool_ = default_memory_pool(); }
 
-  static ArrayFactory JSONArrayFactory(std::shared_ptr<DataType> type, const char* json) {
+  static ArrayFactory JSONArrayFactory(const std::shared_ptr<DataType>& type,
+                                       const char* json) {
     return [=]() { return ArrayFromJSON(type, json); };
   }
 
@@ -4015,11 +4016,11 @@ class TestArrayRoundtrip : public ::testing::Test {
     ASSERT_EQ(pool_->bytes_allocated(), orig_bytes);
   }
 
-  void TestWithJSON(std::shared_ptr<DataType> type, const char* json) {
+  void TestWithJSON(const std::shared_ptr<DataType>& type, const char* json) {
     TestWithArrayFactory(JSONArrayFactory(type, json));
   }
 
-  void TestWithJSONSliced(std::shared_ptr<DataType> type, const char* json) {
+  void TestWithJSONSliced(const std::shared_ptr<DataType>& type, const char* json) {
     TestWithArrayFactory(SlicedArrayFactory(JSONArrayFactory(type, json)));
   }
 
@@ -4352,7 +4353,8 @@ class TestDeviceArrayRoundtrip : public ::testing::Test {
   }
 
   static ArrayFactory JSONArrayFactory(const std::shared_ptr<MemoryManager>& mm,
-                                       std::shared_ptr<DataType> type, const char* json) {
+                                       const std::shared_ptr<DataType>& type,
+                                       const char* json) {
     return [=]() { return ToDevice(mm, *ArrayFromJSON(type, json)->data()); };
   }
 
@@ -4463,12 +4465,12 @@ class TestDeviceArrayRoundtrip : public ::testing::Test {
   }
 
   void TestWithJSON(const std::shared_ptr<MemoryManager>& mm,
-                    std::shared_ptr<DataType> type, const char* json) {
+                    const std::shared_ptr<DataType>& type, const char* json) {
     TestWithArrayFactory(JSONArrayFactory(mm, type, json));
   }
 
   void TestWithJSONSliced(const std::shared_ptr<MemoryManager>& mm,
-                          std::shared_ptr<DataType> type, const char* json) {
+                          const std::shared_ptr<DataType>& type, const char* json) {
     TestWithArrayFactory(SlicedArrayFactory(JSONArrayFactory(mm, type, json)));
   }
 
@@ -4519,7 +4521,8 @@ class BaseArrayStreamTest : public ::testing::Test {
 
   void TearDown() override { ASSERT_EQ(pool_->bytes_allocated(), orig_allocated_); }
 
-  RecordBatchVector MakeBatches(std::shared_ptr<Schema> schema, ArrayVector arrays) {
+  RecordBatchVector MakeBatches(const std::shared_ptr<Schema>& schema,
+                                ArrayVector arrays) {
     DCHECK_EQ(schema->num_fields(), 1);
     RecordBatchVector batches;
     for (const auto& array : arrays) {
diff --git a/cpp/src/arrow/compute/function_benchmark.cc b/cpp/src/arrow/compute/function_benchmark.cc
index 3dfd590c7e30..1c35fa5b6225 100644
--- a/cpp/src/arrow/compute/function_benchmark.cc
+++ b/cpp/src/arrow/compute/function_benchmark.cc
@@ -37,7 +37,7 @@ namespace compute {
 constexpr int32_t kSeed = 0xfede4a7e;
 constexpr int64_t kScalarCount = 1 << 10;
 
-inline ScalarVector ToScalars(std::shared_ptr<Array> arr) {
+inline ScalarVector ToScalars(const std::shared_ptr<Array>& arr) {
   ScalarVector scalars{static_cast<size_t>(arr->length())};
   int64_t i = 0;
   for (auto& scalar : scalars) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index f7ff72bc114a..2a55405bb873 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -316,7 +316,7 @@ struct ProductImpl : public ScalarAggregator {
   using ProductType = typename TypeTraits<AccType>::CType;
   using OutputType = typename TypeTraits<AccType>::ScalarType;
 
-  explicit ProductImpl(std::shared_ptr<DataType> out_type,
+  explicit ProductImpl(const std::shared_ptr<DataType>& out_type,
                        const ScalarAggregateOptions& options)
       : out_type(out_type),
         options(options),
@@ -400,7 +400,7 @@ struct ProductInit {
 
   ProductInit(KernelContext* ctx, std::shared_ptr<DataType> type,
               const ScalarAggregateOptions& options)
-      : ctx(ctx), type(type), options(options) {}
+      : ctx(ctx), type(std::move(type)), options(options) {}
 
   Status Visit(const DataType&) {
     return Status::NotImplemented("No product implemented");
@@ -844,8 +844,8 @@ struct IndexInit {
 
 void AddBasicAggKernels(KernelInit init,
                         const std::vector<std::shared_ptr<DataType>>& types,
-                        std::shared_ptr<DataType> out_ty, ScalarAggregateFunction* func,
-                        SimdLevel::type simd_level) {
+                        const std::shared_ptr<DataType>& out_ty,
+                        ScalarAggregateFunction* func, SimdLevel::type simd_level) {
   for (const auto& ty : types) {
     // array[InT] -> scalar[OutT]
     auto sig = KernelSignature::Make({ty->id()}, out_ty);
@@ -857,7 +857,7 @@ namespace {
 
 void AddScalarAggKernels(KernelInit init,
                          const std::vector<std::shared_ptr<DataType>>& types,
-                         std::shared_ptr<DataType> out_ty,
+                         const std::shared_ptr<DataType>& out_ty,
                          ScalarAggregateFunction* func) {
   for (const auto& ty : types) {
     auto sig = KernelSignature::Make({ty->id()}, out_ty);
@@ -867,7 +867,7 @@ void AddScalarAggKernels(KernelInit init,
 
 void AddArrayScalarAggKernels(KernelInit init,
                               const std::vector<std::shared_ptr<DataType>>& types,
-                              std::shared_ptr<DataType> out_ty,
+                              const std::shared_ptr<DataType>& out_ty,
                               ScalarAggregateFunction* func,
                               SimdLevel::type simd_level = SimdLevel::NONE) {
   AddBasicAggKernels(init, types, out_ty, func, simd_level);
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
index 3733f415a048..2d6b36e65795 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
@@ -166,7 +166,7 @@ struct SumLikeInit {
 
   SumLikeInit(KernelContext* ctx, std::shared_ptr<DataType> type,
               const ScalarAggregateOptions& options)
-      : ctx(ctx), type(type), options(options) {}
+      : ctx(ctx), type(std::move(type)), options(options) {}
 
   // If this returns true, then the aggregator will promote a decimal to the maximum
   // precision for that type. For instance, a decimal128(3, 2) will be promoted to a
@@ -289,7 +289,7 @@ template <template <typename> class KernelClass>
 struct MeanKernelInit : public SumLikeInit<KernelClass> {
   MeanKernelInit(KernelContext* ctx, std::shared_ptr<DataType> type,
                  const ScalarAggregateOptions& options)
-      : SumLikeInit<KernelClass>(ctx, type, options) {}
+      : SumLikeInit<KernelClass>(ctx, std::move(type), options) {}
 
   bool PromoteDecimal() const override { return false; }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 5cc3a558b1ef..d378469ff48d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -31,7 +31,8 @@ namespace arrow::compute::internal {
 
 void AddBasicAggKernels(KernelInit init,
                         const std::vector<std::shared_ptr<DataType>>& types,
-                        std::shared_ptr<DataType> out_ty, ScalarAggregateFunction* func,
+                        const std::shared_ptr<DataType>& out_ty,
+                        ScalarAggregateFunction* func,
                         SimdLevel::type simd_level = SimdLevel::NONE);
 
 void AddMinMaxKernels(KernelInit init,
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.cc b/cpp/src/arrow/compute/kernels/codegen_internal.cc
index 99a9173041fc..f53f0011e991 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.cc
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.cc
@@ -545,7 +545,7 @@ Status CastDecimalArgs(TypeHolder* begin, size_t count) {
 }
 
 Result<std::shared_ptr<DataType>> WidenDecimalToMaxPrecision(
-    std::shared_ptr<DataType> type) {
+    const std::shared_ptr<DataType>& type) {
   DCHECK(is_decimal(type->id()));
   auto cast_type = checked_pointer_cast<DecimalType>(type);
   switch (type->id()) {
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index bfc529dc0a46..d79fcff3e4d1 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1481,7 +1481,7 @@ Status CastDecimalArgs(TypeHolder* begin, size_t count);
 /// and the maximum precision for that DecimalType.
 ARROW_EXPORT
 Result<std::shared_ptr<DataType>> WidenDecimalToMaxPrecision(
-    std::shared_ptr<DataType> type);
+    const std::shared_ptr<DataType>& type);
 
 ARROW_EXPORT
 bool HasDecimal(const std::vector<TypeHolder>& types);
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index cd60d5280b1c..0af861a310ba 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1059,7 +1059,7 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionFloatingPointNotNull(
 }
 
 template <template <int64_t> class Op>
-void AddArithmeticFunctionTimeDuration(std::shared_ptr<ScalarFunction> func) {
+void AddArithmeticFunctionTimeDuration(const std::shared_ptr<ScalarFunction>& func) {
   // Add Op(time32, duration) -> time32
   TimeUnit::type unit = TimeUnit::SECOND;
   auto exec_1 = ScalarBinary<Time32Type, Time32Type, DurationType, Op<86400>>::Exec;
@@ -1085,7 +1085,7 @@ void AddArithmeticFunctionTimeDuration(std::shared_ptr<ScalarFunction> func) {
 }
 
 template <template <int64_t> class Op>
-void AddArithmeticFunctionDurationTime(std::shared_ptr<ScalarFunction> func) {
+void AddArithmeticFunctionDurationTime(const std::shared_ptr<ScalarFunction>& func) {
   // Add Op(duration, time32) -> time32
   TimeUnit::type unit = TimeUnit::SECOND;
   auto exec_1 = ScalarBinary<Time32Type, DurationType, Time32Type, Op<86400>>::Exec;
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_cast_benchmark.cc
index 3899254c9b92..0792dbd6253c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_benchmark.cc
@@ -31,7 +31,7 @@ constexpr auto kSeed = 0x94378165;
 
 template <typename InputType, typename CType = typename InputType::c_type>
 static void BenchmarkNumericCast(benchmark::State& state,
-                                 std::shared_ptr<DataType> to_type,
+                                 const std::shared_ptr<DataType>& to_type,
                                  const CastOptions& options, CType min, CType max) {
   GenericItemsArgs args(state);
   random::RandomArrayGenerator rand(kSeed);
@@ -44,14 +44,14 @@ static void BenchmarkNumericCast(benchmark::State& state,
 template <typename InputType, typename CType = typename InputType::c_type>
 static void BenchmarkFloatingToIntegerCast(benchmark::State& state,
                                            std::shared_ptr<DataType> from_type,
-                                           std::shared_ptr<DataType> to_type,
+                                           const std::shared_ptr<DataType>& to_type,
                                            const CastOptions& options, CType min,
                                            CType max) {
   GenericItemsArgs args(state);
   random::RandomArrayGenerator rand(kSeed);
   auto array = rand.Numeric<InputType>(args.size, min, max, args.null_proportion);
 
-  std::shared_ptr<Array> values_as_float = *Cast(*array, from_type);
+  std::shared_ptr<Array> values_as_float = *Cast(*array, std::move(from_type));
 
   for (auto _ : state) {
     ABORT_NOT_OK(Cast(values_as_float, to_type, options));
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
index 864ec4afce0c..b95f6a8dbfd0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
@@ -56,11 +56,12 @@ using internal::checked_pointer_cast;
 
 namespace compute {
 
-static std::shared_ptr<Array> InvalidUtf8(std::shared_ptr<DataType> type) {
+static std::shared_ptr<Array> InvalidUtf8(const std::shared_ptr<DataType>& type) {
   return BinaryArrayFromStrings(type, {"Hi", "olá mundo", "你好世界", "", "\xa0\xa1"});
 }
 
-static std::shared_ptr<Array> FixedSizeInvalidUtf8(std::shared_ptr<DataType> type) {
+static std::shared_ptr<Array> FixedSizeInvalidUtf8(
+    const std::shared_ptr<DataType>& type) {
   if (type->id() == Type::FIXED_SIZE_BINARY) {
     // Assume a particular width for testing
     EXPECT_EQ(3, checked_cast<const FixedSizeBinaryType&>(*type).byte_width());
@@ -88,13 +89,14 @@ static void AssertBufferSame(const Array& left, const Array& right, size_t buffe
             right.data()->buffers[buffer_index].get());
 }
 
-static void CheckCast(std::shared_ptr<Array> input, std::shared_ptr<Array> expected,
+static void CheckCast(const std::shared_ptr<Array>& input,
+                      const std::shared_ptr<Array>& expected,
                       CastOptions options = CastOptions{}) {
   options.to_type = expected->type();
   CheckScalarUnary("cast", input, expected, &options);
 }
 
-static void CheckCastFails(std::shared_ptr<Array> input, CastOptions options) {
+static void CheckCastFails(const std::shared_ptr<Array>& input, CastOptions options) {
   ASSERT_RAISES(Invalid, Cast(input, options))
       << "\n  to_type:   " << options.to_type.ToString()
       << "\n  from_type: " << input->type()->ToString()
@@ -111,10 +113,10 @@ static void CheckCastFails(std::shared_ptr<Array> input, CastOptions options) {
   ASSERT_GT(num_failing, 0);
 }
 
-static void CheckCastZeroCopy(std::shared_ptr<Array> input,
+static void CheckCastZeroCopy(const std::shared_ptr<Array>& input,
                               std::shared_ptr<DataType> to_type,
                               CastOptions options = CastOptions::Safe()) {
-  ASSERT_OK_AND_ASSIGN(auto converted, Cast(*input, to_type, options));
+  ASSERT_OK_AND_ASSIGN(auto converted, Cast(*input, std::move(to_type), options));
   ValidateOutput(*converted);
 
   ASSERT_EQ(input->data()->buffers.size(), converted->data()->buffers.size());
@@ -123,7 +125,7 @@ static void CheckCastZeroCopy(std::shared_ptr<Array> input,
   }
 }
 
-static std::shared_ptr<Array> MaskArrayWithNullsAt(std::shared_ptr<Array> input,
+static std::shared_ptr<Array> MaskArrayWithNullsAt(const std::shared_ptr<Array>& input,
                                                    std::vector<int> indices_to_mask) {
   auto masked = input->data()->Copy();
   masked->buffers[0] = *AllocateEmptyBitmap(input->length());
@@ -3205,7 +3207,8 @@ TEST(Cast, StringToDate) {
   }
 }
 
-static void AssertBinaryZeroCopy(std::shared_ptr<Array> lhs, std::shared_ptr<Array> rhs) {
+static void AssertBinaryZeroCopy(const std::shared_ptr<Array>& lhs,
+                                 const std::shared_ptr<Array>& rhs) {
   EXPECT_TRUE(is_base_binary_like(lhs->type_id()) || is_binary_view_like(lhs->type_id()));
   EXPECT_EQ(is_base_binary_like(lhs->type_id()), is_base_binary_like(rhs->type_id()));
   // null bitmap and data buffers are always zero-copied
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
index dbd894899204..ed9a20d6b9f1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
@@ -48,7 +48,7 @@ namespace compute {
 // ----------------------------------------------------------------------
 // IsIn tests
 
-void CheckIsIn(const std::shared_ptr<Array> input,
+void CheckIsIn(const std::shared_ptr<Array>& input,
                const std::shared_ptr<Array>& value_set, const std::string& expected_json,
                SetLookupOptions::NullMatchingBehavior null_matching_behavior =
                    SetLookupOptions::MATCH) {
@@ -108,7 +108,7 @@ void CheckIsInDictionary(const std::shared_ptr<DataType>& type,
   AssertArraysEqual(*expected, *actual, /*verbose=*/true);
 }
 
-void CheckIsIn(const std::shared_ptr<Array> input,
+void CheckIsIn(const std::shared_ptr<Array>& input,
                const std::shared_ptr<Array>& value_set, const std::string& expected_json,
                bool skip_nulls) {
   auto expected = ArrayFromJSON(boolean(), expected_json);
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 4969beada682..d4d9997c5459 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -55,13 +55,13 @@ class BaseTestStringKernels : public ::testing::Test {
   using ScalarType = typename TypeTraits<TestType>::ScalarType;
 
   void CheckUnary(std::string func_name, std::string json_input,
-                  std::shared_ptr<DataType> out_ty, std::string json_expected,
+                  const std::shared_ptr<DataType>& out_ty, std::string json_expected,
                   const FunctionOptions* options = nullptr) {
     CheckScalarUnary(func_name, type(), json_input, out_ty, json_expected, options);
   }
 
   void CheckUnary(std::string func_name, const std::shared_ptr<Array>& input,
-                  std::shared_ptr<DataType> out_ty, std::string json_expected,
+                  const std::shared_ptr<DataType>& out_ty, std::string json_expected,
                   const FunctionOptions* options = nullptr) {
     CheckScalar(func_name, {Datum(input)}, Datum(ArrayFromJSON(out_ty, json_expected)),
                 options);
@@ -74,7 +74,8 @@ class BaseTestStringKernels : public ::testing::Test {
   }
 
   void CheckVarArgsScalar(std::string func_name, std::string json_input,
-                          std::shared_ptr<DataType> out_ty, std::string json_expected,
+                          const std::shared_ptr<DataType>& out_ty,
+                          std::string json_expected,
                           const FunctionOptions* options = nullptr) {
     // CheckScalar (on arrays) checks scalar arguments individually,
     // but this lets us test the all-scalar case explicitly
@@ -88,7 +89,7 @@ class BaseTestStringKernels : public ::testing::Test {
   }
 
   void CheckVarArgs(std::string func_name, const DatumVector& inputs,
-                    std::shared_ptr<DataType> out_ty, std::string json_expected,
+                    const std::shared_ptr<DataType>& out_ty, std::string json_expected,
                     const FunctionOptions* options = nullptr) {
     CheckScalar(func_name, inputs, ArrayFromJSON(out_ty, json_expected), options);
   }
@@ -794,7 +795,7 @@ TYPED_TEST(TestBaseBinaryKernels, BinaryJoinElementWise) {
 class TestFixedSizeBinaryKernels : public ::testing::Test {
  protected:
   void CheckUnary(std::string func_name, std::string json_input,
-                  std::shared_ptr<DataType> out_ty, std::string json_expected,
+                  const std::shared_ptr<DataType>& out_ty, std::string json_expected,
                   const FunctionOptions* options = nullptr) {
     CheckScalarUnary(func_name, type(), json_input, out_ty, json_expected, options);
     // Ensure the equivalent binary kernel does the same thing
diff --git a/cpp/src/arrow/compute/kernels/select_k_test.cc b/cpp/src/arrow/compute/kernels/select_k_test.cc
index 47e4af58001c..dab94db0f1e7 100644
--- a/cpp/src/arrow/compute/kernels/select_k_test.cc
+++ b/cpp/src/arrow/compute/kernels/select_k_test.cc
@@ -83,7 +83,7 @@ class TestSelectKBase : public ::testing::Test {
 
  protected:
   template <SortOrder order>
-  void AssertSelectKArray(const std::shared_ptr<Array> values, int k) {
+  void AssertSelectKArray(const std::shared_ptr<Array>& values, int k) {
     std::shared_ptr<Array> select_k;
     ASSERT_OK_AND_ASSIGN(select_k, SelectK<order>(Datum(*values), k));
     ASSERT_EQ(select_k->data()->null_count, 0);
@@ -91,10 +91,10 @@ class TestSelectKBase : public ::testing::Test {
     ValidateSelectK(Datum(*values), *select_k, order);
   }
 
-  void AssertTopKArray(const std::shared_ptr<Array> values, int n) {
+  void AssertTopKArray(const std::shared_ptr<Array>& values, int n) {
     AssertSelectKArray<SortOrder::Descending>(values, n);
   }
-  void AssertBottomKArray(const std::shared_ptr<Array> values, int n) {
+  void AssertBottomKArray(const std::shared_ptr<Array>& values, int n) {
     AssertSelectKArray<SortOrder::Ascending>(values, n);
   }
 
diff --git a/cpp/src/arrow/compute/kernels/test_util_internal.cc b/cpp/src/arrow/compute/kernels/test_util_internal.cc
index b184fe7d44c4..c50945181695 100644
--- a/cpp/src/arrow/compute/kernels/test_util_internal.cc
+++ b/cpp/src/arrow/compute/kernels/test_util_internal.cc
@@ -83,7 +83,8 @@ void CheckScalarNonRecursive(const std::string& func_name, const DatumVector& in
 }
 
 void CheckScalar(std::string func_name, const ScalarVector& inputs,
-                 std::shared_ptr<Scalar> expected, const FunctionOptions* options) {
+                 const std::shared_ptr<Scalar>& expected,
+                 const FunctionOptions* options) {
   ASSERT_OK_AND_ASSIGN(Datum out, CallFunction(func_name, GetDatums(inputs), options));
   ValidateOutput(out);
   if (!out.scalar()->Equals(*expected)) {
@@ -259,8 +260,8 @@ void CheckScalarUnary(std::string func_name, Datum input, Datum expected,
   CheckScalar(std::move(func_name), input_vector, expected, options);
 }
 
-void CheckScalarUnary(std::string func_name, std::shared_ptr<DataType> in_ty,
-                      std::string json_input, std::shared_ptr<DataType> out_ty,
+void CheckScalarUnary(std::string func_name, const std::shared_ptr<DataType>& in_ty,
+                      std::string json_input, const std::shared_ptr<DataType>& out_ty,
                       std::string json_expected, const FunctionOptions* options) {
   CheckScalarUnary(std::move(func_name), ArrayFromJSON(in_ty, json_input),
                    ArrayFromJSON(out_ty, json_expected), options);
diff --git a/cpp/src/arrow/compute/kernels/test_util_internal.h b/cpp/src/arrow/compute/kernels/test_util_internal.h
index 231e5762135a..72a25a64a200 100644
--- a/cpp/src/arrow/compute/kernels/test_util_internal.h
+++ b/cpp/src/arrow/compute/kernels/test_util_internal.h
@@ -95,7 +95,7 @@ inline std::shared_ptr<Scalar> DecimalScalarFromJSON(
 // Call the function with the given arguments, as well as slices of
 // the arguments and scalars extracted from the arguments.
 void CheckScalar(std::string func_name, const ScalarVector& inputs,
-                 std::shared_ptr<Scalar> expected,
+                 const std::shared_ptr<Scalar>& expected,
                  const FunctionOptions* options = nullptr);
 
 void CheckScalar(std::string func_name, const DatumVector& inputs, Datum expected,
@@ -114,8 +114,8 @@ void CheckScalarNonRecursive(const std::string& func_name, const DatumVector& in
                              const Datum& expected,
                              const FunctionOptions* options = nullptr);
 
-void CheckScalarUnary(std::string func_name, std::shared_ptr<DataType> in_ty,
-                      std::string json_input, std::shared_ptr<DataType> out_ty,
+void CheckScalarUnary(std::string func_name, const std::shared_ptr<DataType>& in_ty,
+                      std::string json_input, const std::shared_ptr<DataType>& out_ty,
                       std::string json_expected,
                       const FunctionOptions* options = nullptr);
 
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 3c4f833b752c..b5140d9357b2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -76,7 +76,7 @@ struct CumulativeBinaryOp {
 
   CumulativeBinaryOp() { current_value = Identity<Op>::template value<OutValue>(); }
 
-  explicit CumulativeBinaryOp(const std::shared_ptr<Scalar> start) {
+  explicit CumulativeBinaryOp(const std::shared_ptr<Scalar>& start) {
     current_value = UnboxScalar<OutType>::Unbox(*start);
   }
 
@@ -97,7 +97,7 @@ struct CumulativeMean {
   CumulativeMean() = default;
 
   // start value is ignored for CumulativeMean
-  explicit CumulativeMean(const std::shared_ptr<Scalar> start) {}
+  explicit CumulativeMean(const std::shared_ptr<Scalar>& start) {}
 
   double Call(KernelContext* ctx, ArgValue arg, Status* st) {
     sum += static_cast<double>(arg);
diff --git a/cpp/src/arrow/compute/kernels/vector_replace_test.cc b/cpp/src/arrow/compute/kernels/vector_replace_test.cc
index dc63bae39a54..6bc2a7aeb9fb 100644
--- a/cpp/src/arrow/compute/kernels/vector_replace_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_replace_test.cc
@@ -148,7 +148,7 @@ class TestReplaceKernel : public ::testing::Test {
   }
 
   void AssertFillNullChunkedArray(FillNullFunction func,
-                                  const std::shared_ptr<ChunkedArray> array,
+                                  const std::shared_ptr<ChunkedArray>& array,
                                   const std::shared_ptr<ChunkedArray>& expected) {
     ASSERT_OK_AND_ASSIGN(auto actual, func(Datum(*array), nullptr));
     AssertChunkedEquivalent(*expected, *actual.chunked_array());
diff --git a/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc b/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc
index 68ab4543922f..5b9e9e169aba 100644
--- a/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc
@@ -49,8 +49,8 @@ struct REETestData {
   }
 
  public:
-  static REETestData JSON(std::shared_ptr<DataType> data_type, std::string input_json,
-                          std::string expected_values_json,
+  static REETestData JSON(const std::shared_ptr<DataType>& data_type,
+                          std::string input_json, std::string expected_values_json,
                           std::string expected_run_ends_json, int64_t input_offset = 0) {
     auto input_array = ArrayFromJSON(data_type, input_json);
     return SingleArray(input_offset ? input_array->Slice(input_offset) : input_array,
@@ -69,7 +69,7 @@ struct REETestData {
         "[null * " + std::to_string(input_slice_length) + "]");
   }
 
-  static REETestData JSONChunked(std::shared_ptr<DataType> data_type,
+  static REETestData JSONChunked(const std::shared_ptr<DataType>& data_type,
                                  std::vector<std::string> inputs_json,
                                  std::vector<std::string> expected_values_json,
                                  std::vector<std::string> expected_run_ends_json,
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
index c79720985399..f98929306da8 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
@@ -1305,7 +1305,7 @@ void CheckTakeXA(const std::shared_ptr<DataType>& type, const std::string& value
   }
 }
 
-void CheckTakeXADictionary(std::shared_ptr<DataType> value_type,
+void CheckTakeXADictionary(const std::shared_ptr<DataType>& value_type,
                            const std::string& dictionary_values,
                            const std::string& dictionary_indices,
                            const std::string& indices,
@@ -1489,7 +1489,7 @@ class TestTakeKernel : public ::testing::Test {
  public:
   void DoTestNoValidityBitmapButUnknownNullCount(
       const std::shared_ptr<DataType>& type, const std::string& values,
-      const std::string& indices, std::shared_ptr<DataType> index_type = int8()) {
+      const std::string& indices, const std::shared_ptr<DataType>& index_type = int8()) {
     DoTestNoValidityBitmapButUnknownNullCount(ArrayFromJSON(type, values),
                                               ArrayFromJSON(index_type, indices));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 3ff888570710..20ada697d7c7 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -345,7 +345,7 @@ class ConcreteRecordBatchColumnSorter : public RecordBatchColumnSorter {
 template <>
 class ConcreteRecordBatchColumnSorter<NullType> : public RecordBatchColumnSorter {
  public:
-  ConcreteRecordBatchColumnSorter(std::shared_ptr<Array> array, SortOrder order,
+  ConcreteRecordBatchColumnSorter(const std::shared_ptr<Array>& array, SortOrder order,
                                   NullPlacement null_placement,
                                   RecordBatchColumnSorter* next_column = nullptr)
       : RecordBatchColumnSorter(next_column), null_placement_(null_placement) {}
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index 9bc30f23234b..fc76fe20448b 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -2396,7 +2396,7 @@ class TestRank : public BaseTestRank {
     AssertRank(datums_, order, null_placement, tiebreaker, expected);
   }
 
-  static void AssertRankEmpty(std::shared_ptr<DataType> type, SortOrder order,
+  static void AssertRankEmpty(const std::shared_ptr<DataType>& type, SortOrder order,
                               NullPlacement null_placement,
                               RankOptions::Tiebreaker tiebreaker) {
     AssertRank({ArrayFromJSON(type, "[]")}, order, null_placement, tiebreaker,
@@ -2708,7 +2708,7 @@ class TestRankQuantile : public BaseTestRank {
     AssertRankQuantileGeneric("rank_normal", std::forward<Args>(args)...);
   }
 
-  void AssertRankQuantileEmpty(std::shared_ptr<DataType> type) {
+  void AssertRankQuantileEmpty(const std::shared_ptr<DataType>& type) {
     for (auto null_placement : AllNullPlacements()) {
       for (auto order : AllOrders()) {
         AssertRankQuantile(ArrayFromJSON(type, "[]"), order, null_placement, "[]");
@@ -2765,7 +2765,7 @@ class TestRankQuantile : public BaseTestRank {
                      "-1.2815515655446004, 0.5244005127080407]");
   }
 
-  void AssertRankQuantileNumeric(std::shared_ptr<DataType> type) {
+  void AssertRankQuantileNumeric(const std::shared_ptr<DataType>& type) {
     ARROW_SCOPED_TRACE("type = ", type->ToString());
     AssertRankQuantileEmpty(type);
 
@@ -2794,7 +2794,7 @@ class TestRankQuantile : public BaseTestRank {
     AssertRankQuantile_N1N2N();
   }
 
-  void AssertRankQuantileBinaryLike(std::shared_ptr<DataType> type) {
+  void AssertRankQuantileBinaryLike(const std::shared_ptr<DataType>& type) {
     ARROW_SCOPED_TRACE("type = ", type->ToString());
     AssertRankQuantileEmpty(type);
 
diff --git a/cpp/src/arrow/csv/column_builder_test.cc b/cpp/src/arrow/csv/column_builder_test.cc
index 94de8c92d4be..5f166027d106 100644
--- a/cpp/src/arrow/csv/column_builder_test.cc
+++ b/cpp/src/arrow/csv/column_builder_test.cc
@@ -77,7 +77,8 @@ class ColumnBuilderTest : public ::testing::Test {
 
   void CheckInferred(const std::shared_ptr<TaskGroup>& tg, const ChunkData& csv_data,
                      const ConvertOptions& options,
-                     std::shared_ptr<ChunkedArray> expected, bool validate_full = true) {
+                     const std::shared_ptr<ChunkedArray>& expected,
+                     bool validate_full = true) {
     std::shared_ptr<ColumnBuilder> builder;
     std::shared_ptr<ChunkedArray> actual;
     ASSERT_OK_AND_ASSIGN(
@@ -97,7 +98,7 @@ class ColumnBuilderTest : public ::testing::Test {
   void CheckFixedType(const std::shared_ptr<TaskGroup>& tg,
                       const std::shared_ptr<DataType>& type, const ChunkData& csv_data,
                       const ConvertOptions& options,
-                      std::shared_ptr<ChunkedArray> expected) {
+                      const std::shared_ptr<ChunkedArray>& expected) {
     std::shared_ptr<ColumnBuilder> builder;
     std::shared_ptr<ChunkedArray> actual;
     ASSERT_OK_AND_ASSIGN(builder, ColumnBuilder::Make(default_memory_pool(), type, 0,
diff --git a/cpp/src/arrow/csv/column_decoder_test.cc b/cpp/src/arrow/csv/column_decoder_test.cc
index 567732647179..730ab2e02e73 100644
--- a/cpp/src/arrow/csv/column_decoder_test.cc
+++ b/cpp/src/arrow/csv/column_decoder_test.cc
@@ -103,7 +103,8 @@ class ColumnDecoderTest : public ::testing::Test {
     return decoded_chunks_[read_ptr_++].result();
   }
 
-  void AssertChunk(std::vector<std::string> chunk, std::shared_ptr<Array> expected) {
+  void AssertChunk(std::vector<std::string> chunk,
+                   const std::shared_ptr<Array>& expected) {
     std::shared_ptr<BlockParser> parser;
     MakeColumnParser(chunk, &parser);
     ASSERT_FINISHES_OK_AND_ASSIGN(auto decoded, decoder_->Decode(parser));
@@ -116,7 +117,7 @@ class ColumnDecoderTest : public ::testing::Test {
     ASSERT_FINISHES_AND_RAISES(Invalid, decoder_->Decode(parser));
   }
 
-  void AssertFetch(std::shared_ptr<Array> expected_chunk) {
+  void AssertFetch(const std::shared_ptr<Array>& expected_chunk) {
     ASSERT_OK_AND_ASSIGN(auto chunk, NextChunk());
     ASSERT_NE(chunk, nullptr);
     AssertArraysEqual(*expected_chunk, *chunk);
@@ -142,7 +143,7 @@ class NullColumnDecoderTest : public ColumnDecoderTest {
 
   void MakeDecoder(std::shared_ptr<DataType> type) {
     ASSERT_OK_AND_ASSIGN(auto decoder,
-                         ColumnDecoder::MakeNull(default_memory_pool(), type));
+                         ColumnDecoder::MakeNull(default_memory_pool(), std::move(type)));
     SetDecoder(decoder);
   }
 
diff --git a/cpp/src/arrow/csv/reader.cc b/cpp/src/arrow/csv/reader.cc
index 1ae9d27e6bfd..a78ddc84bd89 100644
--- a/cpp/src/arrow/csv/reader.cc
+++ b/cpp/src/arrow/csv/reader.cc
@@ -195,7 +195,7 @@ class SerialBlockReader : public BlockReader {
 
   static Iterator<CSVBlock> MakeIterator(
       Iterator<std::shared_ptr<Buffer>> buffer_iterator, std::unique_ptr<Chunker> chunker,
-      std::shared_ptr<Buffer> first_buffer, int64_t skip_rows) {
+      const std::shared_ptr<Buffer>& first_buffer, int64_t skip_rows) {
     auto block_reader =
         std::make_shared<SerialBlockReader>(std::move(chunker), first_buffer, skip_rows);
     // Wrap shared pointer in callable
@@ -208,7 +208,7 @@ class SerialBlockReader : public BlockReader {
 
   static AsyncGenerator<CSVBlock> MakeAsyncIterator(
       AsyncGenerator<std::shared_ptr<Buffer>> buffer_generator,
-      std::unique_ptr<Chunker> chunker, std::shared_ptr<Buffer> first_buffer,
+      std::unique_ptr<Chunker> chunker, const std::shared_ptr<Buffer>& first_buffer,
       int64_t skip_rows) {
     auto block_reader =
         std::make_shared<SerialBlockReader>(std::move(chunker), first_buffer, skip_rows);
@@ -283,7 +283,7 @@ class ThreadedBlockReader : public BlockReader {
 
   static AsyncGenerator<CSVBlock> MakeAsyncIterator(
       AsyncGenerator<std::shared_ptr<Buffer>> buffer_generator,
-      std::unique_ptr<Chunker> chunker, std::shared_ptr<Buffer> first_buffer,
+      std::unique_ptr<Chunker> chunker, const std::shared_ptr<Buffer>& first_buffer,
       int64_t skip_rows) {
     auto block_reader = std::make_shared<ThreadedBlockReader>(std::move(chunker),
                                                               first_buffer, skip_rows);
@@ -1024,7 +1024,7 @@ class AsyncThreadedTableReader
   using BaseTableReader::BaseTableReader;
 
   AsyncThreadedTableReader(io::IOContext io_context,
-                           std::shared_ptr<io::InputStream> input,
+                           const std::shared_ptr<io::InputStream>& input,
                            const ReadOptions& read_options,
                            const ParseOptions& parse_options,
                            const ConvertOptions& convert_options, Executor* cpu_executor)
@@ -1115,9 +1115,9 @@ class AsyncThreadedTableReader
 };
 
 Result<std::shared_ptr<TableReader>> MakeTableReader(
-    MemoryPool* pool, io::IOContext io_context, std::shared_ptr<io::InputStream> input,
-    const ReadOptions& read_options, const ParseOptions& parse_options,
-    const ConvertOptions& convert_options) {
+    MemoryPool* pool, io::IOContext io_context,
+    const std::shared_ptr<io::InputStream>& input, const ReadOptions& read_options,
+    const ParseOptions& parse_options, const ConvertOptions& convert_options) {
   RETURN_NOT_OK(parse_options.Validate());
   RETURN_NOT_OK(read_options.Validate());
   RETURN_NOT_OK(convert_options.Validate());
@@ -1136,7 +1136,7 @@ Result<std::shared_ptr<TableReader>> MakeTableReader(
 }
 
 Future<std::shared_ptr<StreamingReader>> MakeStreamingReader(
-    io::IOContext io_context, std::shared_ptr<io::InputStream> input,
+    io::IOContext io_context, const std::shared_ptr<io::InputStream>& input,
     Executor* cpu_executor, const ReadOptions& read_options,
     const ParseOptions& parse_options, const ConvertOptions& convert_options) {
   RETURN_NOT_OK(parse_options.Validate());
diff --git a/cpp/src/arrow/csv/reader_test.cc b/cpp/src/arrow/csv/reader_test.cc
index 2493cb66271e..ac9c1b371990 100644
--- a/cpp/src/arrow/csv/reader_test.cc
+++ b/cpp/src/arrow/csv/reader_test.cc
@@ -192,7 +192,7 @@ void StressInvalidTableReader(TableReaderFactory reader_factory) {
   }
 }
 
-void TestNestedParallelism(std::shared_ptr<internal::ThreadPool> thread_pool,
+void TestNestedParallelism(const std::shared_ptr<internal::ThreadPool>& thread_pool,
                            TableReaderFactory reader_factory) {
   const int NROWS = 1000;
   ASSERT_OK_AND_ASSIGN(auto table_buffer, MakeSampleCsvBuffer(NROWS));
diff --git a/cpp/src/arrow/dataset/dataset_test.cc b/cpp/src/arrow/dataset/dataset_test.cc
index cd23429bf5ef..f9eb08d75c91 100644
--- a/cpp/src/arrow/dataset/dataset_test.cc
+++ b/cpp/src/arrow/dataset/dataset_test.cc
@@ -599,7 +599,7 @@ class TestSchemaUnification : public TestUnionDataset {
   }
 
   template <typename TupleType>
-  void AssertScanEquals(std::shared_ptr<Scanner> scanner,
+  void AssertScanEquals(const std::shared_ptr<Scanner>& scanner,
                         const std::vector<TupleType>& expected_rows) {
     std::vector<std::string> columns;
     for (const auto& field : scanner->options()->projected_schema->fields()) {
@@ -614,7 +614,7 @@ class TestSchemaUnification : public TestUnionDataset {
   }
 
   template <typename TupleType>
-  void AssertBuilderEquals(std::shared_ptr<ScannerBuilder> builder,
+  void AssertBuilderEquals(const std::shared_ptr<ScannerBuilder>& builder,
                            const std::vector<TupleType>& expected_rows) {
     ASSERT_OK_AND_ASSIGN(auto scanner, builder->Finish());
     AssertScanEquals(scanner, expected_rows);
diff --git a/cpp/src/arrow/dataset/discovery.cc b/cpp/src/arrow/dataset/discovery.cc
index c6f6e41d1ed8..488fa1d520d5 100644
--- a/cpp/src/arrow/dataset/discovery.cc
+++ b/cpp/src/arrow/dataset/discovery.cc
@@ -72,7 +72,7 @@ Result<std::shared_ptr<Dataset>> DatasetFactory::Finish() {
 
 Result<std::shared_ptr<Dataset>> DatasetFactory::Finish(std::shared_ptr<Schema> schema) {
   FinishOptions options;
-  options.schema = schema;
+  options.schema = std::move(schema);
   return Finish(std::move(options));
 }
 
diff --git a/cpp/src/arrow/dataset/discovery_test.cc b/cpp/src/arrow/dataset/discovery_test.cc
index 981146b7999e..cdc4163b6422 100644
--- a/cpp/src/arrow/dataset/discovery_test.cc
+++ b/cpp/src/arrow/dataset/discovery_test.cc
@@ -45,7 +45,8 @@ void AssertSchemasAre(std::vector<std::shared_ptr<Schema>> actual,
 
 class DatasetFactoryTest : public TestFileSystemDataset {
  public:
-  void AssertInspect(std::shared_ptr<Schema> expected, InspectOptions options = {}) {
+  void AssertInspect(const std::shared_ptr<Schema>& expected,
+                     InspectOptions options = {}) {
     ASSERT_OK_AND_ASSIGN(auto actual, factory_->Inspect(options));
     EXPECT_EQ(*actual, *expected);
   }
diff --git a/cpp/src/arrow/dataset/file_base.cc b/cpp/src/arrow/dataset/file_base.cc
index 8ad2254aa64b..d6c157bf7215 100644
--- a/cpp/src/arrow/dataset/file_base.cc
+++ b/cpp/src/arrow/dataset/file_base.cc
@@ -439,7 +439,7 @@ class DatasetWritingSinkNodeConsumer : public acero::SinkNodeConsumer {
   }
 
  private:
-  Status WriteNextBatch(std::shared_ptr<RecordBatch> batch,
+  Status WriteNextBatch(const std::shared_ptr<RecordBatch>& batch,
                         compute::Expression guarantee) {
     return WriteBatch(batch, guarantee, write_options_,
                       [this](std::shared_ptr<RecordBatch> next_batch,
@@ -629,7 +629,7 @@ class TeeNode : public acero::MapNode,
     return batch;
   }
 
-  Status WriteNextBatch(std::shared_ptr<RecordBatch> batch,
+  Status WriteNextBatch(const std::shared_ptr<RecordBatch>& batch,
                         compute::Expression guarantee) {
     return WriteBatch(batch, guarantee, write_options_,
                       [this](std::shared_ptr<RecordBatch> next_batch,
diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index ba0e93f09d40..cd81c628a3d2 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -66,7 +66,8 @@ namespace {
 
 parquet::ReaderProperties MakeReaderProperties(
     const ParquetFileFormat& format, ParquetFragmentScanOptions* parquet_scan_options,
-    const std::string& path = "", std::shared_ptr<fs::FileSystem> filesystem = nullptr,
+    const std::string& path = "",
+    const std::shared_ptr<fs::FileSystem>& filesystem = nullptr,
     MemoryPool* pool = default_memory_pool()) {
   // Can't mutate pool after construction
   parquet::ReaderProperties properties(pool);
diff --git a/cpp/src/arrow/dataset/file_parquet_test.cc b/cpp/src/arrow/dataset/file_parquet_test.cc
index 0d86f5eaa0d3..ad7f2048e8de 100644
--- a/cpp/src/arrow/dataset/file_parquet_test.cc
+++ b/cpp/src/arrow/dataset/file_parquet_test.cc
@@ -537,13 +537,13 @@ TEST_F(TestParquetFileSystemDataset, WriteWithEncryptionConfigNotSupported) {
 
 class TestParquetFileFormatScan : public FileFormatScanMixin<ParquetFormatHelper> {
  public:
-  std::shared_ptr<RecordBatch> SingleBatch(std::shared_ptr<Fragment> fragment) {
+  std::shared_ptr<RecordBatch> SingleBatch(const std::shared_ptr<Fragment>& fragment) {
     auto batches = IteratorToVector(PhysicalBatches(fragment));
     EXPECT_EQ(batches.size(), 1);
     return batches.front();
   }
 
-  void CountRowsAndBatchesInScan(std::shared_ptr<Fragment> fragment,
+  void CountRowsAndBatchesInScan(const std::shared_ptr<Fragment>& fragment,
                                  int64_t expected_rows, int64_t expected_batches) {
     int64_t actual_rows = 0;
     int64_t actual_batches = 0;
diff --git a/cpp/src/arrow/dataset/partition_test.cc b/cpp/src/arrow/dataset/partition_test.cc
index 9f0bd7c0be04..a11f0dbdb9cd 100644
--- a/cpp/src/arrow/dataset/partition_test.cc
+++ b/cpp/src/arrow/dataset/partition_test.cc
@@ -90,8 +90,8 @@ class TestPartitioning : public ::testing::Test {
     ASSERT_OK_AND_ASSIGN(partitioning_, factory_->Finish(actual));
   }
 
-  void AssertPartition(const std::shared_ptr<Partitioning> partitioning,
-                       const std::shared_ptr<RecordBatch> full_batch,
+  void AssertPartition(const std::shared_ptr<Partitioning>& partitioning,
+                       const std::shared_ptr<RecordBatch>& full_batch,
                        const RecordBatchVector& expected_batches,
                        const std::vector<compute::Expression>& expected_expressions) {
     ASSERT_OK_AND_ASSIGN(auto partition_results, partitioning->Partition(full_batch));
@@ -116,10 +116,10 @@ class TestPartitioning : public ::testing::Test {
     }
   }
 
-  void AssertPartition(const std::shared_ptr<Partitioning> partitioning,
-                       const std::shared_ptr<Schema> schema,
+  void AssertPartition(const std::shared_ptr<Partitioning>& partitioning,
+                       const std::shared_ptr<Schema>& schema,
                        const std::string& record_batch_json,
-                       const std::shared_ptr<Schema> partitioned_schema,
+                       const std::shared_ptr<Schema>& partitioned_schema,
                        const std::vector<std::string>& expected_record_batch_strs,
                        const std::vector<compute::Expression>& expected_expressions) {
     auto record_batch = RecordBatchFromJSON(schema, record_batch_json);
diff --git a/cpp/src/arrow/dataset/scanner_test.cc b/cpp/src/arrow/dataset/scanner_test.cc
index a45847b49def..27fb3e60b79c 100644
--- a/cpp/src/arrow/dataset/scanner_test.cc
+++ b/cpp/src/arrow/dataset/scanner_test.cc
@@ -528,7 +528,7 @@ class TestScannerBase : public ::testing::TestWithParam<ScannerTestParams> {
     return as_one_batch;
   }
 
-  acero::Declaration MakeScanNode(std::shared_ptr<Dataset> dataset) {
+  acero::Declaration MakeScanNode(const std::shared_ptr<Dataset>& dataset) {
     ScanV2Options options(dataset);
     options.columns = ScanV2Options::AllColumns(*dataset->schema());
     return acero::Declaration("scan2", options);
@@ -878,8 +878,8 @@ TEST(TestNewScanner, MissingColumn) {
 }
 
 void WriteIpcData(const std::string& path,
-                  const std::shared_ptr<fs::FileSystem> file_system,
-                  const std::shared_ptr<Table> input) {
+                  const std::shared_ptr<fs::FileSystem>& file_system,
+                  const std::shared_ptr<Table>& input) {
   EXPECT_OK_AND_ASSIGN(auto out_stream, file_system->OpenOutputStream(path));
   ASSERT_OK_AND_ASSIGN(
       auto file_writer,
@@ -949,7 +949,7 @@ class TestScanner : public DatasetFixtureMixinWithParam<TestScannerParams> {
     return scanner;
   }
 
-  std::shared_ptr<Scanner> MakeScanner(std::shared_ptr<RecordBatch> batch) {
+  std::shared_ptr<Scanner> MakeScanner(const std::shared_ptr<RecordBatch>& batch) {
     RecordBatchVector batches{static_cast<size_t>(GetParam().num_batches), batch};
 
     DatasetVector children{static_cast<size_t>(GetParam().num_child_datasets),
@@ -960,7 +960,7 @@ class TestScanner : public DatasetFixtureMixinWithParam<TestScannerParams> {
   }
 
   void AssertScannerEqualsRepetitionsOf(
-      std::shared_ptr<Scanner> scanner, std::shared_ptr<RecordBatch> batch,
+      const std::shared_ptr<Scanner>& scanner, const std::shared_ptr<RecordBatch>& batch,
       const int64_t total_batches = GetParam().num_child_datasets *
                                     GetParam().num_batches) {
     auto expected = ConstantArrayGenerator::Repeat(total_batches, batch);
@@ -971,7 +971,7 @@ class TestScanner : public DatasetFixtureMixinWithParam<TestScannerParams> {
   }
 
   void AssertScanBatchesEqualRepetitionsOf(
-      std::shared_ptr<Scanner> scanner, std::shared_ptr<RecordBatch> batch,
+      const std::shared_ptr<Scanner>& scanner, const std::shared_ptr<RecordBatch>& batch,
       const int64_t total_batches = GetParam().num_child_datasets *
                                     GetParam().num_batches) {
     auto expected = ConstantArrayGenerator::Repeat(total_batches, batch);
@@ -979,7 +979,7 @@ class TestScanner : public DatasetFixtureMixinWithParam<TestScannerParams> {
     AssertScanBatchesEquals(expected.get(), scanner.get());
   }
 
-  void AssertNoAugmentedFields(std::shared_ptr<Scanner> scanner) {
+  void AssertNoAugmentedFields(const std::shared_ptr<Scanner>& scanner) {
     ASSERT_OK_AND_ASSIGN(auto table, scanner.get()->ToTable());
     auto columns = table.get()->ColumnNames();
     EXPECT_TRUE(std::none_of(columns.begin(), columns.end(), [](std::string& x) {
@@ -989,7 +989,7 @@ class TestScanner : public DatasetFixtureMixinWithParam<TestScannerParams> {
   }
 
   void AssertScanBatchesUnorderedEqualRepetitionsOf(
-      std::shared_ptr<Scanner> scanner, std::shared_ptr<RecordBatch> batch,
+      const std::shared_ptr<Scanner>& scanner, const std::shared_ptr<RecordBatch>& batch,
       const int64_t total_batches = GetParam().num_child_datasets *
                                     GetParam().num_batches) {
     auto expected = ConstantArrayGenerator::Repeat(total_batches, batch);
diff --git a/cpp/src/arrow/dataset/test_util_internal.h b/cpp/src/arrow/dataset/test_util_internal.h
index 0dc8264a9ccd..50f60cf84a55 100644
--- a/cpp/src/arrow/dataset/test_util_internal.h
+++ b/cpp/src/arrow/dataset/test_util_internal.h
@@ -145,8 +145,8 @@ using compute::project;
 using fs::internal::GetAbstractPathExtension;
 
 /// \brief Assert a dataset produces data with the schema
-inline void AssertDatasetHasSchema(std::shared_ptr<Dataset> ds,
-                                   std::shared_ptr<Schema> schema) {
+inline void AssertDatasetHasSchema(const std::shared_ptr<Dataset>& ds,
+                                   const std::shared_ptr<Schema>& schema) {
   ASSERT_OK_AND_ASSIGN(auto scanner_builder, ds->NewScan());
   ASSERT_OK_AND_ASSIGN(auto scanner, scanner_builder->Finish());
   ASSERT_OK_AND_ASSIGN(auto table, scanner->ToTable());
@@ -178,7 +178,8 @@ class GeneratedRecordBatch : public RecordBatchReader {
 template <typename Gen>
 std::unique_ptr<GeneratedRecordBatch<Gen>> MakeGeneratedRecordBatch(
     std::shared_ptr<Schema> schema, Gen&& gen) {
-  return std::make_unique<GeneratedRecordBatch<Gen>>(schema, std::forward<Gen>(gen));
+  return std::make_unique<GeneratedRecordBatch<Gen>>(std::move(schema),
+                                                     std::forward<Gen>(gen));
 }
 
 inline std::unique_ptr<RecordBatchReader> MakeGeneratedRecordBatch(
@@ -186,7 +187,8 @@ inline std::unique_ptr<RecordBatchReader> MakeGeneratedRecordBatch(
   auto batch = random::GenerateBatch(schema->fields(), batch_size, /*seed=*/0);
   int64_t i = 0;
   return MakeGeneratedRecordBatch(
-      schema, [batch, i, batch_repetitions](std::shared_ptr<RecordBatch>* out) mutable {
+      std::move(schema),
+      [batch, i, batch_repetitions](std::shared_ptr<RecordBatch>* out) mutable {
         *out = i++ < batch_repetitions ? batch : nullptr;
         return Status::OK();
       });
@@ -481,7 +483,7 @@ class FileFormatFixtureMixin : public ::testing::Test {
 
   virtual std::shared_ptr<RecordBatchReader> GetRecordBatchReader(
       std::shared_ptr<Schema> schema) {
-    return MakeGeneratedRecordBatch(schema, kBatchSize, kBatchRepetitions);
+    return MakeGeneratedRecordBatch(std::move(schema), kBatchSize, kBatchRepetitions);
   }
 
   Result<std::shared_ptr<io::BufferOutputStream>> GetFileSink() {
@@ -598,7 +600,7 @@ class FileFormatFixtureMixin : public ::testing::Test {
     EXPECT_EQ(supported, true);
   }
   std::shared_ptr<Buffer> WriteToBuffer(
-      std::shared_ptr<Schema> schema,
+      const std::shared_ptr<Schema>& schema,
       std::shared_ptr<FileWriteOptions> options = nullptr) {
     auto format = format_;
     SetSchema(schema->fields());
@@ -678,12 +680,12 @@ class FileFormatScanMixin : public FileFormatFixtureMixin<FormatHelper>,
 
   std::shared_ptr<RecordBatchReader> GetRecordBatchReader(
       std::shared_ptr<Schema> schema) override {
-    return MakeGeneratedRecordBatch(schema, GetParam().items_per_batch,
+    return MakeGeneratedRecordBatch(std::move(schema), GetParam().items_per_batch,
                                     GetParam().num_batches);
   }
 
   // Scan the fragment through the scanner.
-  RecordBatchIterator Batches(std::shared_ptr<Fragment> fragment,
+  RecordBatchIterator Batches(const std::shared_ptr<Fragment>& fragment,
                               bool use_readahead = true) {
     auto dataset = std::make_shared<FragmentDataset>(opts_->dataset_schema,
                                                      FragmentVector{fragment});
@@ -700,7 +702,7 @@ class FileFormatScanMixin : public FileFormatFixtureMixin<FormatHelper>,
   }
 
   // Scan the fragment directly, without using the scanner.
-  RecordBatchIterator PhysicalBatches(std::shared_ptr<Fragment> fragment) {
+  RecordBatchIterator PhysicalBatches(const std::shared_ptr<Fragment>& fragment) {
     opts_->use_threads = GetParam().use_threads;
     EXPECT_OK_AND_ASSIGN(auto batch_gen, fragment->ScanBatchesAsync(opts_));
     auto batch_it = MakeGeneratorIterator(std::move(batch_gen));
@@ -1049,7 +1051,7 @@ class FileFormatFixtureMixinV2 : public ::testing::Test {
 
   virtual std::shared_ptr<RecordBatchReader> GetRandomData(
       std::shared_ptr<Schema> schema) {
-    return MakeGeneratedRecordBatch(schema, kBatchSize, kBatchRepetitions);
+    return MakeGeneratedRecordBatch(std::move(schema), kBatchSize, kBatchRepetitions);
   }
 
   Result<std::shared_ptr<io::BufferOutputStream>> GetFileSink() {
@@ -1170,7 +1172,7 @@ class FileFormatFixtureMixinV2 : public ::testing::Test {
   }
 
   std::shared_ptr<Buffer> WriteToBuffer(
-      std::shared_ptr<Schema> schema,
+      const std::shared_ptr<Schema>& schema,
       std::shared_ptr<FileWriteOptions> options = nullptr) {
     auto format = format_;
     SetDatasetSchema(schema->fields());
@@ -1255,13 +1257,13 @@ class FileFormatScanNodeMixin : public FileFormatFixtureMixinV2<FormatHelper>,
   // of batches and rows per batch
   std::shared_ptr<RecordBatchReader> GetRandomData(
       std::shared_ptr<Schema> schema) override {
-    return MakeGeneratedRecordBatch(schema, GetParam().items_per_batch,
+    return MakeGeneratedRecordBatch(std::move(schema), GetParam().items_per_batch,
                                     GetParam().num_batches);
   }
 
   // Scan the fragment through the scanner.
-  Result<std::unique_ptr<RecordBatchReader>> Scan(std::shared_ptr<Fragment> fragment,
-                                                  bool add_filter_fields = true) {
+  Result<std::unique_ptr<RecordBatchReader>> Scan(
+      const std::shared_ptr<Fragment>& fragment, bool add_filter_fields = true) {
     opts_->dataset =
         std::make_shared<FragmentDataset>(dataset_schema_, FragmentVector{fragment});
     if (add_filter_fields) {
@@ -1774,7 +1776,7 @@ static std::vector<compute::Expression> PartitionExpressionsOf(
 }
 
 inline void AssertFragmentsHavePartitionExpressions(
-    std::shared_ptr<Dataset> dataset, std::vector<compute::Expression> expected) {
+    const std::shared_ptr<Dataset>& dataset, std::vector<compute::Expression> expected) {
   ASSERT_OK_AND_ASSIGN(auto fragment_it, dataset->GetFragments());
   // Ordering is not guaranteed.
   EXPECT_THAT(PartitionExpressionsOf(IteratorToVector(std::move(fragment_it))),
@@ -1933,7 +1935,7 @@ class WriteFileSystemDatasetMixin : public MakeFileSystemDatasetMixin {
   }
 
   void SetWriteOptions(std::shared_ptr<FileWriteOptions> file_write_options) {
-    write_options_.file_write_options = file_write_options;
+    write_options_.file_write_options = std::move(file_write_options);
     write_options_.filesystem = fs_;
     write_options_.base_dir = "/new_root/";
     write_options_.basename_template = "dat_{i}";
@@ -1943,7 +1945,7 @@ class WriteFileSystemDatasetMixin : public MakeFileSystemDatasetMixin {
     };
   }
 
-  void DoWrite(std::shared_ptr<Partitioning> desired_partitioning) {
+  void DoWrite(const std::shared_ptr<Partitioning>& desired_partitioning) {
     write_options_.partitioning = desired_partitioning;
     auto scanner_builder = ScannerBuilder(dataset_, scan_options_);
     ASSERT_OK_AND_ASSIGN(auto scanner, scanner_builder.Finish());
diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc
index d8d77fa800cd..a4fede191384 100644
--- a/cpp/src/arrow/engine/substrait/relation_internal.cc
+++ b/cpp/src/arrow/engine/substrait/relation_internal.cc
@@ -302,7 +302,7 @@ namespace internal {
 Result<compute::Aggregate> ParseAggregateMeasure(
     const substrait::AggregateRel::Measure& agg_measure, const ExtensionSet& ext_set,
     const ConversionOptions& conversion_options, bool is_hash,
-    const std::shared_ptr<Schema> input_schema) {
+    const std::shared_ptr<Schema>& input_schema) {
   if (agg_measure.has_measure()) {
     if (agg_measure.has_filter()) {
       return Status::NotImplemented("Aggregate filters are not supported.");
@@ -326,7 +326,7 @@ Result<compute::Aggregate> ParseAggregateMeasure(
 }
 
 ARROW_ENGINE_EXPORT Result<DeclarationInfo> MakeAggregateDeclaration(
-    acero::Declaration input_decl, std::shared_ptr<Schema> aggregate_schema,
+    acero::Declaration input_decl, const std::shared_ptr<Schema>& aggregate_schema,
     std::vector<compute::Aggregate> aggregates, std::vector<FieldRef> keys,
     std::vector<FieldRef> segment_keys) {
   return DeclarationInfo{
diff --git a/cpp/src/arrow/engine/substrait/relation_internal.h b/cpp/src/arrow/engine/substrait/relation_internal.h
index 2a96d0024e69..54c198a25e53 100644
--- a/cpp/src/arrow/engine/substrait/relation_internal.h
+++ b/cpp/src/arrow/engine/substrait/relation_internal.h
@@ -65,7 +65,7 @@ ARROW_ENGINE_EXPORT
 Result<compute::Aggregate> ParseAggregateMeasure(
     const substrait::AggregateRel::Measure& agg_measure, const ExtensionSet& ext_set,
     const ConversionOptions& conversion_options, bool is_hash,
-    const std::shared_ptr<Schema> input_schema);
+    const std::shared_ptr<Schema>& input_schema);
 
 /// \brief Make an aggregate declaration info
 ///
@@ -75,7 +75,7 @@ Result<compute::Aggregate> ParseAggregateMeasure(
 /// \param[in] keys the field-refs for grouping keys to use
 /// \param[in] segment_keys the field-refs for segment keys to use
 ARROW_ENGINE_EXPORT Result<DeclarationInfo> MakeAggregateDeclaration(
-    acero::Declaration input_decl, std::shared_ptr<Schema> output_schema,
+    acero::Declaration input_decl, const std::shared_ptr<Schema>& output_schema,
     std::vector<compute::Aggregate> aggregates, std::vector<FieldRef> keys,
     std::vector<FieldRef> segment_keys);
 
diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc
index 4de5480ef3cd..0b2928765515 100644
--- a/cpp/src/arrow/engine/substrait/serde_test.cc
+++ b/cpp/src/arrow/engine/substrait/serde_test.cc
@@ -107,7 +107,7 @@ Status AddPassFactory(
 
     PassNode(ExecPlan* plan, std::vector<ExecNode*> inputs,
              std::shared_ptr<Schema> output_schema)
-        : MapNode(plan, inputs, output_schema) {}
+        : MapNode(plan, inputs, std::move(output_schema)) {}
 
     const char* kind_name() const override { return "PassNode"; }
     Result<ExecBatch> ProcessBatch(ExecBatch batch) override { return batch; }
@@ -118,8 +118,8 @@ Status AddPassFactory(
 const auto kNullConsumer = std::make_shared<acero::NullSinkNodeConsumer>();
 
 void WriteIpcData(const std::string& path,
-                  const std::shared_ptr<fs::FileSystem> file_system,
-                  const std::shared_ptr<Table> input) {
+                  const std::shared_ptr<fs::FileSystem>& file_system,
+                  const std::shared_ptr<Table>& input) {
   EXPECT_OK_AND_ASSIGN(auto out_stream, file_system->OpenOutputStream(path));
   ASSERT_OK_AND_ASSIGN(
       auto file_writer,
@@ -128,7 +128,7 @@ void WriteIpcData(const std::string& path,
   ASSERT_OK(file_writer->Close());
 }
 
-void CheckRoundTripResult(const std::shared_ptr<Table> expected_table,
+void CheckRoundTripResult(const std::shared_ptr<Table>& expected_table,
                           std::shared_ptr<Buffer>& buf,
                           const std::vector<int>& include_columns = {},
                           const ConversionOptions& conversion_options = {},
diff --git a/cpp/src/arrow/extension/parquet_variant.cc b/cpp/src/arrow/extension/parquet_variant.cc
index 95aa5a0eb68e..47fab07e13bb 100644
--- a/cpp/src/arrow/extension/parquet_variant.cc
+++ b/cpp/src/arrow/extension/parquet_variant.cc
@@ -63,7 +63,7 @@ std::shared_ptr<Array> VariantExtensionType::MakeArray(
 }
 
 namespace {
-bool IsBinaryField(const std::shared_ptr<Field> field) {
+bool IsBinaryField(const std::shared_ptr<Field>& field) {
   return field->type()->storage_id() == Type::BINARY ||
          field->type()->storage_id() == Type::LARGE_BINARY;
 }
diff --git a/cpp/src/arrow/extension/tensor_extension_array_test.cc b/cpp/src/arrow/extension/tensor_extension_array_test.cc
index 29147df6ba6a..823bb58b6151 100644
--- a/cpp/src/arrow/extension/tensor_extension_array_test.cc
+++ b/cpp/src/arrow/extension/tensor_extension_array_test.cc
@@ -386,7 +386,8 @@ TEST_F(TestFixedShapeTensorType, CreateFromTensor) {
 
 void CheckFromTensorType(const std::shared_ptr<Tensor>& tensor,
                          std::shared_ptr<DataType> expected_ext_type) {
-  auto ext_type = internal::checked_pointer_cast<FixedShapeTensorType>(expected_ext_type);
+  auto ext_type =
+      internal::checked_pointer_cast<FixedShapeTensorType>(std::move(expected_ext_type));
   ASSERT_OK_AND_ASSIGN(auto ext_arr, FixedShapeTensorArray::FromTensor(tensor));
   auto generated_ext_type =
       internal::checked_cast<const FixedShapeTensorType*>(ext_arr->extension_type());
@@ -426,7 +427,7 @@ TEST_F(TestFixedShapeTensorType, TestFromTensorType) {
 }
 
 template <typename T>
-void CheckToTensor(const std::vector<T>& values, const std::shared_ptr<DataType> typ,
+void CheckToTensor(const std::vector<T>& values, const std::shared_ptr<DataType>& typ,
                    const int32_t& element_size, const std::vector<int64_t>& element_shape,
                    const std::vector<int64_t>& element_permutation,
                    const std::vector<std::string>& element_dim_names,
diff --git a/cpp/src/arrow/extension_type.cc b/cpp/src/arrow/extension_type.cc
index ce88c9517411..605125d0efdf 100644
--- a/cpp/src/arrow/extension_type.cc
+++ b/cpp/src/arrow/extension_type.cc
@@ -174,7 +174,7 @@ std::shared_ptr<ExtensionTypeRegistry> ExtensionTypeRegistry::GetGlobalRegistry(
 
 Status RegisterExtensionType(std::shared_ptr<ExtensionType> type) {
   auto registry = ExtensionTypeRegistry::GetGlobalRegistry();
-  return registry->RegisterType(type);
+  return registry->RegisterType(std::move(type));
 }
 
 Status UnregisterExtensionType(const std::string& type_name) {
diff --git a/cpp/src/arrow/extension_type_test.cc b/cpp/src/arrow/extension_type_test.cc
index 0b256f1b45b4..551b0eaf053d 100644
--- a/cpp/src/arrow/extension_type_test.cc
+++ b/cpp/src/arrow/extension_type_test.cc
@@ -263,7 +263,7 @@ std::shared_ptr<Array> ExampleParametric(std::shared_ptr<DataType> type,
                                          const std::string& json_data) {
   auto arr = ArrayFromJSON(int32(), json_data);
   auto ext_data = arr->data()->Copy();
-  ext_data->type = type;
+  ext_data->type = std::move(type);
   return MakeArray(ext_data);
 }
 
diff --git a/cpp/src/arrow/filesystem/azurefs.cc b/cpp/src/arrow/filesystem/azurefs.cc
index 20b0a655d8e2..7c2640ad52a7 100644
--- a/cpp/src/arrow/filesystem/azurefs.cc
+++ b/cpp/src/arrow/filesystem/azurefs.cc
@@ -965,7 +965,7 @@ Status CreateEmptyBlockBlob(const Blobs::BlockBlobClient& block_blob_client) {
 }
 
 Result<Blobs::Models::GetBlockListResult> GetBlockList(
-    std::shared_ptr<Blobs::BlockBlobClient> block_blob_client) {
+    const std::shared_ptr<Blobs::BlockBlobClient>& block_blob_client) {
   try {
     return block_blob_client->GetBlockList().Value;
   } catch (Core::RequestFailedException& exception) {
@@ -975,9 +975,10 @@ Result<Blobs::Models::GetBlockListResult> GetBlockList(
   }
 }
 
-Status CommitBlockList(std::shared_ptr<Storage::Blobs::BlockBlobClient> block_blob_client,
-                       const std::vector<std::string>& block_ids,
-                       const Blobs::CommitBlockListOptions& options) {
+Status CommitBlockList(
+    const std::shared_ptr<Storage::Blobs::BlockBlobClient>& block_blob_client,
+    const std::vector<std::string>& block_ids,
+    const Blobs::CommitBlockListOptions& options) {
   try {
     // CommitBlockList puts all block_ids in the latest element. That means in the case
     // of overlapping block_ids the newly staged block ids will always replace the
@@ -1230,7 +1231,7 @@ class ObjectAppendStream final : public io::OutputStream {
   }
 
   Status DoWrite(const void* data, int64_t nbytes,
-                 std::shared_ptr<Buffer> owned_buffer = nullptr) {
+                 const std::shared_ptr<Buffer>& owned_buffer = nullptr) {
     if (closed_) {
       return Status::Invalid("Operation on closed stream");
     }
@@ -1363,7 +1364,7 @@ class ObjectAppendStream final : public io::OutputStream {
     return Status::OK();
   }
 
-  Status AppendBlock(std::shared_ptr<Buffer> buffer) {
+  Status AppendBlock(const std::shared_ptr<Buffer>& buffer) {
     return AppendBlock(buffer->data(), buffer->size(), buffer);
   }
 
diff --git a/cpp/src/arrow/filesystem/azurefs_test.cc b/cpp/src/arrow/filesystem/azurefs_test.cc
index 250e3572bd9b..dc793d63871f 100644
--- a/cpp/src/arrow/filesystem/azurefs_test.cc
+++ b/cpp/src/arrow/filesystem/azurefs_test.cc
@@ -2937,7 +2937,7 @@ TEST_F(TestAzuriteFileSystem, OpenInputStreamTrailingSlash) {
 
 namespace {
 std::shared_ptr<const KeyValueMetadata> NormalizerKeyValueMetadata(
-    std::shared_ptr<const KeyValueMetadata> metadata) {
+    const std::shared_ptr<const KeyValueMetadata>& metadata) {
   auto normalized = std::make_shared<KeyValueMetadata>();
   for (int64_t i = 0; i < metadata->size(); ++i) {
     auto key = metadata->key(i);
diff --git a/cpp/src/arrow/filesystem/filesystem.cc b/cpp/src/arrow/filesystem/filesystem.cc
index f92336e004ea..be6a8bef95bd 100644
--- a/cpp/src/arrow/filesystem/filesystem.cc
+++ b/cpp/src/arrow/filesystem/filesystem.cc
@@ -290,7 +290,7 @@ SubTreeFileSystem::SubTreeFileSystem(const std::string& base_path,
                                      std::shared_ptr<FileSystem> base_fs)
     : FileSystem(base_fs->io_context()),
       base_path_(NormalizeBasePath(base_path, base_fs).ValueOrDie()),
-      base_fs_(base_fs) {}
+      base_fs_(std::move(base_fs)) {}
 
 SubTreeFileSystem::~SubTreeFileSystem() = default;
 
@@ -518,13 +518,13 @@ SlowFileSystem::SlowFileSystem(std::shared_ptr<FileSystem> base_fs,
 SlowFileSystem::SlowFileSystem(std::shared_ptr<FileSystem> base_fs,
                                double average_latency)
     : FileSystem(base_fs->io_context()),
-      base_fs_(base_fs),
+      base_fs_(std::move(base_fs)),
       latencies_(io::LatencyGenerator::Make(average_latency)) {}
 
 SlowFileSystem::SlowFileSystem(std::shared_ptr<FileSystem> base_fs,
                                double average_latency, int32_t seed)
     : FileSystem(base_fs->io_context()),
-      base_fs_(base_fs),
+      base_fs_(std::move(base_fs)),
       latencies_(io::LatencyGenerator::Make(average_latency, seed)) {}
 
 bool SlowFileSystem::Equals(const FileSystem& other) const { return this == &other; }
diff --git a/cpp/src/arrow/filesystem/gcsfs_test.cc b/cpp/src/arrow/filesystem/gcsfs_test.cc
index e174638b5359..10b6e201c425 100644
--- a/cpp/src/arrow/filesystem/gcsfs_test.cc
+++ b/cpp/src/arrow/filesystem/gcsfs_test.cc
@@ -212,7 +212,7 @@ class GcsIntegrationTest : public ::testing::Test {
     std::vector<FileInfo> contents;
   };
 
-  Result<Hierarchy> CreateHierarchy(std::shared_ptr<arrow::fs::FileSystem> fs) {
+  Result<Hierarchy> CreateHierarchy(const std::shared_ptr<arrow::fs::FileSystem>& fs) {
     const char* const kTestFolders[] = {
         "b",
         "b/0",
diff --git a/cpp/src/arrow/filesystem/localfs.cc b/cpp/src/arrow/filesystem/localfs.cc
index 4060d83a5fac..e6020c32ecd7 100644
--- a/cpp/src/arrow/filesystem/localfs.cc
+++ b/cpp/src/arrow/filesystem/localfs.cc
@@ -520,7 +520,7 @@ class AsyncStatSelector {
   /// the producer is closed automatically.
   static Status DoDiscovery(const PlatformFilename& dir_fn, int32_t nesting_depth,
                             FileSelector selector,
-                            std::shared_ptr<DiscoveryState> discovery_state,
+                            const std::shared_ptr<DiscoveryState>& discovery_state,
                             const io::IOContext& io_context,
                             int32_t file_info_batch_size) {
     ARROW_RETURN_IF(discovery_state->producer.is_closed(),
diff --git a/cpp/src/arrow/filesystem/localfs_test.cc b/cpp/src/arrow/filesystem/localfs_test.cc
index 212d91989659..27faaead5ea0 100644
--- a/cpp/src/arrow/filesystem/localfs_test.cc
+++ b/cpp/src/arrow/filesystem/localfs_test.cc
@@ -95,7 +95,7 @@ class SlowFileSystemPublicProps : public SlowFileSystem {
  public:
   SlowFileSystemPublicProps(std::shared_ptr<FileSystem> base_fs, double average_latency,
                             int32_t seed)
-      : SlowFileSystem(base_fs, average_latency, seed),
+      : SlowFileSystem(std::move(base_fs), average_latency, seed),
         average_latency{average_latency},
         seed{seed} {}
   double average_latency;
diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc
index 1c6763a4aee9..11e10290a97d 100644
--- a/cpp/src/arrow/filesystem/s3fs.cc
+++ b/cpp/src/arrow/filesystem/s3fs.cc
@@ -1887,7 +1887,7 @@ class ObjectOutputStream final : public io::OutputStream {
   }
 
   Status DoWrite(const void* data, int64_t nbytes,
-                 std::shared_ptr<Buffer> owned_buffer = nullptr) {
+                 const std::shared_ptr<Buffer>& owned_buffer = nullptr) {
     if (closed_) {
       return Status::Invalid("Operation on closed stream");
     }
@@ -2065,7 +2065,7 @@ class ObjectOutputStream final : public io::OutputStream {
         "PutObject", outcome.GetError());
   }
 
-  Status UploadUsingSingleRequest(std::shared_ptr<Buffer> buffer) {
+  Status UploadUsingSingleRequest(const std::shared_ptr<Buffer>& buffer) {
     return UploadUsingSingleRequest(buffer->data(), buffer->size(), buffer);
   }
 
@@ -2097,7 +2097,7 @@ class ObjectOutputStream final : public io::OutputStream {
         data, nbytes, std::move(owned_buffer));
   }
 
-  Status UploadPart(std::shared_ptr<Buffer> buffer) {
+  Status UploadPart(const std::shared_ptr<Buffer>& buffer) {
     return UploadPart(buffer->data(), buffer->size(), buffer);
   }
 
diff --git a/cpp/src/arrow/flight/client.cc b/cpp/src/arrow/flight/client.cc
index e33b6c3fd071..67bc8f70b8fd 100644
--- a/cpp/src/arrow/flight/client.cc
+++ b/cpp/src/arrow/flight/client.cc
@@ -130,7 +130,7 @@ class IpcMessageReader : public ipc::MessageReader {
                    std::shared_ptr<MemoryManager> memory_manager,
                    std::shared_ptr<Buffer>* app_metadata)
       : stream_(std::move(stream)),
-        peekable_reader_(peekable_reader),
+        peekable_reader_(std::move(peekable_reader)),
         memory_manager_(memory_manager ? std::move(memory_manager)
                                        : CPUDevice::Instance()->default_memory_manager()),
         app_metadata_(app_metadata),
@@ -463,7 +463,7 @@ class ClientStreamWriter : public FlightStreamWriter {
 
   Status WriteMetadata(std::shared_ptr<Buffer> app_metadata) override {
     FlightPayload payload;
-    payload.app_metadata = app_metadata;
+    payload.app_metadata = std::move(app_metadata);
     ARROW_ASSIGN_OR_RAISE(auto success, stream_->WriteData(payload));
     if (!success) {
       return Close();
@@ -474,7 +474,7 @@ class ClientStreamWriter : public FlightStreamWriter {
   Status WriteWithMetadata(const RecordBatch& batch,
                            std::shared_ptr<Buffer> app_metadata) override {
     RETURN_NOT_OK(CheckStarted());
-    app_metadata_ = app_metadata;
+    app_metadata_ = std::move(app_metadata);
     auto status = batch_writer_->WriteRecordBatch(batch);
     if (!status.ok() &&
         // Only want to Close() if server error, not for client error
diff --git a/cpp/src/arrow/flight/server.cc b/cpp/src/arrow/flight/server.cc
index 7807829b3b3b..332fd20742c0 100644
--- a/cpp/src/arrow/flight/server.cc
+++ b/cpp/src/arrow/flight/server.cc
@@ -120,7 +120,7 @@ struct FlightServerBase::Impl {
     self_pipe_->Send(/*payload=*/0);
   }
 
-  static void WaitForSignals(std::shared_ptr<SelfPipe> self_pipe) {
+  static void WaitForSignals(const std::shared_ptr<SelfPipe>& self_pipe) {
     // Wait for a signal handler to wake up the pipe
     auto st = self_pipe->Wait().status();
     // Status::Invalid means the pipe was shutdown without any wakeup
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
index f1a5dcd68635..c8c0426924c7 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
@@ -220,7 +220,7 @@ class GrpcClientAuthSender : public ClientAuthSender {
       std::shared_ptr<
           ::grpc::ClientReaderWriter<pb::HandshakeRequest, pb::HandshakeResponse>>
           stream)
-      : stream_(stream) {}
+      : stream_(std::move(stream)) {}
 
   Status Write(const std::string& token) override {
     pb::HandshakeRequest response;
@@ -242,7 +242,7 @@ class GrpcClientAuthReader : public ClientAuthReader {
       std::shared_ptr<
           ::grpc::ClientReaderWriter<pb::HandshakeRequest, pb::HandshakeResponse>>
           stream)
-      : stream_(stream) {}
+      : stream_(std::move(stream)) {}
 
   Status Read(std::string* token) override {
     pb::HandshakeResponse request;
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
index 03f22f8864d4..ed44f225d8ad 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
@@ -248,7 +248,7 @@ class GrpcServiceHandler final : public FlightService::Service {
       std::vector<std::pair<std::string, std::shared_ptr<ServerMiddlewareFactory>>>
           middleware,
       internal::ServerTransport* impl)
-      : auth_handler_(auth_handler), middleware_(middleware), impl_(impl) {}
+      : auth_handler_(std::move(auth_handler)), middleware_(middleware), impl_(impl) {}
 
   template <typename UserType, typename Iterator, typename ProtoType>
   ::grpc::Status WriteStream(Iterator* iterator, ServerWriter<ProtoType>* writer) {
diff --git a/cpp/src/arrow/flight/transport_server.cc b/cpp/src/arrow/flight/transport_server.cc
index 197def7cabdc..5ba802f76990 100644
--- a/cpp/src/arrow/flight/transport_server.cc
+++ b/cpp/src/arrow/flight/transport_server.cc
@@ -43,7 +43,7 @@ class TransportIpcMessageReader : public ipc::MessageReader {
       std::shared_ptr<internal::PeekableFlightDataReader> peekable_reader,
       std::shared_ptr<MemoryManager> memory_manager,
       std::shared_ptr<Buffer>* app_metadata)
-      : peekable_reader_(peekable_reader),
+      : peekable_reader_(std::move(peekable_reader)),
         memory_manager_(std::move(memory_manager)),
         app_metadata_(app_metadata) {}
 
@@ -233,7 +233,7 @@ class TransportMessageWriter final : public FlightMessageWriter {
 
   Status WriteMetadata(std::shared_ptr<Buffer> app_metadata) override {
     FlightPayload payload{};
-    payload.app_metadata = app_metadata;
+    payload.app_metadata = std::move(app_metadata);
     ARROW_ASSIGN_OR_RAISE(auto success, stream_->WriteData(payload));
     if (!success) {
       ARROW_RETURN_NOT_OK(Close());
@@ -246,7 +246,7 @@ class TransportMessageWriter final : public FlightMessageWriter {
   Status WriteWithMetadata(const RecordBatch& batch,
                            std::shared_ptr<Buffer> app_metadata) override {
     RETURN_NOT_OK(CheckStarted());
-    app_metadata_ = app_metadata;
+    app_metadata_ = std::move(app_metadata);
     auto status = batch_writer_->WriteRecordBatch(batch);
     if (!status.ok()) {
       ARROW_RETURN_NOT_OK(Close());
diff --git a/cpp/src/arrow/gpu/cuda_test.cc b/cpp/src/arrow/gpu/cuda_test.cc
index 2e12cf68d5b9..49f787351e3c 100644
--- a/cpp/src/arrow/gpu/cuda_test.cc
+++ b/cpp/src/arrow/gpu/cuda_test.cc
@@ -764,7 +764,8 @@ class TestCudaDeviceArrayRoundtrip : public ::testing::Test {
  public:
   using ArrayFactory = std::function<Result<std::shared_ptr<Array>>()>;
 
-  static ArrayFactory JSONArrayFactory(std::shared_ptr<DataType> type, const char* json) {
+  static ArrayFactory JSONArrayFactory(const std::shared_ptr<DataType>& type,
+                                       const char* json) {
     return [=]() { return ArrayFromJSON(type, json); };
   }
 
@@ -833,7 +834,7 @@ class TestCudaDeviceArrayRoundtrip : public ::testing::Test {
     }
   }
 
-  void TestWithJSON(std::shared_ptr<DataType> type, const char* json) {
+  void TestWithJSON(const std::shared_ptr<DataType>& type, const char* json) {
     TestWithArrayFactory(JSONArrayFactory(type, json));
   }
 };
diff --git a/cpp/src/arrow/io/compressed_test.cc b/cpp/src/arrow/io/compressed_test.cc
index 7724c65e9dd6..d485fece65f4 100644
--- a/cpp/src/arrow/io/compressed_test.cc
+++ b/cpp/src/arrow/io/compressed_test.cc
@@ -80,7 +80,7 @@ std::shared_ptr<Buffer> CompressDataOneShot(Codec* codec,
   return compressed;
 }
 
-Status RunCompressedInputStream(Codec* codec, std::shared_ptr<Buffer> compressed,
+Status RunCompressedInputStream(Codec* codec, const std::shared_ptr<Buffer>& compressed,
                                 int64_t* stream_pos, std::vector<uint8_t>* out) {
   // Create compressed input stream
   auto buffer_reader = std::make_shared<BufferReader>(compressed);
@@ -106,7 +106,7 @@ Status RunCompressedInputStream(Codec* codec, std::shared_ptr<Buffer> compressed
   return Status::OK();
 }
 
-Status RunCompressedInputStream(Codec* codec, std::shared_ptr<Buffer> compressed,
+Status RunCompressedInputStream(Codec* codec, const std::shared_ptr<Buffer>& compressed,
                                 std::vector<uint8_t>* out) {
   return RunCompressedInputStream(codec, compressed, nullptr, out);
 }
diff --git a/cpp/src/arrow/io/file.cc b/cpp/src/arrow/io/file.cc
index ed2c8c9a246f..ae07c7e94d5f 100644
--- a/cpp/src/arrow/io/file.cc
+++ b/cpp/src/arrow/io/file.cc
@@ -400,7 +400,7 @@ class MemoryMappedFile::MemoryMap
   // will then keep the original region alive as long as necessary.
   class Region : public Buffer {
    public:
-    Region(std::shared_ptr<MemoryMappedFile::MemoryMap> memory_map, uint8_t* data,
+    Region(const std::shared_ptr<MemoryMappedFile::MemoryMap>& memory_map, uint8_t* data,
            int64_t size)
         : Buffer(data, size) {
       is_mutable_ = memory_map->writable();
diff --git a/cpp/src/arrow/ipc/feather_test.cc b/cpp/src/arrow/ipc/feather_test.cc
index a9d701422f69..2b12354436c0 100644
--- a/cpp/src/arrow/ipc/feather_test.cc
+++ b/cpp/src/arrow/ipc/feather_test.cc
@@ -95,7 +95,7 @@ class TestFeatherBase {
     }
   }
 
-  void CheckSlices(std::shared_ptr<RecordBatch> batch) {
+  void CheckSlices(const std::shared_ptr<RecordBatch>& batch) {
     std::vector<int> starts = {0, 1, 300, 301, 302, 303, 304, 305, 306, 307};
     std::vector<int> sizes = {0, 1, 7, 8, 30, 32, 100};
     for (auto start : starts) {
@@ -105,7 +105,7 @@ class TestFeatherBase {
     }
   }
 
-  void CheckRoundtrip(std::shared_ptr<RecordBatch> batch) {
+  void CheckRoundtrip(const std::shared_ptr<RecordBatch>& batch) {
     std::vector<std::shared_ptr<RecordBatch>> batches = {batch};
     ASSERT_OK_AND_ASSIGN(auto table, Table::FromRecordBatches(batches));
 
diff --git a/cpp/src/arrow/ipc/message.cc b/cpp/src/arrow/ipc/message.cc
index 4123a6b17355..1fc595fa12a9 100644
--- a/cpp/src/arrow/ipc/message.cc
+++ b/cpp/src/arrow/ipc/message.cc
@@ -335,7 +335,7 @@ struct ReadMessageState {
 // A common continuation callback for ReadMessage and ReadMessageAsync overloads
 static Result<std::unique_ptr<Message>> ReadMessageContinued(
     int64_t offset, int32_t metadata_length, std::optional<int64_t> body_length,
-    std::shared_ptr<Buffer> metadata, io::RandomAccessFile* file,
+    const std::shared_ptr<Buffer>& metadata, io::RandomAccessFile* file,
     const FieldsLoaderFunction& fields_loader, ReadMessageState* state) {
   MessageDecoder* decoder = state->decoder.get();
   if (body_length.has_value()) {
diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index cfa6a541d5cc..5f4455457d92 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -1004,7 +1004,7 @@ TEST_F(TestWriteRecordBatch, RoundtripPreservesBufferSizes) {
 }
 
 void TestGetRecordBatchSize(const IpcWriteOptions& options,
-                            std::shared_ptr<RecordBatch> batch) {
+                            const std::shared_ptr<RecordBatch>& batch) {
   io::MockOutputStream mock;
   ipc::IpcPayload payload;
   int32_t mock_metadata_length = -1;
@@ -2178,7 +2178,7 @@ TEST(TestRecordBatchStreamReader, EmptyStreamWithDictionaries) {
 // Delimit IPC stream messages and reassemble with the indicated messages
 // included. This way we can remove messages from an IPC stream to test
 // different failure modes or other difficult-to-test behaviors
-void SpliceMessages(std::shared_ptr<Buffer> stream,
+void SpliceMessages(const std::shared_ptr<Buffer>& stream,
                     const std::vector<int>& included_indices,
                     std::shared_ptr<Buffer>* spliced_stream) {
   ASSERT_OK_AND_ASSIGN(auto out, io::BufferOutputStream::Create(0));
@@ -2780,7 +2780,7 @@ class TestDictionaryReplacement : public ::testing::Test {
   }
 
   // Make one-column batch
-  std::shared_ptr<RecordBatch> MakeBatch(std::shared_ptr<Array> column) {
+  std::shared_ptr<RecordBatch> MakeBatch(const std::shared_ptr<Array>& column) {
     return RecordBatch::Make(schema({field("f", column->type())}), column->length(),
                              {column});
   }
diff --git a/cpp/src/arrow/json/chunker_test.cc b/cpp/src/arrow/json/chunker_test.cc
index 0976e9ba22be..8791ec0b61e5 100644
--- a/cpp/src/arrow/json/chunker_test.cc
+++ b/cpp/src/arrow/json/chunker_test.cc
@@ -118,7 +118,7 @@ void AssertChunking(Chunker& chunker, std::shared_ptr<Buffer> buf, int total_cou
   }
 }
 
-void AssertChunkingBlockSize(Chunker& chunker, std::shared_ptr<Buffer> buf,
+void AssertChunkingBlockSize(Chunker& chunker, const std::shared_ptr<Buffer>& buf,
                              int64_t block_size, int expected_count) {
   std::shared_ptr<Buffer> partial = Buffer::FromString({});
   int64_t pos = 0;
diff --git a/cpp/src/arrow/json/converter.cc b/cpp/src/arrow/json/converter.cc
index 53abfe4888d8..e49e9c467f30 100644
--- a/cpp/src/arrow/json/converter.cc
+++ b/cpp/src/arrow/json/converter.cc
@@ -75,7 +75,7 @@ Status VisitDictionaryEntries(const DictionaryArray& dict_array,
 // base class for types which accept and output non-nested types
 class PrimitiveConverter : public Converter {
  public:
-  PrimitiveConverter(MemoryPool* pool, std::shared_ptr<DataType> out_type)
+  PrimitiveConverter(MemoryPool* pool, const std::shared_ptr<DataType>& out_type)
       : Converter(pool, out_type) {}
 };
 
diff --git a/cpp/src/arrow/json/converter_test.cc b/cpp/src/arrow/json/converter_test.cc
index fa85e704bc5e..1d6e34efe30c 100644
--- a/cpp/src/arrow/json/converter_test.cc
+++ b/cpp/src/arrow/json/converter_test.cc
@@ -28,8 +28,8 @@
 namespace arrow {
 namespace json {
 
-Result<std::shared_ptr<Array>> Convert(std::shared_ptr<DataType> type,
-                                       std::shared_ptr<Array> unconverted) {
+Result<std::shared_ptr<Array>> Convert(const std::shared_ptr<DataType>& type,
+                                       const std::shared_ptr<Array>& unconverted) {
   std::shared_ptr<Array> converted;
   // convert the array
   std::shared_ptr<Converter> converter;
diff --git a/cpp/src/arrow/json/from_string_test.cc b/cpp/src/arrow/json/from_string_test.cc
index 817cfe52ee72..00b9f596c994 100644
--- a/cpp/src/arrow/json/from_string_test.cc
+++ b/cpp/src/arrow/json/from_string_test.cc
@@ -570,7 +570,7 @@ TEST(TestFixedSizeBinaryFromString, Dictionary) {
 }
 
 template <typename DecimalValue, typename DecimalBuilder>
-void TestDecimalBasic(std::shared_ptr<DataType> type) {
+void TestDecimalBasic(const std::shared_ptr<DataType>& type) {
   std::shared_ptr<Array> expected, actual;
 
   ASSERT_OK_AND_ASSIGN(actual, ArrayFromJSONString(type, "[]"));
diff --git a/cpp/src/arrow/json/reader.cc b/cpp/src/arrow/json/reader.cc
index 5c06e726b992..f6b7683c445a 100644
--- a/cpp/src/arrow/json/reader.cc
+++ b/cpp/src/arrow/json/reader.cc
@@ -246,8 +246,8 @@ class TableReaderImpl : public TableReader,
         task_group_(std::move(task_group)) {}
 
   Status Init(std::shared_ptr<io::InputStream> input) {
-    ARROW_ASSIGN_OR_RAISE(auto it,
-                          io::MakeInputStreamIterator(input, read_options_.block_size));
+    ARROW_ASSIGN_OR_RAISE(
+        auto it, io::MakeInputStreamIterator(std::move(input), read_options_.block_size));
     return MakeReadaheadIterator(std::move(it), task_group_->parallelism())
         .Value(&buffer_iterator_);
   }
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
index 22cffae05cb1..a17adf8a41de 100644
--- a/cpp/src/arrow/scalar.cc
+++ b/cpp/src/arrow/scalar.cc
@@ -1091,7 +1091,7 @@ std::shared_ptr<Buffer> FormatToBuffer(Formatter&& formatter, const ScalarType&
 // error fallback
 template <typename To>
 Result<std::shared_ptr<Scalar>> CastImpl(const Scalar& from,
-                                         std::shared_ptr<DataType> to_type) {
+                                         const std::shared_ptr<DataType>& to_type) {
   return Status::NotImplemented("casting scalars of type ", *from.type, " to type ",
                                 *to_type);
 }
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index 3e79d25d629c..22e447186168 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -468,7 +468,7 @@ struct TemporalScalar : internal::PrimitiveScalar<T> {
   using ValueType = typename internal::PrimitiveScalar<T>::ValueType;
 
   TemporalScalar(ValueType value, std::shared_ptr<DataType> type)
-      : internal::PrimitiveScalar<T>(std::move(value), type) {}
+      : internal::PrimitiveScalar<T>(std::move(value), std::move(type)) {}
 };
 
 template <typename T>
diff --git a/cpp/src/arrow/sparse_tensor.cc b/cpp/src/arrow/sparse_tensor.cc
index c23612e25306..e0141762c381 100644
--- a/cpp/src/arrow/sparse_tensor.cc
+++ b/cpp/src/arrow/sparse_tensor.cc
@@ -268,7 +268,8 @@ Result<std::shared_ptr<SparseCOOIndex>> SparseCOOIndex::Make(
       internal::checked_cast<const IntegerType&>(*indices_type).bit_width() / 8;
   std::vector<int64_t> indices_shape({non_zero_length, ndim});
   std::vector<int64_t> indices_strides({elsize * ndim, elsize});
-  return Make(indices_type, indices_shape, indices_strides, indices_data, is_canonical);
+  return Make(indices_type, indices_shape, indices_strides, std::move(indices_data),
+              is_canonical);
 }
 
 Result<std::shared_ptr<SparseCOOIndex>> SparseCOOIndex::Make(
@@ -281,7 +282,7 @@ Result<std::shared_ptr<SparseCOOIndex>> SparseCOOIndex::Make(
   const int64_t elsize = indices_type->byte_width();
   std::vector<int64_t> indices_shape({non_zero_length, ndim});
   std::vector<int64_t> indices_strides({elsize * ndim, elsize});
-  return Make(indices_type, indices_shape, indices_strides, indices_data);
+  return Make(indices_type, indices_shape, indices_strides, std::move(indices_data));
 }
 
 // Constructor with a contiguous NumericTensor
diff --git a/cpp/src/arrow/sparse_tensor.h b/cpp/src/arrow/sparse_tensor.h
index a41024b74160..8496dc79f09f 100644
--- a/cpp/src/arrow/sparse_tensor.h
+++ b/cpp/src/arrow/sparse_tensor.h
@@ -245,8 +245,8 @@ class SparseCSXIndex : public SparseIndexBase<SparseIndexType> {
       const std::shared_ptr<DataType>& indices_type,
       const std::vector<int64_t>& indptr_shape, const std::vector<int64_t>& indices_shape,
       std::shared_ptr<Buffer> indptr_data, std::shared_ptr<Buffer> indices_data) {
-    return Make(indices_type, indices_type, indptr_shape, indices_shape, indptr_data,
-                indices_data);
+    return Make(indices_type, indices_type, indptr_shape, indices_shape,
+                std::move(indptr_data), std::move(indices_data));
   }
 
   /// \brief Make a subclass of SparseCSXIndex from sparse tensor's shape properties and
@@ -260,8 +260,8 @@ class SparseCSXIndex : public SparseIndexBase<SparseIndexType> {
                           ComputeSparseCSXIndptrLength(COMPRESSED_AXIS, shape));
     std::vector<int64_t> indptr_shape({indptr_length});
     std::vector<int64_t> indices_shape({non_zero_length});
-    return Make(indptr_type, indices_type, indptr_shape, indices_shape, indptr_data,
-                indices_data);
+    return Make(indptr_type, indices_type, indptr_shape, indices_shape,
+                std::move(indptr_data), std::move(indices_data));
   }
 
   /// \brief Make a subclass of SparseCSXIndex from sparse tensor's shape properties and
@@ -270,8 +270,8 @@ class SparseCSXIndex : public SparseIndexBase<SparseIndexType> {
       const std::shared_ptr<DataType>& indices_type, const std::vector<int64_t>& shape,
       int64_t non_zero_length, std::shared_ptr<Buffer> indptr_data,
       std::shared_ptr<Buffer> indices_data) {
-    return Make(indices_type, indices_type, shape, non_zero_length, indptr_data,
-                indices_data);
+    return Make(indices_type, indices_type, shape, non_zero_length,
+                std::move(indptr_data), std::move(indices_data));
   }
 
   /// \brief Construct SparseCSXIndex from two index vectors
diff --git a/cpp/src/arrow/testing/random.cc b/cpp/src/arrow/testing/random.cc
index ce73b3f37419..b93aef0c16b3 100644
--- a/cpp/src/arrow/testing/random.cc
+++ b/cpp/src/arrow/testing/random.cc
@@ -432,7 +432,7 @@ std::shared_ptr<Array> RandomArrayGenerator::Decimal32(std::shared_ptr<DataType>
                                                        double null_probability,
                                                        int64_t alignment,
                                                        MemoryPool* memory_pool) {
-  SmallDecimalGenerator<Decimal32Type> gen{type, this};
+  SmallDecimalGenerator<Decimal32Type> gen{std::move(type), this};
   return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
 }
 
@@ -441,7 +441,7 @@ std::shared_ptr<Array> RandomArrayGenerator::Decimal64(std::shared_ptr<DataType>
                                                        double null_probability,
                                                        int64_t alignment,
                                                        MemoryPool* memory_pool) {
-  SmallDecimalGenerator<Decimal64Type> gen{type, this};
+  SmallDecimalGenerator<Decimal64Type> gen{std::move(type), this};
   return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
 }
 
@@ -450,7 +450,7 @@ std::shared_ptr<Array> RandomArrayGenerator::Decimal128(std::shared_ptr<DataType
                                                         double null_probability,
                                                         int64_t alignment,
                                                         MemoryPool* memory_pool) {
-  DecimalGenerator<Decimal128Type> gen{type, this};
+  DecimalGenerator<Decimal128Type> gen{std::move(type), this};
   return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
 }
 
@@ -459,7 +459,7 @@ std::shared_ptr<Array> RandomArrayGenerator::Decimal256(std::shared_ptr<DataType
                                                         double null_probability,
                                                         int64_t alignment,
                                                         MemoryPool* memory_pool) {
-  DecimalGenerator<Decimal256Type> gen{type, this};
+  DecimalGenerator<Decimal256Type> gen{std::move(type), this};
   return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
 }
 
diff --git a/cpp/src/arrow/testing/random_test.cc b/cpp/src/arrow/testing/random_test.cc
index 279fb6dc91fa..d655079c472d 100644
--- a/cpp/src/arrow/testing/random_test.cc
+++ b/cpp/src/arrow/testing/random_test.cc
@@ -226,7 +226,7 @@ class RandomNumericArrayTest : public ::testing::Test {
   std::shared_ptr<Field> GetField() { return field("field0", std::make_shared<T>()); }
 
   std::shared_ptr<NumericArray<T>> Downcast(std::shared_ptr<Array> array) {
-    return internal::checked_pointer_cast<NumericArray<T>>(array);
+    return internal::checked_pointer_cast<NumericArray<T>>(std::move(array));
   }
 };
 
diff --git a/cpp/src/arrow/util/cancel.cc b/cpp/src/arrow/util/cancel.cc
index a83475fed0b8..9c2781be8f30 100644
--- a/cpp/src/arrow/util/cancel.cc
+++ b/cpp/src/arrow/util/cancel.cc
@@ -239,7 +239,7 @@ struct SignalStopState : public std::enable_shared_from_this<SignalStopState> {
     ReinstateSignalHandler(signum, &HandleSignal);
   }
 
-  static void ReceiveSignals(std::shared_ptr<SelfPipe> self_pipe) {
+  static void ReceiveSignals(const std::shared_ptr<SelfPipe>& self_pipe) {
     // Wait for signals on the self-pipe and propagate them to the current StopSource
     DCHECK(self_pipe);
     while (true) {
diff --git a/cpp/src/arrow/util/compression_test.cc b/cpp/src/arrow/util/compression_test.cc
index 5ba93cc291df..9785d2c3f87e 100644
--- a/cpp/src/arrow/util/compression_test.cc
+++ b/cpp/src/arrow/util/compression_test.cc
@@ -224,8 +224,8 @@ void CheckStreamingDecompressor(Codec* codec, const std::vector<uint8_t>& data)
 
 // Check the streaming compressor and decompressor together
 
-void CheckStreamingRoundtrip(std::shared_ptr<Compressor> compressor,
-                             std::shared_ptr<Decompressor> decompressor,
+void CheckStreamingRoundtrip(const std::shared_ptr<Compressor>& compressor,
+                             const std::shared_ptr<Decompressor>& decompressor,
                              const std::vector<uint8_t>& data) {
   std::default_random_engine engine(42);
   std::uniform_int_distribution<int> buf_size_distribution(10, 40);
diff --git a/cpp/src/arrow/util/delimiting.cc b/cpp/src/arrow/util/delimiting.cc
index 0bc1b45f6bf7..61d2b64d0a4a 100644
--- a/cpp/src/arrow/util/delimiting.cc
+++ b/cpp/src/arrow/util/delimiting.cc
@@ -104,7 +104,7 @@ std::shared_ptr<BoundaryFinder> MakeNewlineBoundaryFinder() {
 Chunker::~Chunker() {}
 
 Chunker::Chunker(std::shared_ptr<BoundaryFinder> delimiter)
-    : boundary_finder_(delimiter) {}
+    : boundary_finder_(std::move(delimiter)) {}
 
 Status Chunker::Process(std::shared_ptr<Buffer> block, std::shared_ptr<Buffer>* whole,
                         std::shared_ptr<Buffer>* partial) {
diff --git a/cpp/src/arrow/util/rle_encoding_test.cc b/cpp/src/arrow/util/rle_encoding_test.cc
index 16b702c23d49..bb4ee46c0b64 100644
--- a/cpp/src/arrow/util/rle_encoding_test.cc
+++ b/cpp/src/arrow/util/rle_encoding_test.cc
@@ -1056,7 +1056,7 @@ std::vector<uint8_t> EncodeTestArray(const Array& data, int bit_width,
 ///         is valid.
 template <typename Type>
 void CheckRoundTrip(const Array& data, int bit_width, bool spaced, int32_t parts,
-                    std::shared_ptr<FloatArray> dict = {}) {
+                    const std::shared_ptr<FloatArray>& dict = {}) {
   using ArrayType = typename TypeTraits<Type>::ArrayType;
   using value_type = typename Type::c_type;
 
diff --git a/cpp/src/arrow/util/task_group_test.cc b/cpp/src/arrow/util/task_group_test.cc
index 4913fb9294c2..0432dd58e20a 100644
--- a/cpp/src/arrow/util/task_group_test.cc
+++ b/cpp/src/arrow/util/task_group_test.cc
@@ -50,7 +50,7 @@ static std::vector<double> RandomSleepDurations(int nsleeps, double min_seconds,
 }
 
 // Check TaskGroup behaviour with a bunch of all-successful tasks
-void TestTaskGroupSuccess(std::shared_ptr<TaskGroup> task_group) {
+void TestTaskGroupSuccess(const std::shared_ptr<TaskGroup>& task_group) {
   const int NTASKS = 10;
   auto sleeps = RandomSleepDurations(NTASKS, 1e-3, 4e-3);
 
@@ -280,7 +280,7 @@ void StressFailingTaskGroupLifetime(std::function<std::shared_ptr<TaskGroup>()>
   }
 }
 
-void TestNoCopyTask(std::shared_ptr<TaskGroup> task_group) {
+void TestNoCopyTask(const std::shared_ptr<TaskGroup>& task_group) {
   auto counter = std::make_shared<uint8_t>(0);
   CopyCountingTask task(counter);
   task_group->Append(std::move(task));
@@ -327,7 +327,7 @@ void TestFinishNotSticky(std::function<std::shared_ptr<TaskGroup>()> factory) {
   }
 }
 
-void TestFinishNeverStarted(std::shared_ptr<TaskGroup> task_group) {
+void TestFinishNeverStarted(const std::shared_ptr<TaskGroup>& task_group) {
   // If we call FinishAsync we are done adding tasks so if we never added any it should be
   // completed
   auto finished = task_group->FinishAsync();