diff --git a/cpp/include/Ice/Buffer.h b/cpp/include/Ice/Buffer.h
index 7f860dd167d..572d29a078c 100644
--- a/cpp/include/Ice/Buffer.h
+++ b/cpp/include/Ice/Buffer.h
@@ -9,6 +9,7 @@
 
 #include <cassert>
 #include <cstddef>
+#include <utility>
 #include <vector>
 
 namespace IceInternal
diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h
index a1d14a58339..631fab3abb3 100644
--- a/cpp/include/Ice/InputStream.h
+++ b/cpp/include/Ice/InputStream.h
@@ -835,16 +835,12 @@ namespace Ice
             virtual void readPendingValues() {}
 
         protected:
-            EncapsDecoder(
-                InputStream* stream,
-                Encaps* encaps,
-                size_t classGraphDepthMax,
-                const Ice::ValueFactoryManagerPtr& f)
+            EncapsDecoder(InputStream* stream, Encaps* encaps, size_t classGraphDepthMax, Ice::ValueFactoryManagerPtr f)
                 : _stream(stream),
                   _encaps(encaps),
                   _classGraphDepthMax(classGraphDepthMax),
                   _classGraphDepth(0),
-                  _valueFactoryManager(f),
+                  _valueFactoryManager(std::move(f)),
                   _typeIdIndex(0)
             {
             }
diff --git a/cpp/include/Ice/LoggerUtil.h b/cpp/include/Ice/LoggerUtil.h
index c6bf0d66693..e2064093c60 100644
--- a/cpp/include/Ice/LoggerUtil.h
+++ b/cpp/include/Ice/LoggerUtil.h
@@ -13,6 +13,7 @@
 #include "Proxy.h"
 
 #include <sstream>
+#include <utility>
 
 namespace Ice
 {
@@ -94,7 +95,7 @@ namespace Ice
     template<class L, class LPtr, void (L::*output)(const std::string&)> class LoggerOutput : public LoggerOutputBase
     {
     public:
-        inline LoggerOutput(const LPtr& lptr) : _logger(lptr) {}
+        inline LoggerOutput(LPtr lptr) : _logger(std::move(lptr)) {}
 
         inline ~LoggerOutput() { flush(); }
 
diff --git a/cpp/include/Ice/MetricsAdminI.h b/cpp/include/Ice/MetricsAdminI.h
index 56317db31de..87910682f6e 100644
--- a/cpp/include/Ice/MetricsAdminI.h
+++ b/cpp/include/Ice/MetricsAdminI.h
@@ -35,7 +35,7 @@ namespace IceInternal
         class ICE_API RegExp
         {
         public:
-            RegExp(const std::string&, const std::string&);
+            RegExp(std::string, const std::string&);
 
             template<typename T> bool match(const IceMX::MetricsHelperT<T>& helper, bool reject)
             {
@@ -115,9 +115,9 @@ namespace IceInternal
         class EntryT : public std::enable_shared_from_this<EntryT>
         {
         public:
-            EntryT(MetricsMapTPtr map, const TPtr& object, const typename std::list<EntryTPtr>::iterator& p)
-                : _map(map),
-                  _object(object),
+            EntryT(MetricsMapTPtr map, TPtr object, const typename std::list<EntryTPtr>::iterator& p)
+                : _map(std::move(map)),
+                  _object(std::move(object)),
                   _detachedPos(p)
             {
             }
@@ -505,7 +505,7 @@ namespace IceInternal
     class MetricsViewI
     {
     public:
-        MetricsViewI(const std::string&);
+        MetricsViewI(std::string);
 
         void destroy();
 
@@ -533,7 +533,7 @@ namespace IceInternal
     class ICE_API MetricsAdminI : public IceMX::MetricsAdmin
     {
     public:
-        MetricsAdminI(const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
+        MetricsAdminI(Ice::PropertiesPtr, Ice::LoggerPtr);
         ~MetricsAdminI() override;
 
         void destroy();
diff --git a/cpp/include/Ice/MetricsObserverI.h b/cpp/include/Ice/MetricsObserverI.h
index 04a676ddf1a..3f5bad14805 100644
--- a/cpp/include/Ice/MetricsObserverI.h
+++ b/cpp/include/Ice/MetricsObserverI.h
@@ -67,7 +67,7 @@ namespace IceMX
             class Resolver
             {
             public:
-                Resolver(const std::string& name) : _name(name) {}
+                Resolver(std::string name) : _name(std::move(name)) {}
 
                 virtual ~Resolver() {}
 
@@ -440,8 +440,8 @@ namespace IceMX
         using MetricsType = typename ObserverImplType::MetricsType;
         using MetricsMapSeqType = std::vector<std::shared_ptr<IceInternal::MetricsMapT<MetricsType>>>;
 
-        ObserverFactoryT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name)
-            : _metrics(metrics),
+        ObserverFactoryT(IceInternal::MetricsAdminIPtr metrics, const std::string& name)
+            : _metrics(std::move(metrics)),
               _name(name),
               _enabled(0)
         {
diff --git a/cpp/src/DataStorm/NodeI.h b/cpp/src/DataStorm/NodeI.h
index 83d4174f778..b7f6e9594dd 100644
--- a/cpp/src/DataStorm/NodeI.h
+++ b/cpp/src/DataStorm/NodeI.h
@@ -8,7 +8,6 @@
 #include "DataStorm/Contract.h"
 #include "DataStorm/InternalI.h"
 #include "ForwarderManager.h"
-
 #include "Ice/Ice.h"
 
 #include <set>
diff --git a/cpp/src/Glacier2/Blobject.cpp b/cpp/src/Glacier2/Blobject.cpp
index ddd54463273..49d564d4c51 100644
--- a/cpp/src/Glacier2/Blobject.cpp
+++ b/cpp/src/Glacier2/Blobject.cpp
@@ -19,7 +19,7 @@ namespace
     constexpr string_view clientTraceRequest = "Glacier2.Client.Trace.Request";
 }
 
-Glacier2::Blobject::Blobject(shared_ptr<Instance> instance, ConnectionPtr reverseConnection, const Context& context)
+Glacier2::Blobject::Blobject(shared_ptr<Instance> instance, ConnectionPtr reverseConnection, Context context)
     : _instance(std::move(instance)),
       _reverseConnection(std::move(reverseConnection)),
       _forwardContext(
@@ -28,7 +28,7 @@ Glacier2::Blobject::Blobject(shared_ptr<Instance> instance, ConnectionPtr revers
       _requestTraceLevel(
           _reverseConnection ? _instance->properties()->getIcePropertyAsInt(serverTraceRequest)
                              : _instance->properties()->getIcePropertyAsInt(clientTraceRequest)),
-      _context(context)
+      _context(std::move(context))
 {
 }
 
diff --git a/cpp/src/Glacier2/Blobject.h b/cpp/src/Glacier2/Blobject.h
index 0913a7ff5d7..8b2ea3915fb 100644
--- a/cpp/src/Glacier2/Blobject.h
+++ b/cpp/src/Glacier2/Blobject.h
@@ -13,7 +13,7 @@ namespace Glacier2
     class Blobject : public Ice::BlobjectArrayAsync, public std::enable_shared_from_this<Blobject>
     {
     public:
-        Blobject(std::shared_ptr<Instance>, Ice::ConnectionPtr, const Ice::Context&);
+        Blobject(std::shared_ptr<Instance>, Ice::ConnectionPtr, Ice::Context);
         void invokeException(std::exception_ptr, std::function<void(std::exception_ptr)>&&);
 
     protected:
diff --git a/cpp/src/Glacier2/ClientBlobject.cpp b/cpp/src/Glacier2/ClientBlobject.cpp
index 39130ea3765..501cadb3ce7 100644
--- a/cpp/src/Glacier2/ClientBlobject.cpp
+++ b/cpp/src/Glacier2/ClientBlobject.cpp
@@ -2,9 +2,8 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
-#include "../Ice/CheckIdentity.h"
-
 #include "ClientBlobject.h"
+#include "../Ice/CheckIdentity.h"
 #include "FilterManager.h"
 #include "FilterT.h"
 #include "RoutingTable.h"
diff --git a/cpp/src/Glacier2/FilterT.h b/cpp/src/Glacier2/FilterT.h
index 883f92c708f..63fdadf9639 100644
--- a/cpp/src/Glacier2/FilterT.h
+++ b/cpp/src/Glacier2/FilterT.h
@@ -5,7 +5,6 @@
 #define FILTER_I_H
 
 #include "Glacier2/Session.h"
-
 #include "Ice/Identity.h"
 
 #include <list>
diff --git a/cpp/src/Glacier2/Instance.h b/cpp/src/Glacier2/Instance.h
index 5a42b509893..e0fe3b5ad45 100644
--- a/cpp/src/Glacier2/Instance.h
+++ b/cpp/src/Glacier2/Instance.h
@@ -8,7 +8,6 @@
 #include "Ice/CommunicatorF.h"
 #include "Ice/ObjectAdapterF.h"
 #include "Ice/PropertiesF.h"
-
 #include "Instrumentation.h"
 #include "ProxyVerifier.h"
 #include "SessionRouterI.h"
diff --git a/cpp/src/Glacier2/InstrumentationI.cpp b/cpp/src/Glacier2/InstrumentationI.cpp
index ea51fcd2aff..1eda4f89d98 100644
--- a/cpp/src/Glacier2/InstrumentationI.cpp
+++ b/cpp/src/Glacier2/InstrumentationI.cpp
@@ -4,7 +4,6 @@
 
 #include "InstrumentationI.h"
 #include "../Ice/InstrumentationI.h"
-
 #include "Ice/Communicator.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/LoggerUtil.h"
@@ -146,9 +145,9 @@ SessionObserverI::routingTableSize(int delta)
     forEach(add(&SessionMetrics::routingTableSize, delta));
 }
 
-RouterObserverI::RouterObserverI(shared_ptr<IceInternal::MetricsAdminI> metrics, const string& instanceName)
+RouterObserverI::RouterObserverI(shared_ptr<IceInternal::MetricsAdminI> metrics, string instanceName)
     : _metrics(std::move(metrics)),
-      _instanceName(instanceName),
+      _instanceName(std::move(instanceName)),
       _sessions(_metrics, "Session")
 {
 }
diff --git a/cpp/src/Glacier2/InstrumentationI.h b/cpp/src/Glacier2/InstrumentationI.h
index e777eb556ea..39c4b13485e 100644
--- a/cpp/src/Glacier2/InstrumentationI.h
+++ b/cpp/src/Glacier2/InstrumentationI.h
@@ -5,9 +5,8 @@
 #ifndef INSTRUMENTATION_I_H
 #define INSTRUMENTATION_I_H
 
-#include "Ice/MetricsObserverI.h"
-
 #include "Glacier2/Metrics.h"
+#include "Ice/MetricsObserverI.h"
 #include "Instrumentation.h"
 
 namespace Glacier2
@@ -25,7 +24,7 @@ namespace Glacier2
     class RouterObserverI final : public Glacier2::Instrumentation::RouterObserver
     {
     public:
-        RouterObserverI(std::shared_ptr<IceInternal::MetricsAdminI>, const std::string&);
+        RouterObserverI(std::shared_ptr<IceInternal::MetricsAdminI>, std::string);
 
         void setObserverUpdater(const std::shared_ptr<Glacier2::Instrumentation::ObserverUpdater>&) override;
 
diff --git a/cpp/src/Glacier2/RouterI.cpp b/cpp/src/Glacier2/RouterI.cpp
index 4149d08519f..424de5f9ec6 100644
--- a/cpp/src/Glacier2/RouterI.cpp
+++ b/cpp/src/Glacier2/RouterI.cpp
@@ -16,18 +16,18 @@ using namespace Glacier2;
 Glacier2::RouterI::RouterI(
     shared_ptr<Instance> instance,
     ConnectionPtr connection,
-    const string& userId,
+    string userId,
     optional<SessionPrx> session,
-    const Identity& controlId,
+    Identity controlId,
     shared_ptr<FilterManager> filters,
     const Context& context)
     : _instance(std::move(instance)),
       _routingTable(make_shared<RoutingTable>(_instance->communicator(), _instance->proxyVerifier())),
       _clientBlobject(make_shared<ClientBlobject>(_instance, std::move(filters), context, _routingTable)),
       _connection(std::move(connection)),
-      _userId(userId),
+      _userId(std::move(userId)),
       _session(std::move(session)),
-      _controlId(controlId),
+      _controlId(std::move(controlId)),
       _context(context)
 {
     if (_instance->serverObjectAdapter())
diff --git a/cpp/src/Glacier2/RouterI.h b/cpp/src/Glacier2/RouterI.h
index 7148898644e..24a205e4395 100644
--- a/cpp/src/Glacier2/RouterI.h
+++ b/cpp/src/Glacier2/RouterI.h
@@ -22,9 +22,9 @@ namespace Glacier2
         RouterI(
             std::shared_ptr<Instance>,
             Ice::ConnectionPtr,
-            const std::string&,
+            std::string,
             std::optional<SessionPrx>,
-            const Ice::Identity&,
+            Ice::Identity,
             std::shared_ptr<FilterManager>,
             const Ice::Context&);
 
diff --git a/cpp/src/Glacier2/RoutingTable.h b/cpp/src/Glacier2/RoutingTable.h
index 25fa916fbef..c3cb3816418 100644
--- a/cpp/src/Glacier2/RoutingTable.h
+++ b/cpp/src/Glacier2/RoutingTable.h
@@ -7,7 +7,6 @@
 
 #include "Ice/Ice.h"
 #include "Ice/ObserverHelper.h"
-
 #include "Instrumentation.h"
 #include "ProxyVerifier.h"
 
diff --git a/cpp/src/Glacier2/SessionRouterI.cpp b/cpp/src/Glacier2/SessionRouterI.cpp
index fb30fe50585..2d9c413d076 100644
--- a/cpp/src/Glacier2/SessionRouterI.cpp
+++ b/cpp/src/Glacier2/SessionRouterI.cpp
@@ -80,13 +80,13 @@ namespace Glacier2
             function<void(const optional<SessionPrx>&)> response,
             function<void(exception_ptr)> exception,
             const string& user,
-            const string& password,
+            string password,
             const Ice::Current& current,
             const shared_ptr<SessionRouterI>& sessionRouter)
             : CreateSession(sessionRouter, user, current),
               _response(std::move(response)),
               _exception(std::move(exception)),
-              _password(password)
+              _password(std::move(password))
         {
         }
 
@@ -179,13 +179,13 @@ namespace Glacier2
             function<void(const optional<SessionPrx>& returnValue)> response,
             function<void(exception_ptr)> exception,
             const string& user,
-            const SSLInfo& sslInfo,
+            SSLInfo sslInfo,
             const Ice::Current& current,
             const shared_ptr<SessionRouterI>& sessionRouter)
             : CreateSession(sessionRouter, user, current),
               _response(std::move(response)),
               _exception(std::move(exception)),
-              _sslInfo(sslInfo)
+              _sslInfo(std::move(sslInfo))
         {
         }
 
@@ -273,10 +273,10 @@ namespace Glacier2
     };
 }
 
-CreateSession::CreateSession(shared_ptr<SessionRouterI> sessionRouter, const string& user, const Ice::Current& current)
+CreateSession::CreateSession(shared_ptr<SessionRouterI> sessionRouter, string user, const Ice::Current& current)
     : _instance(sessionRouter->_instance),
       _sessionRouter(std::move(sessionRouter)),
-      _user(user),
+      _user(std::move(user)),
       _current(current)
 {
     // Clear reserved contexts potentially set by client
diff --git a/cpp/src/Glacier2/SessionRouterI.h b/cpp/src/Glacier2/SessionRouterI.h
index 730c2052d15..c847d0eafde 100644
--- a/cpp/src/Glacier2/SessionRouterI.h
+++ b/cpp/src/Glacier2/SessionRouterI.h
@@ -5,10 +5,9 @@
 #ifndef GLACIER2_SESSION_ROUTER_I_H
 #define GLACIER2_SESSION_ROUTER_I_H
 
-#include "Ice/Ice.h"
-
 #include "Glacier2/PermissionsVerifier.h"
 #include "Glacier2/Router.h"
+#include "Ice/Ice.h"
 #include "Instrumentation.h"
 
 #include <set>
@@ -25,7 +24,7 @@ namespace Glacier2
     class CreateSession : public std::enable_shared_from_this<CreateSession>
     {
     public:
-        CreateSession(std::shared_ptr<SessionRouterI>, const std::string&, const Ice::Current&);
+        CreateSession(std::shared_ptr<SessionRouterI>, std::string, const Ice::Current&);
 
         void create();
         void addPendingCallback(std::shared_ptr<CreateSession>);
diff --git a/cpp/src/Glacier2CryptPermissionsVerifier/CryptPermissionsVerifierI.cpp b/cpp/src/Glacier2CryptPermissionsVerifier/CryptPermissionsVerifierI.cpp
index a094efefe96..e6effff1f95 100644
--- a/cpp/src/Glacier2CryptPermissionsVerifier/CryptPermissionsVerifierI.cpp
+++ b/cpp/src/Glacier2CryptPermissionsVerifier/CryptPermissionsVerifierI.cpp
@@ -2,10 +2,9 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
+#include "../Ice/FileUtil.h"
 #include "Glacier2/PermissionsVerifier.h"
 #include "Ice/Ice.h"
-
-#include "../Ice/FileUtil.h"
 #include "Ice/StringUtil.h"
 
 #include <fstream>
diff --git a/cpp/src/Ice/CommunicatorFlushBatchAsync.cpp b/cpp/src/Ice/CommunicatorFlushBatchAsync.cpp
index e01b403b33d..92ed2466af5 100644
--- a/cpp/src/Ice/CommunicatorFlushBatchAsync.cpp
+++ b/cpp/src/Ice/CommunicatorFlushBatchAsync.cpp
@@ -34,12 +34,9 @@ CommunicatorFlushBatchAsync::flushConnection(const ConnectionIPtr& con, Ice::Com
     class FlushBatch final : public OutgoingAsyncBase
     {
     public:
-        FlushBatch(
-            const CommunicatorFlushBatchAsyncPtr& outAsync,
-            const InstancePtr& instance,
-            InvocationObserver& observer)
+        FlushBatch(CommunicatorFlushBatchAsyncPtr outAsync, const InstancePtr& instance, InvocationObserver& observer)
             : OutgoingAsyncBase(instance),
-              _outAsync(outAsync),
+              _outAsync(std::move(outAsync)),
               _parentObserver(observer)
         {
         }
diff --git a/cpp/src/Ice/ConnectionFactory.cpp b/cpp/src/Ice/ConnectionFactory.cpp
index eee5d9dc573..552bb04195b 100644
--- a/cpp/src/Ice/ConnectionFactory.cpp
+++ b/cpp/src/Ice/ConnectionFactory.cpp
@@ -72,9 +72,9 @@ namespace
     class StartAcceptor : public TimerTask, public std::enable_shared_from_this<StartAcceptor>
     {
     public:
-        StartAcceptor(const IncomingConnectionFactoryPtr& factory, const InstancePtr& instance)
-            : _factory(factory),
-              _instance(instance)
+        StartAcceptor(IncomingConnectionFactoryPtr factory, InstancePtr instance)
+            : _factory(std::move(factory)),
+              _instance(std::move(instance))
         {
         }
 
@@ -319,9 +319,9 @@ IceInternal::OutgoingConnectionFactory::removeConnection(const ConnectionIPtr& c
 }
 
 IceInternal::OutgoingConnectionFactory::OutgoingConnectionFactory(
-    const CommunicatorPtr& communicator,
+    CommunicatorPtr communicator,
     const InstancePtr& instance)
-    : _communicator(communicator),
+    : _communicator(std::move(communicator)),
       _instance(instance),
       _connectionOptions(instance->clientConnectionOptions()),
       _destroyed(false),
@@ -792,15 +792,15 @@ IceInternal::OutgoingConnectionFactory::handleConnectionException(exception_ptr
 }
 
 IceInternal::OutgoingConnectionFactory::ConnectCallback::ConnectCallback(
-    const InstancePtr& instance,
-    const OutgoingConnectionFactoryPtr& factory,
+    InstancePtr instance,
+    OutgoingConnectionFactoryPtr factory,
     const vector<EndpointIPtr>& endpoints,
     bool hasMore,
     std::function<void(Ice::ConnectionIPtr, bool)> createConnectionResponse,
     std::function<void(std::exception_ptr)> createConnectionException,
     Ice::EndpointSelectionType selType)
-    : _instance(instance),
-      _factory(factory),
+    : _instance(std::move(instance)),
+      _factory(std::move(factory)),
       _endpoints(endpoints),
       _hasMore(hasMore),
       _createConnectionResponse(std::move(createConnectionResponse)),
diff --git a/cpp/src/Ice/ConnectionFactory.h b/cpp/src/Ice/ConnectionFactory.h
index 671c0f24aeb..6906c72e0a0 100644
--- a/cpp/src/Ice/ConnectionFactory.h
+++ b/cpp/src/Ice/ConnectionFactory.h
@@ -65,14 +65,14 @@ namespace IceInternal
         void setDefaultObjectAdapter(Ice::ObjectAdapterPtr adapter) noexcept;
         [[nodiscard]] Ice::ObjectAdapterPtr getDefaultObjectAdapter() const noexcept;
 
-        OutgoingConnectionFactory(const Ice::CommunicatorPtr&, const InstancePtr&);
+        OutgoingConnectionFactory(Ice::CommunicatorPtr, const InstancePtr&);
         ~OutgoingConnectionFactory();
         friend class Instance;
 
     private:
         struct ConnectorInfo
         {
-            ConnectorInfo(const ConnectorPtr& c, const EndpointIPtr& e) : connector(c), endpoint(e) {}
+            ConnectorInfo(ConnectorPtr c, EndpointIPtr e) : connector(std::move(c)), endpoint(std::move(e)) {}
 
             bool operator==(const ConnectorInfo& other) const;
 
@@ -84,8 +84,8 @@ namespace IceInternal
         {
         public:
             ConnectCallback(
-                const InstancePtr&,
-                const OutgoingConnectionFactoryPtr&,
+                InstancePtr,
+                OutgoingConnectionFactoryPtr,
                 const std::vector<EndpointIPtr>&,
                 bool,
                 std::function<void(Ice::ConnectionIPtr, bool)>,
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 21ee99b285a..c07900d286b 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -95,7 +95,7 @@ namespace
     class ConnectionFlushBatchAsync : public OutgoingAsyncBase
     {
     public:
-        ConnectionFlushBatchAsync(const Ice::ConnectionIPtr&, const InstancePtr&);
+        ConnectionFlushBatchAsync(Ice::ConnectionIPtr, const InstancePtr&);
 
         [[nodiscard]] virtual Ice::ConnectionPtr getConnection() const;
 
@@ -128,9 +128,9 @@ namespace
     }
 }
 
-ConnectionFlushBatchAsync::ConnectionFlushBatchAsync(const ConnectionIPtr& connection, const InstancePtr& instance)
+ConnectionFlushBatchAsync::ConnectionFlushBatchAsync(ConnectionIPtr connection, const InstancePtr& instance)
     : OutgoingAsyncBase(instance),
-      _connection(connection)
+      _connection(std::move(connection))
 {
 }
 
@@ -1891,7 +1891,7 @@ Ice::ConnectionI::exception(std::exception_ptr ex)
 }
 
 Ice::ConnectionI::ConnectionI(
-    const CommunicatorPtr& communicator,
+    CommunicatorPtr communicator,
     const InstancePtr& instance,
     const TransceiverPtr& transceiver,
     const ConnectorPtr& connector,
@@ -1899,7 +1899,7 @@ Ice::ConnectionI::ConnectionI(
     const shared_ptr<ObjectAdapterI>& adapter,
     std::function<void(const ConnectionIPtr&)> removeFromFactory,
     const ConnectionOptions& options) noexcept
-    : _communicator(communicator),
+    : _communicator(std::move(communicator)),
       _instance(instance),
       _transceiver(transceiver),
       _idleTimeoutTransceiver(dynamic_pointer_cast<IdleTimeoutTransceiverDecorator>(transceiver)),
diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h
index 293539aaa01..212d2e246a0 100644
--- a/cpp/src/Ice/ConnectionI.h
+++ b/cpp/src/Ice/ConnectionI.h
@@ -97,9 +97,9 @@ namespace Ice
                 assert(stream->b.ownsMemory());
             }
 
-            OutgoingMessage(const IceInternal::OutgoingAsyncBasePtr& o, Ice::OutputStream* str, bool comp, int rid)
+            OutgoingMessage(IceInternal::OutgoingAsyncBasePtr o, Ice::OutputStream* str, bool comp, int rid)
                 : stream(str),
-                  outAsync(o),
+                  outAsync(std::move(o)),
                   compress(comp),
                   requestId(rid),
                   adopted(false)
@@ -243,7 +243,7 @@ namespace Ice
 
     private:
         ConnectionI(
-            const Ice::CommunicatorPtr&,
+            Ice::CommunicatorPtr,
             const IceInternal::InstancePtr&,
             const IceInternal::TransceiverPtr&,
             const IceInternal::ConnectorPtr&,
diff --git a/cpp/src/Ice/EndpointFactory.cpp b/cpp/src/Ice/EndpointFactory.cpp
index 7ea4c4f110c..3ae9c4648ab 100644
--- a/cpp/src/Ice/EndpointFactory.cpp
+++ b/cpp/src/Ice/EndpointFactory.cpp
@@ -39,10 +39,8 @@ IceInternal::EndpointFactoryPlugin::destroy()
 {
 }
 
-IceInternal::EndpointFactoryWithUnderlying::EndpointFactoryWithUnderlying(
-    const ProtocolInstancePtr& instance,
-    int16_t type)
-    : _instance(instance),
+IceInternal::EndpointFactoryWithUnderlying::EndpointFactoryWithUnderlying(ProtocolInstancePtr instance, int16_t type)
+    : _instance(std::move(instance)),
       _type(type)
 {
 }
@@ -101,10 +99,10 @@ IceInternal::EndpointFactoryWithUnderlying::clone(const ProtocolInstancePtr& ins
 }
 
 IceInternal::UnderlyingEndpointFactory::UnderlyingEndpointFactory(
-    const ProtocolInstancePtr& instance,
+    ProtocolInstancePtr instance,
     int16_t type,
     int16_t underlying)
-    : _instance(instance),
+    : _instance(std::move(instance)),
       _type(type),
       _underlying(underlying)
 {
diff --git a/cpp/src/Ice/EndpointFactory.h b/cpp/src/Ice/EndpointFactory.h
index 4a94a76f371..7c2935ffe15 100644
--- a/cpp/src/Ice/EndpointFactory.h
+++ b/cpp/src/Ice/EndpointFactory.h
@@ -41,7 +41,7 @@ namespace IceInternal
     class ICE_API EndpointFactoryWithUnderlying : public EndpointFactory
     {
     public:
-        EndpointFactoryWithUnderlying(const ProtocolInstancePtr&, std::int16_t);
+        EndpointFactoryWithUnderlying(ProtocolInstancePtr, std::int16_t);
 
         void initialize() override;
         [[nodiscard]] std::int16_t type() const override;
@@ -72,7 +72,7 @@ namespace IceInternal
     class ICE_API UnderlyingEndpointFactory : public EndpointFactory
     {
     public:
-        UnderlyingEndpointFactory(const ProtocolInstancePtr&, std::int16_t, std::int16_t);
+        UnderlyingEndpointFactory(ProtocolInstancePtr, std::int16_t, std::int16_t);
 
         void initialize() override;
         [[nodiscard]] std::int16_t type() const override;
diff --git a/cpp/src/Ice/EndpointFactoryManager.cpp b/cpp/src/Ice/EndpointFactoryManager.cpp
index 3c9ee261a6b..4a42b738166 100644
--- a/cpp/src/Ice/EndpointFactoryManager.cpp
+++ b/cpp/src/Ice/EndpointFactoryManager.cpp
@@ -17,7 +17,7 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceInternal::EndpointFactoryManager::EndpointFactoryManager(const InstancePtr& instance) : _instance(instance) {}
+IceInternal::EndpointFactoryManager::EndpointFactoryManager(InstancePtr instance) : _instance(std::move(instance)) {}
 
 void
 IceInternal::EndpointFactoryManager::initialize() const
diff --git a/cpp/src/Ice/EndpointFactoryManager.h b/cpp/src/Ice/EndpointFactoryManager.h
index 307a5dedc4c..eae0f075285 100644
--- a/cpp/src/Ice/EndpointFactoryManager.h
+++ b/cpp/src/Ice/EndpointFactoryManager.h
@@ -25,7 +25,7 @@ namespace IceInternal
     class EndpointFactoryManager
     {
     public:
-        EndpointFactoryManager(const InstancePtr&);
+        EndpointFactoryManager(InstancePtr);
         void initialize() const;
         void add(const EndpointFactoryPtr&);
         [[nodiscard]] EndpointFactoryPtr get(std::int16_t) const;
diff --git a/cpp/src/Ice/FixedRequestHandler.cpp b/cpp/src/Ice/FixedRequestHandler.cpp
index 9452849b828..f729a13a415 100644
--- a/cpp/src/Ice/FixedRequestHandler.cpp
+++ b/cpp/src/Ice/FixedRequestHandler.cpp
@@ -13,12 +13,9 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-FixedRequestHandler::FixedRequestHandler(
-    const ReferencePtr& reference,
-    const Ice::ConnectionIPtr& connection,
-    bool compress)
+FixedRequestHandler::FixedRequestHandler(const ReferencePtr& reference, Ice::ConnectionIPtr connection, bool compress)
     : RequestHandler(reference),
-      _connection(connection),
+      _connection(std::move(connection)),
       _compress(compress)
 {
 }
diff --git a/cpp/src/Ice/FixedRequestHandler.h b/cpp/src/Ice/FixedRequestHandler.h
index a483826328c..c48fd89bcef 100644
--- a/cpp/src/Ice/FixedRequestHandler.h
+++ b/cpp/src/Ice/FixedRequestHandler.h
@@ -14,7 +14,7 @@ namespace IceInternal
     class FixedRequestHandler final : public RequestHandler
     {
     public:
-        FixedRequestHandler(const ReferencePtr&, const Ice::ConnectionIPtr&, bool);
+        FixedRequestHandler(const ReferencePtr&, Ice::ConnectionIPtr, bool);
 
         AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) final;
 
diff --git a/cpp/src/Ice/HttpParser.cpp b/cpp/src/Ice/HttpParser.cpp
index 68570d0b878..da3de74d551 100644
--- a/cpp/src/Ice/HttpParser.cpp
+++ b/cpp/src/Ice/HttpParser.cpp
@@ -24,7 +24,7 @@ namespace
     }
 }
 
-IceInternal::WebSocketException::WebSocketException(const string& r) : reason(r) {}
+IceInternal::WebSocketException::WebSocketException(string r) : reason(std::move(r)) {}
 
 IceInternal::HttpParser::HttpParser()
     : _type(TypeUnknown),
diff --git a/cpp/src/Ice/HttpParser.h b/cpp/src/Ice/HttpParser.h
index d2ac337634d..95dcde553b8 100644
--- a/cpp/src/Ice/HttpParser.h
+++ b/cpp/src/Ice/HttpParser.h
@@ -21,7 +21,7 @@ namespace IceInternal
     class WebSocketException
     {
     public:
-        WebSocketException(const std::string&);
+        WebSocketException(std::string);
 
         std::string reason;
     };
diff --git a/cpp/src/Ice/IPEndpointI.cpp b/cpp/src/Ice/IPEndpointI.cpp
index a6694c2feae..bc4ccc30b5f 100644
--- a/cpp/src/Ice/IPEndpointI.cpp
+++ b/cpp/src/Ice/IPEndpointI.cpp
@@ -403,23 +403,23 @@ IceInternal::IPEndpointI::checkOption(const string& option, const string& argume
 }
 
 IceInternal::IPEndpointI::IPEndpointI(
-    const ProtocolInstancePtr& instance,
-    const string& host,
+    ProtocolInstancePtr instance,
+    string host,
     int port,
     const Address& sourceAddr,
-    const string& connectionId)
-    : _instance(instance),
-      _host(host),
+    string connectionId)
+    : _instance(std::move(instance)),
+      _host(std::move(host)),
       _port(port),
       _sourceAddr(sourceAddr),
-      _connectionId(connectionId)
+      _connectionId(std::move(connectionId))
 {
 }
 
-IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance) : _instance(instance), _port(0) {}
+IceInternal::IPEndpointI::IPEndpointI(ProtocolInstancePtr instance) : _instance(std::move(instance)), _port(0) {}
 
-IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance, InputStream* s)
-    : _instance(instance),
+IceInternal::IPEndpointI::IPEndpointI(ProtocolInstancePtr instance, InputStream* s)
+    : _instance(std::move(instance)),
       _port(0)
 {
     s->read(const_cast<string&>(_host), false);
diff --git a/cpp/src/Ice/IPEndpointI.h b/cpp/src/Ice/IPEndpointI.h
index a35e056151f..627880144f1 100644
--- a/cpp/src/Ice/IPEndpointI.h
+++ b/cpp/src/Ice/IPEndpointI.h
@@ -57,9 +57,9 @@ namespace IceInternal
         [[nodiscard]] virtual ConnectorPtr createConnector(const Address& address, const NetworkProxyPtr&) const = 0;
         [[nodiscard]] virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const = 0;
 
-        IPEndpointI(const ProtocolInstancePtr&, const std::string&, int, const Address&, const std::string&);
-        IPEndpointI(const ProtocolInstancePtr&);
-        IPEndpointI(const ProtocolInstancePtr&, Ice::InputStream*);
+        IPEndpointI(ProtocolInstancePtr, std::string, int, const Address&, std::string);
+        IPEndpointI(ProtocolInstancePtr);
+        IPEndpointI(ProtocolInstancePtr, Ice::InputStream*);
 
         const ProtocolInstancePtr _instance;
         const std::string _host;
diff --git a/cpp/src/Ice/IdleTimeoutTransceiverDecorator.h b/cpp/src/Ice/IdleTimeoutTransceiverDecorator.h
index f123101cc24..7afd8735541 100644
--- a/cpp/src/Ice/IdleTimeoutTransceiverDecorator.h
+++ b/cpp/src/Ice/IdleTimeoutTransceiverDecorator.h
@@ -19,12 +19,12 @@ namespace IceInternal
     {
     public:
         IdleTimeoutTransceiverDecorator(
-            const TransceiverPtr& decoratee,
+            TransceiverPtr decoratee,
             const std::chrono::seconds& idleTimeout,
-            const IceInternal::TimerPtr& timer)
-            : _decoratee(decoratee),
+            IceInternal::TimerPtr timer)
+            : _decoratee(std::move(decoratee)),
               _idleTimeout(idleTimeout),
-              _timer(timer)
+              _timer(std::move(timer))
         {
             assert(_decoratee->protocol() != "udp");
         }
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 0c2fe0662ca..d4ba3054b5e 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -186,7 +186,7 @@ namespace IceInternal // Required because ObserverUpdaterI is a friend of Instan
     class ObserverUpdaterI : public Ice::Instrumentation::ObserverUpdater
     {
     public:
-        ObserverUpdaterI(const InstancePtr&);
+        ObserverUpdaterI(InstancePtr);
 
         void updateConnectionObservers() override;
         void updateThreadObservers() override;
@@ -271,7 +271,7 @@ ThreadObserverTimer::runTimerTask(const TimerTaskPtr& task)
     }
 }
 
-IceInternal::ObserverUpdaterI::ObserverUpdaterI(const InstancePtr& instance) : _instance(instance) {}
+IceInternal::ObserverUpdaterI::ObserverUpdaterI(InstancePtr instance) : _instance(std::move(instance)) {}
 
 void
 IceInternal::ObserverUpdaterI::updateConnectionObservers()
@@ -911,9 +911,9 @@ IceInternal::Instance::create(const Ice::CommunicatorPtr& communicator, const Ic
     return instance;
 }
 
-IceInternal::Instance::Instance(const InitializationData& initData)
+IceInternal::Instance::Instance(InitializationData initData)
     : _state(StateActive),
-      _initData(initData),
+      _initData(std::move(initData)),
       _messageSizeMax(0),
       _batchAutoFlushSize(0),
       _classGraphDepthMax(0),
@@ -1858,7 +1858,7 @@ IceInternal::Instance::setRcvBufSizeWarn(int16_t type, int size)
     _setBufSizeWarn[type] = info;
 }
 
-IceInternal::ProcessI::ProcessI(const CommunicatorPtr& communicator) : _communicator(communicator) {}
+IceInternal::ProcessI::ProcessI(CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 IceInternal::ProcessI::shutdown(const Current&)
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index a8f6f52ddfb..b3b15e5caa2 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -123,7 +123,7 @@ namespace IceInternal
         [[nodiscard]] Ice::SSL::SSLEnginePtr sslEngine() const { return _sslEngine; }
 
     private:
-        Instance(const Ice::InitializationData&);
+        Instance(Ice::InitializationData);
         void initialize(const Ice::CommunicatorPtr&);
         void finishSetup(int&, const char*[], const Ice::CommunicatorPtr&);
         void destroy();
@@ -204,7 +204,7 @@ namespace IceInternal
     class ProcessI final : public Ice::Process
     {
     public:
-        ProcessI(const Ice::CommunicatorPtr&);
+        ProcessI(Ice::CommunicatorPtr);
 
         void shutdown(const Ice::Current&) final;
         void writeMessage(std::string message, std::int32_t fd, const Ice::Current&) final;
diff --git a/cpp/src/Ice/InstrumentationI.cpp b/cpp/src/Ice/InstrumentationI.cpp
index ff365976b38..0ee8050df82 100644
--- a/cpp/src/Ice/InstrumentationI.cpp
+++ b/cpp/src/Ice/InstrumentationI.cpp
@@ -557,9 +557,9 @@ namespace
         };
         static Attributes attributes;
 
-        ThreadHelper(const string& parent, const string& id, ThreadState state)
-            : _parent(parent),
-              _id(id),
+        ThreadHelper(string parent, string id, ThreadState state)
+            : _parent(std::move(parent)),
+              _id(std::move(id)),
               _state(state)
         {
         }
@@ -597,9 +597,9 @@ namespace
         };
         static Attributes attributes;
 
-        EndpointHelper(const EndpointPtr& endpt, const string& id) : _endpoint(endpt), _id(id) {}
+        EndpointHelper(EndpointPtr endpt, string id) : _endpoint(std::move(endpt)), _id(std::move(id)) {}
 
-        EndpointHelper(const EndpointPtr& endpt) : _endpoint(endpt) {}
+        EndpointHelper(EndpointPtr endpt) : _endpoint(std::move(endpt)) {}
 
         string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp
index 2e6f793fe60..8d2971370bb 100644
--- a/cpp/src/Ice/LocatorInfo.cpp
+++ b/cpp/src/Ice/LocatorInfo.cpp
@@ -347,12 +347,12 @@ IceInternal::LocatorInfo::RequestCallback::exception(const LocatorInfoPtr& locat
 }
 
 IceInternal::LocatorInfo::RequestCallback::RequestCallback(
-    const ReferencePtr& ref,
+    ReferencePtr ref,
     chrono::milliseconds ttl,
-    const GetEndpointsCallbackPtr& cb)
-    : _reference(ref),
+    GetEndpointsCallbackPtr cb)
+    : _reference(std::move(ref)),
       _ttl(ttl),
-      _callback(cb)
+      _callback(std::move(cb))
 {
 }
 
@@ -394,9 +394,9 @@ IceInternal::LocatorInfo::Request::addCallback(
     }
 }
 
-IceInternal::LocatorInfo::Request::Request(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref)
-    : _locatorInfo(locatorInfo),
-      _reference(ref),
+IceInternal::LocatorInfo::Request::Request(LocatorInfoPtr locatorInfo, ReferencePtr ref)
+    : _locatorInfo(std::move(locatorInfo)),
+      _reference(std::move(ref)),
       _sent(false),
       _response(false)
 {
@@ -444,9 +444,9 @@ IceInternal::LocatorInfo::Request::exception(std::exception_ptr ex)
     }
 }
 
-IceInternal::LocatorInfo::LocatorInfo(const LocatorPrx& locator, const LocatorTablePtr& table, bool background)
-    : _locator(locator),
-      _table(table),
+IceInternal::LocatorInfo::LocatorInfo(LocatorPrx locator, LocatorTablePtr table, bool background)
+    : _locator(std::move(locator)),
+      _table(std::move(table)),
       _background(background)
 {
     assert(_table);
diff --git a/cpp/src/Ice/LocatorInfo.h b/cpp/src/Ice/LocatorInfo.h
index daa431546ca..ed605d25d6e 100644
--- a/cpp/src/Ice/LocatorInfo.h
+++ b/cpp/src/Ice/LocatorInfo.h
@@ -79,7 +79,7 @@ namespace IceInternal
         class RequestCallback final
         {
         public:
-            RequestCallback(const ReferencePtr&, std::chrono::milliseconds, const GetEndpointsCallbackPtr&);
+            RequestCallback(ReferencePtr, std::chrono::milliseconds, GetEndpointsCallbackPtr);
 
             void response(const LocatorInfoPtr&, const std::optional<Ice::ObjectPrx>&);
             void exception(const LocatorInfoPtr&, std::exception_ptr);
@@ -104,7 +104,7 @@ namespace IceInternal
             void exception(std::exception_ptr);
 
         protected:
-            Request(const LocatorInfoPtr&, const ReferencePtr&);
+            Request(LocatorInfoPtr, ReferencePtr);
 
             virtual void send() = 0;
 
@@ -122,7 +122,7 @@ namespace IceInternal
         };
         using RequestPtr = std::shared_ptr<Request>;
 
-        LocatorInfo(const Ice::LocatorPrx&, const LocatorTablePtr&, bool);
+        LocatorInfo(Ice::LocatorPrx, LocatorTablePtr, bool);
 
         void destroy();
 
diff --git a/cpp/src/Ice/LoggerAdminI.cpp b/cpp/src/Ice/LoggerAdminI.cpp
index a3217efd7cf..464e1e03123 100644
--- a/cpp/src/Ice/LoggerAdminI.cpp
+++ b/cpp/src/Ice/LoggerAdminI.cpp
@@ -93,7 +93,7 @@ namespace
     class Job
     {
     public:
-        Job(const vector<RemoteLoggerPrx>& r, const LogMessage& l) : remoteLoggers(r), logMessage(l) {}
+        Job(const vector<RemoteLoggerPrx>& r, LogMessage l) : remoteLoggers(r), logMessage(std::move(l)) {}
 
         const vector<RemoteLoggerPrx> remoteLoggers;
         const LogMessage logMessage;
diff --git a/cpp/src/Ice/MetricsAdminI.cpp b/cpp/src/Ice/MetricsAdminI.cpp
index d9ea37b830a..dcfc3c3e36d 100644
--- a/cpp/src/Ice/MetricsAdminI.cpp
+++ b/cpp/src/Ice/MetricsAdminI.cpp
@@ -3,16 +3,14 @@
 //
 
 #include "Ice/MetricsAdminI.h"
-
 #include "Ice/Communicator.h"
 #include "Ice/Logger.h"
 #include "Ice/LoggerUtil.h"
 #include "Ice/Properties.h"
+#include "Ice/StringUtil.h"
 #include "Instance.h"
 #include "InstrumentationI.h"
 
-#include "Ice/StringUtil.h"
-
 #include <chrono>
 #include <stdexcept>
 
@@ -86,7 +84,7 @@ namespace
     }
 }
 
-MetricsMapI::RegExp::RegExp(const string& attribute, const string& regexp) : _attribute(attribute)
+MetricsMapI::RegExp::RegExp(string attribute, const string& regexp) : _attribute(std::move(attribute))
 {
     _regex = regex(regexp, std::regex_constants::extended | std::regex_constants::nosubs);
 }
@@ -185,7 +183,7 @@ MetricsMapFactory::update()
     _updater->update();
 }
 
-MetricsViewI::MetricsViewI(const string& name) : _name(name) {}
+MetricsViewI::MetricsViewI(string name) : _name(std::move(name)) {}
 
 void
 MetricsViewI::destroy()
@@ -338,9 +336,9 @@ MetricsViewI::getMap(const string& mapName) const
     return nullptr;
 }
 
-MetricsAdminI::MetricsAdminI(const PropertiesPtr& properties, const LoggerPtr& logger)
-    : _logger(logger),
-      _properties(properties)
+MetricsAdminI::MetricsAdminI(PropertiesPtr properties, LoggerPtr logger)
+    : _logger(std::move(logger)),
+      _properties(std::move(properties))
 {
     updateViews();
 }
diff --git a/cpp/src/Ice/Network.cpp b/cpp/src/Ice/Network.cpp
index 0bcddff9c9c..798cbccbe74 100644
--- a/cpp/src/Ice/Network.cpp
+++ b/cpp/src/Ice/Network.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "Network.h"
-#include "DisableWarnings.h"
 #include "Ice/Buffer.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/LoggerUtil.h" // For setTcpBufSize
@@ -14,6 +13,8 @@
 #include "ProtocolInstance.h" // For setTcpBufSize
 #include "Random.h"
 
+#include "DisableWarnings.h"
+
 #include <cassert>
 #include <functional>
 
diff --git a/cpp/src/Ice/Network.h b/cpp/src/Ice/Network.h
index 1fa3bbf75a7..b7f40a211f9 100644
--- a/cpp/src/Ice/Network.h
+++ b/cpp/src/Ice/Network.h
@@ -6,7 +6,6 @@
 #define ICE_NETWORK_H
 
 #include "Ice/Config.h"
-
 #include "Ice/EndpointSelectionType.h"
 #include "Ice/EndpointTypes.h"
 #include "Ice/Logger.h"      // For setTcpBufSize
diff --git a/cpp/src/Ice/ObjectAdapterFactory.cpp b/cpp/src/Ice/ObjectAdapterFactory.cpp
index cf5b8c28e9a..fd2ccb7d396 100644
--- a/cpp/src/Ice/ObjectAdapterFactory.cpp
+++ b/cpp/src/Ice/ObjectAdapterFactory.cpp
@@ -267,11 +267,9 @@ IceInternal::ObjectAdapterFactory::flushAsyncBatchRequests(
     }
 }
 
-IceInternal::ObjectAdapterFactory::ObjectAdapterFactory(
-    const InstancePtr& instance,
-    const CommunicatorPtr& communicator)
-    : _instance(instance),
-      _communicator(communicator)
+IceInternal::ObjectAdapterFactory::ObjectAdapterFactory(InstancePtr instance, CommunicatorPtr communicator)
+    : _instance(std::move(instance)),
+      _communicator(std::move(communicator))
 {
 }
 
diff --git a/cpp/src/Ice/ObjectAdapterFactory.h b/cpp/src/Ice/ObjectAdapterFactory.h
index 5543f7aa704..b268e398ac7 100644
--- a/cpp/src/Ice/ObjectAdapterFactory.h
+++ b/cpp/src/Ice/ObjectAdapterFactory.h
@@ -32,7 +32,7 @@ namespace IceInternal
         void removeObjectAdapter(const Ice::ObjectAdapterPtr&);
         void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, Ice::CompressBatch) const;
 
-        ObjectAdapterFactory(const InstancePtr&, const Ice::CommunicatorPtr&);
+        ObjectAdapterFactory(InstancePtr, Ice::CommunicatorPtr);
         virtual ~ObjectAdapterFactory();
 
     private:
diff --git a/cpp/src/Ice/PluginManagerI.cpp b/cpp/src/Ice/PluginManagerI.cpp
index 8e69fc46036..c4156c36cff 100644
--- a/cpp/src/Ice/PluginManagerI.cpp
+++ b/cpp/src/Ice/PluginManagerI.cpp
@@ -213,8 +213,8 @@ Ice::PluginManagerI::destroy() noexcept
     _plugins.clear();
 }
 
-Ice::PluginManagerI::PluginManagerI(const CommunicatorPtr& communicator)
-    : _communicator(communicator),
+Ice::PluginManagerI::PluginManagerI(CommunicatorPtr communicator)
+    : _communicator(std::move(communicator)),
       _initialized(false)
 {
 }
diff --git a/cpp/src/Ice/PluginManagerI.h b/cpp/src/Ice/PluginManagerI.h
index 7dc08caed1f..31916a5f8c8 100644
--- a/cpp/src/Ice/PluginManagerI.h
+++ b/cpp/src/Ice/PluginManagerI.h
@@ -30,7 +30,7 @@ namespace Ice
         void destroy() noexcept final;
 
         // Constructs the plugin manager (internal).
-        PluginManagerI(const CommunicatorPtr&);
+        PluginManagerI(CommunicatorPtr);
 
         // Loads all the plugins (internal).
         // Returns true when one or more libraries may have been loaded dynamically; returns false when definitely no
diff --git a/cpp/src/Ice/ProtocolInstance.cpp b/cpp/src/Ice/ProtocolInstance.cpp
index 5fde68b4d5b..efef48e8fb2 100644
--- a/cpp/src/Ice/ProtocolInstance.cpp
+++ b/cpp/src/Ice/ProtocolInstance.cpp
@@ -19,31 +19,23 @@ IceInternal::ProtocolInstance::~ProtocolInstance()
     // Out of line to avoid weak vtable
 }
 
-IceInternal::ProtocolInstance::ProtocolInstance(
-    const CommunicatorPtr& com,
-    int16_t type,
-    const string& protocol,
-    bool secure)
+IceInternal::ProtocolInstance::ProtocolInstance(const CommunicatorPtr& com, int16_t type, string protocol, bool secure)
     : _instance(getInstance(com)),
       _traceLevel(_instance.lock()->traceLevels()->network),
       _traceCategory(_instance.lock()->traceLevels()->networkCat),
       _properties(_instance.lock()->initializationData().properties),
-      _protocol(protocol),
+      _protocol(std::move(protocol)),
       _type(type),
       _secure(secure)
 {
 }
 
-IceInternal::ProtocolInstance::ProtocolInstance(
-    const InstancePtr& instance,
-    int16_t type,
-    const string& protocol,
-    bool secure)
+IceInternal::ProtocolInstance::ProtocolInstance(const InstancePtr& instance, int16_t type, string protocol, bool secure)
     : _instance(instance),
       _traceLevel(instance->traceLevels()->network),
       _traceCategory(instance->traceLevels()->networkCat),
       _properties(instance->initializationData().properties),
-      _protocol(protocol),
+      _protocol(std::move(protocol)),
       _type(type),
       _secure(secure)
 {
diff --git a/cpp/src/Ice/ProtocolInstance.h b/cpp/src/Ice/ProtocolInstance.h
index c68ba99d6a0..adae46489ba 100644
--- a/cpp/src/Ice/ProtocolInstance.h
+++ b/cpp/src/Ice/ProtocolInstance.h
@@ -23,7 +23,7 @@ namespace IceInternal
     public:
         virtual ~ProtocolInstance();
 
-        ProtocolInstance(const Ice::CommunicatorPtr&, std::int16_t, const std::string&, bool);
+        ProtocolInstance(const Ice::CommunicatorPtr&, std::int16_t, std::string, bool);
 
         [[nodiscard]] int traceLevel() const { return _traceLevel; }
 
@@ -60,7 +60,7 @@ namespace IceInternal
             std::function<void(std::exception_ptr)>) const;
 
     protected:
-        ProtocolInstance(const InstancePtr&, std::int16_t, const std::string&, bool);
+        ProtocolInstance(const InstancePtr&, std::int16_t, std::string, bool);
         friend class Instance;
         // Use a weak pointer to avoid circular references. The communicator owns the endpoint factory, which in
         // turn own this protocol instance.
diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp
index 998f33be258..829404b333a 100644
--- a/cpp/src/Ice/Reference.cpp
+++ b/cpp/src/Ice/Reference.cpp
@@ -1439,10 +1439,10 @@ IceInternal::RoutableReference::getConnectionNoRouterInfoAsync(
         void setException(std::exception_ptr ex) final { _exception(ex); }
 
         Callback(
-            const RoutableReferencePtr& reference,
+            RoutableReferencePtr reference,
             function<void(ConnectionIPtr, bool)> response,
             function<void(std::exception_ptr)> exception)
-            : _reference(reference),
+            : _reference(std::move(reference)),
               _response(std::move(response)),
               _exception(std::move(exception))
         {
diff --git a/cpp/src/Ice/RetryQueue.cpp b/cpp/src/Ice/RetryQueue.cpp
index 65718856d09..3721f1ac0a8 100644
--- a/cpp/src/Ice/RetryQueue.cpp
+++ b/cpp/src/Ice/RetryQueue.cpp
@@ -15,13 +15,10 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceInternal::RetryTask::RetryTask(
-    const InstancePtr& instance,
-    const RetryQueuePtr& queue,
-    const ProxyOutgoingAsyncBasePtr& outAsync)
-    : _instance(instance),
-      _queue(queue),
-      _outAsync(outAsync)
+IceInternal::RetryTask::RetryTask(InstancePtr instance, RetryQueuePtr queue, ProxyOutgoingAsyncBasePtr outAsync)
+    : _instance(std::move(instance)),
+      _queue(std::move(queue)),
+      _outAsync(std::move(outAsync))
 {
 }
 
@@ -76,7 +73,7 @@ IceInternal::RetryTask::destroy()
     }
 }
 
-IceInternal::RetryQueue::RetryQueue(const InstancePtr& instance) : _instance(instance) {}
+IceInternal::RetryQueue::RetryQueue(InstancePtr instance) : _instance(std::move(instance)) {}
 
 void
 IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
diff --git a/cpp/src/Ice/RetryQueue.h b/cpp/src/Ice/RetryQueue.h
index af0a15fe054..458eab11b0a 100644
--- a/cpp/src/Ice/RetryQueue.h
+++ b/cpp/src/Ice/RetryQueue.h
@@ -23,7 +23,7 @@ namespace IceInternal
     class RetryTask : public TimerTask, public CancellationHandler, public std::enable_shared_from_this<RetryTask>
     {
     public:
-        RetryTask(const InstancePtr&, const RetryQueuePtr&, const ProxyOutgoingAsyncBasePtr&);
+        RetryTask(InstancePtr, RetryQueuePtr, ProxyOutgoingAsyncBasePtr);
 
         void runTimerTask() override;
 
@@ -41,7 +41,7 @@ namespace IceInternal
     class RetryQueue : public std::enable_shared_from_this<RetryQueue>
     {
     public:
-        RetryQueue(const InstancePtr&);
+        RetryQueue(InstancePtr);
 
         void add(const ProxyOutgoingAsyncBasePtr&, int);
         void destroy();
diff --git a/cpp/src/Ice/RouterInfo.cpp b/cpp/src/Ice/RouterInfo.cpp
index 1c9906b773d..57f251bd617 100644
--- a/cpp/src/Ice/RouterInfo.cpp
+++ b/cpp/src/Ice/RouterInfo.cpp
@@ -85,7 +85,7 @@ IceInternal::RouterManager::erase(const RouterPrx& router)
     }
 }
 
-IceInternal::RouterInfo::RouterInfo(const RouterPrx& router) : _router(router), _hasRoutingTable(false) {}
+IceInternal::RouterInfo::RouterInfo(RouterPrx router) : _router(std::move(router)), _hasRoutingTable(false) {}
 
 void
 IceInternal::RouterInfo::destroy()
diff --git a/cpp/src/Ice/RouterInfo.h b/cpp/src/Ice/RouterInfo.h
index 16e4c580ce0..c208cc0cb76 100644
--- a/cpp/src/Ice/RouterInfo.h
+++ b/cpp/src/Ice/RouterInfo.h
@@ -48,7 +48,7 @@ namespace IceInternal
     class RouterInfo final : public std::enable_shared_from_this<RouterInfo>
     {
     public:
-        RouterInfo(const Ice::RouterPrx&);
+        RouterInfo(Ice::RouterPrx);
 
         void destroy();
 
diff --git a/cpp/src/Ice/SSL/DistinguishedName.h b/cpp/src/Ice/SSL/DistinguishedName.h
index 275b03395a5..e7ad4d0b248 100644
--- a/cpp/src/Ice/SSL/DistinguishedName.h
+++ b/cpp/src/Ice/SSL/DistinguishedName.h
@@ -9,7 +9,6 @@
 
 #include <list>
 #include <string>
-#include <utility>
 
 namespace Ice::SSL
 {
diff --git a/cpp/src/Ice/SSL/RFC2253.cpp b/cpp/src/Ice/SSL/RFC2253.cpp
index 24fb43e746c..2a0350ec9ee 100644
--- a/cpp/src/Ice/SSL/RFC2253.cpp
+++ b/cpp/src/Ice/SSL/RFC2253.cpp
@@ -9,7 +9,6 @@
 
 #include <cassert>
 #include <string>
-#include <utility>
 
 using namespace std;
 using namespace Ice::SSL;
diff --git a/cpp/src/Ice/SSL/SSLAcceptorI.cpp b/cpp/src/Ice/SSL/SSLAcceptorI.cpp
index e7e3941f68c..1b43bee5a91 100644
--- a/cpp/src/Ice/SSL/SSLAcceptorI.cpp
+++ b/cpp/src/Ice/SSL/SSLAcceptorI.cpp
@@ -112,15 +112,15 @@ Ice::SSL::AcceptorI::toDetailedString() const
 }
 
 Ice::SSL::AcceptorI::AcceptorI(
-    const EndpointIPtr& endpoint,
-    const InstancePtr& instance,
-    const IceInternal::AcceptorPtr& del,
-    const string& adapterName,
+    EndpointIPtr endpoint,
+    InstancePtr instance,
+    IceInternal::AcceptorPtr del,
+    string adapterName,
     const optional<Ice::SSL::ServerAuthenticationOptions>& serverAuthenticationOptions)
-    : _endpoint(endpoint),
-      _instance(instance),
-      _delegate(del),
-      _adapterName(adapterName),
+    : _endpoint(std::move(endpoint)),
+      _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _adapterName(std::move(adapterName)),
       _serverAuthenticationOptions(serverAuthenticationOptions)
 {
 }
diff --git a/cpp/src/Ice/SSL/SSLAcceptorI.h b/cpp/src/Ice/SSL/SSLAcceptorI.h
index 6d4aa7d53f8..e5b5af1e88c 100644
--- a/cpp/src/Ice/SSL/SSLAcceptorI.h
+++ b/cpp/src/Ice/SSL/SSLAcceptorI.h
@@ -20,10 +20,10 @@ namespace Ice::SSL
     {
     public:
         AcceptorI(
-            const EndpointIPtr&,
-            const InstancePtr&,
-            const IceInternal::AcceptorPtr&,
-            const std::string&,
+            EndpointIPtr,
+            InstancePtr,
+            IceInternal::AcceptorPtr,
+            std::string,
             const std::optional<Ice::SSL::ServerAuthenticationOptions>&);
         ~AcceptorI() override;
         IceInternal::NativeInfoPtr getNativeInfo() final;
diff --git a/cpp/src/Ice/SSL/SSLConnectorI.cpp b/cpp/src/Ice/SSL/SSLConnectorI.cpp
index 56ff0b55ae9..e468c00f9f9 100644
--- a/cpp/src/Ice/SSL/SSLConnectorI.cpp
+++ b/cpp/src/Ice/SSL/SSLConnectorI.cpp
@@ -3,8 +3,6 @@
 //
 
 #include "SSLConnectorI.h"
-#include "SSLInstance.h"
-
 #include "../NetworkProxy.h"
 #include "../StreamSocket.h"
 #include "Ice/Communicator.h"
@@ -13,6 +11,7 @@
 #include "Ice/SSL/ClientAuthenticationOptions.h"
 #include "SSLEndpointI.h"
 #include "SSLEngine.h"
+#include "SSLInstance.h"
 #include "SSLUtil.h"
 
 #if defined(ICE_USE_SCHANNEL)
@@ -92,10 +91,10 @@ Ice::SSL::ConnectorI::operator<(const IceInternal::Connector& r) const
     return Ice::targetLess(_delegate, p->_delegate);
 }
 
-Ice::SSL::ConnectorI::ConnectorI(const InstancePtr& instance, const IceInternal::ConnectorPtr& del, const string& h)
-    : _instance(instance),
-      _delegate(del),
-      _host(h)
+Ice::SSL::ConnectorI::ConnectorI(InstancePtr instance, IceInternal::ConnectorPtr del, string h)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _host(std::move(h))
 {
 }
 
diff --git a/cpp/src/Ice/SSL/SSLConnectorI.h b/cpp/src/Ice/SSL/SSLConnectorI.h
index 901b2d5fa0a..700fe3df683 100644
--- a/cpp/src/Ice/SSL/SSLConnectorI.h
+++ b/cpp/src/Ice/SSL/SSLConnectorI.h
@@ -8,7 +8,6 @@
 #include "../Connector.h"
 #include "../Network.h"
 #include "../TransceiverF.h"
-
 #include "SSLInstanceF.h"
 
 namespace Ice::SSL
@@ -18,7 +17,7 @@ namespace Ice::SSL
     class ConnectorI final : public IceInternal::Connector
     {
     public:
-        ConnectorI(const InstancePtr&, const IceInternal::ConnectorPtr&, const std::string&);
+        ConnectorI(InstancePtr, IceInternal::ConnectorPtr, std::string);
         ~ConnectorI() override;
         IceInternal::TransceiverPtr connect() final;
 
diff --git a/cpp/src/Ice/SSL/SSLEndpointI.cpp b/cpp/src/Ice/SSL/SSLEndpointI.cpp
index 9973260c7fe..ca55daada05 100644
--- a/cpp/src/Ice/SSL/SSLEndpointI.cpp
+++ b/cpp/src/Ice/SSL/SSLEndpointI.cpp
@@ -81,9 +81,9 @@ Ice::SSL::EndpointInfo::~EndpointInfo()
     // out of line to avoid weak vtable
 }
 
-Ice::SSL::EndpointI::EndpointI(const InstancePtr& instance, const IceInternal::EndpointIPtr& del)
-    : _instance(instance),
-      _delegate(del)
+Ice::SSL::EndpointI::EndpointI(InstancePtr instance, IceInternal::EndpointIPtr del)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del))
 {
 }
 
diff --git a/cpp/src/Ice/SSL/SSLEndpointI.h b/cpp/src/Ice/SSL/SSLEndpointI.h
index 93ef6d80627..2a956bdc2fa 100644
--- a/cpp/src/Ice/SSL/SSLEndpointI.h
+++ b/cpp/src/Ice/SSL/SSLEndpointI.h
@@ -18,7 +18,7 @@ namespace Ice::SSL
     class EndpointI final : public IceInternal::EndpointI, public std::enable_shared_from_this<EndpointI>
     {
     public:
-        EndpointI(const InstancePtr&, const IceInternal::EndpointIPtr&);
+        EndpointI(InstancePtr, IceInternal::EndpointIPtr);
 
         void streamWriteImpl(Ice::OutputStream*) const final;
 
diff --git a/cpp/src/Ice/SSL/SSLUtil.h b/cpp/src/Ice/SSL/SSLUtil.h
index 6942e5057ca..c353c07d22e 100644
--- a/cpp/src/Ice/SSL/SSLUtil.h
+++ b/cpp/src/Ice/SSL/SSLUtil.h
@@ -10,7 +10,6 @@
 
 #include <optional>
 #include <string>
-#include <utility>
 #include <vector>
 
 namespace Ice::SSL
diff --git a/cpp/src/Ice/SSL/SecureTransportTransceiverI.cpp b/cpp/src/Ice/SSL/SecureTransportTransceiverI.cpp
index fe2757db3c0..7425609d704 100644
--- a/cpp/src/Ice/SSL/SecureTransportTransceiverI.cpp
+++ b/cpp/src/Ice/SSL/SecureTransportTransceiverI.cpp
@@ -11,6 +11,7 @@
 #include "SecureTransportUtil.h"
 
 #include <sstream>
+#include <utility>
 
 // Disable deprecation warnings from SecureTransport APIs
 #include "../DisableWarnings.h"
@@ -535,15 +536,15 @@ Ice::SSL::SecureTransport::TransceiverI::setBufferSize(int rcvSize, int sndSize)
 
 Ice::SSL::SecureTransport::TransceiverI::TransceiverI(
     const Ice::SSL::InstancePtr& instance,
-    const IceInternal::TransceiverPtr& delegate,
-    const string& adapterName,
+    IceInternal::TransceiverPtr delegate,
+    string adapterName,
     const ServerAuthenticationOptions& serverAuthenticationOptions)
     : _instance(instance),
       _engine(dynamic_pointer_cast<Ice::SSL::SecureTransport::SSLEngine>(instance->engine())),
       _host(""),
-      _adapterName(adapterName),
+      _adapterName(std::move(adapterName)),
       _incoming(true),
-      _delegate(delegate),
+      _delegate(std::move(delegate)),
       _connected(false),
       _buffered(0),
       _sslNewSessionCallback(serverAuthenticationOptions.sslNewSessionCallback),
@@ -557,15 +558,15 @@ Ice::SSL::SecureTransport::TransceiverI::TransceiverI(
 
 Ice::SSL::SecureTransport::TransceiverI::TransceiverI(
     const Ice::SSL::InstancePtr& instance,
-    const IceInternal::TransceiverPtr& delegate,
-    const string& host,
+    IceInternal::TransceiverPtr delegate,
+    string host,
     const ClientAuthenticationOptions& clientAuthenticationOptions)
     : _instance(instance),
       _engine(dynamic_pointer_cast<Ice::SSL::SecureTransport::SSLEngine>(instance->engine())),
-      _host(host),
+      _host(std::move(host)),
       _adapterName(""),
       _incoming(false),
-      _delegate(delegate),
+      _delegate(std::move(delegate)),
       _connected(false),
       _buffered(0),
       _sslNewSessionCallback(clientAuthenticationOptions.sslNewSessionCallback),
diff --git a/cpp/src/Ice/SSL/SecureTransportTransceiverI.h b/cpp/src/Ice/SSL/SecureTransportTransceiverI.h
index d7c248ac12b..b2a19cc39f0 100644
--- a/cpp/src/Ice/SSL/SecureTransportTransceiverI.h
+++ b/cpp/src/Ice/SSL/SecureTransportTransceiverI.h
@@ -27,13 +27,13 @@ namespace Ice::SSL::SecureTransport
     public:
         TransceiverI(
             const InstancePtr&,
-            const IceInternal::TransceiverPtr&,
-            const std::string&,
+            IceInternal::TransceiverPtr,
+            std::string,
             const Ice::SSL::ServerAuthenticationOptions&);
         TransceiverI(
             const InstancePtr&,
-            const IceInternal::TransceiverPtr&,
-            const std::string&,
+            IceInternal::TransceiverPtr,
+            std::string,
             const Ice::SSL::ClientAuthenticationOptions&);
         ~TransceiverI();
 
diff --git a/cpp/src/Ice/SSL/TrustManager.cpp b/cpp/src/Ice/SSL/TrustManager.cpp
index 14e88a33f2e..fe73b18d1c1 100644
--- a/cpp/src/Ice/SSL/TrustManager.cpp
+++ b/cpp/src/Ice/SSL/TrustManager.cpp
@@ -17,7 +17,7 @@
 using namespace std;
 using namespace Ice::SSL;
 
-TrustManager::TrustManager(const IceInternal::InstancePtr& instance) : _instance(instance)
+TrustManager::TrustManager(IceInternal::InstancePtr instance) : _instance(std::move(instance))
 {
     Ice::PropertiesPtr properties = _instance->initializationData().properties;
     _traceLevel = properties->getIcePropertyAsInt("IceSSL.Trace.Security");
diff --git a/cpp/src/Ice/SSL/TrustManager.h b/cpp/src/Ice/SSL/TrustManager.h
index 27eddacc2c6..cfa89084fad 100644
--- a/cpp/src/Ice/SSL/TrustManager.h
+++ b/cpp/src/Ice/SSL/TrustManager.h
@@ -19,7 +19,7 @@ namespace Ice::SSL
     class TrustManager
     {
     public:
-        TrustManager(const IceInternal::InstancePtr&);
+        TrustManager(IceInternal::InstancePtr);
 
         [[nodiscard]] bool verify(const ConnectionInfoPtr&) const;
 
diff --git a/cpp/src/Ice/Selector.cpp b/cpp/src/Ice/Selector.cpp
index f80e54d8e13..16be1118577 100644
--- a/cpp/src/Ice/Selector.cpp
+++ b/cpp/src/Ice/Selector.cpp
@@ -174,7 +174,7 @@ Selector::completed(EventHandler* handler, SocketOperation op)
 
 #elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL) || defined(ICE_USE_POLL)
 
-Selector::Selector(const InstancePtr& instance) : _instance(instance), _interrupted(false)
+Selector::Selector(InstancePtr instance) : _instance(std::move(instance)), _interrupted(false)
 {
     SOCKET fds[2];
     createPipe(fds);
diff --git a/cpp/src/Ice/Selector.h b/cpp/src/Ice/Selector.h
index bbe0c4fe0db..c69afd182cc 100644
--- a/cpp/src/Ice/Selector.h
+++ b/cpp/src/Ice/Selector.h
@@ -5,10 +5,9 @@
 #ifndef ICE_SELECTOR_H
 #define ICE_SELECTOR_H
 
-#include "Ice/StringUtil.h"
-
 #include "EventHandlerF.h"
 #include "Ice/InstanceF.h"
+#include "Ice/StringUtil.h"
 #include "Network.h"
 #include "UniqueRef.h"
 
@@ -79,7 +78,7 @@ namespace IceInternal
     class Selector final
     {
     public:
-        Selector(const InstancePtr&);
+        Selector(InstancePtr);
 
         void destroy();
 
diff --git a/cpp/src/Ice/SharedContext.h b/cpp/src/Ice/SharedContext.h
index 7720bc85044..3ebee210c81 100644
--- a/cpp/src/Ice/SharedContext.h
+++ b/cpp/src/Ice/SharedContext.h
@@ -21,7 +21,7 @@ namespace IceInternal
     public:
         SharedContext() {}
 
-        SharedContext(const Ice::Context& val) : _val(val) {}
+        SharedContext(Ice::Context val) : _val(std::move(val)) {}
 
         inline const Ice::Context& getValue() { return _val; }
 
diff --git a/cpp/src/Ice/StreamSocket.cpp b/cpp/src/Ice/StreamSocket.cpp
index 282fe316869..2c555c1241b 100644
--- a/cpp/src/Ice/StreamSocket.cpp
+++ b/cpp/src/Ice/StreamSocket.cpp
@@ -9,12 +9,12 @@
 using namespace IceInternal;
 
 StreamSocket::StreamSocket(
-    const ProtocolInstancePtr& instance,
+    ProtocolInstancePtr instance,
     const NetworkProxyPtr& proxy,
     const Address& addr,
     const Address& sourceAddr)
     : NativeInfo(createSocket(false, proxy ? proxy->getAddress() : addr)),
-      _instance(instance),
+      _instance(std::move(instance)),
       _proxy(proxy),
       _addr(addr),
       _sourceAddr(sourceAddr),
@@ -43,9 +43,9 @@ StreamSocket::StreamSocket(
     }
 }
 
-StreamSocket::StreamSocket(const ProtocolInstancePtr& instance, SOCKET fd)
+StreamSocket::StreamSocket(ProtocolInstancePtr instance, SOCKET fd)
     : NativeInfo(fd),
-      _instance(instance),
+      _instance(std::move(instance)),
       _addr(),
       _sourceAddr(),
       _state(StateConnected)
diff --git a/cpp/src/Ice/StreamSocket.h b/cpp/src/Ice/StreamSocket.h
index 2ed2da71744..d2ac1c0c832 100644
--- a/cpp/src/Ice/StreamSocket.h
+++ b/cpp/src/Ice/StreamSocket.h
@@ -16,8 +16,8 @@ namespace IceInternal
     class ICE_API StreamSocket : public NativeInfo
     {
     public:
-        StreamSocket(const ProtocolInstancePtr&, const NetworkProxyPtr&, const Address&, const Address&);
-        StreamSocket(const ProtocolInstancePtr&, SOCKET);
+        StreamSocket(ProtocolInstancePtr, const NetworkProxyPtr&, const Address&, const Address&);
+        StreamSocket(ProtocolInstancePtr, SOCKET);
         ~StreamSocket() override;
 
         SocketOperation connect(Buffer&, Buffer&);
diff --git a/cpp/src/Ice/TcpAcceptor.cpp b/cpp/src/Ice/TcpAcceptor.cpp
index 58e490234f6..4d4b5f62fbe 100644
--- a/cpp/src/Ice/TcpAcceptor.cpp
+++ b/cpp/src/Ice/TcpAcceptor.cpp
@@ -13,8 +13,10 @@
 #    include "ProtocolInstance.h"
 #    include "StreamSocket.h"
 #    include "TcpAcceptor.h"
+
 #    include "TcpEndpointI.h"
 #    include "TcpTransceiver.h"
+#    include <utility>
 
 #    if defined(ICE_USE_IOCP)
 #        include <Mswsock.h>
@@ -178,11 +180,11 @@ IceInternal::TcpAcceptor::effectivePort() const
 }
 
 IceInternal::TcpAcceptor::TcpAcceptor(
-    const TcpEndpointIPtr& endpoint,
+    TcpEndpointIPtr endpoint,
     const ProtocolInstancePtr& instance,
     const string& host,
     int port)
-    : _endpoint(endpoint),
+    : _endpoint(std::move(endpoint)),
       _instance(instance),
       _addr(getAddressForServer(host, port, _instance->protocolSupport(), instance->preferIPv6(), true))
 #    ifdef ICE_USE_IOCP
diff --git a/cpp/src/Ice/TcpAcceptor.h b/cpp/src/Ice/TcpAcceptor.h
index 492fa2612b5..4b7f2d7c315 100644
--- a/cpp/src/Ice/TcpAcceptor.h
+++ b/cpp/src/Ice/TcpAcceptor.h
@@ -17,7 +17,7 @@ namespace IceInternal
     class TcpAcceptor final : public Acceptor, public NativeInfo, public std::enable_shared_from_this<TcpAcceptor>
     {
     public:
-        TcpAcceptor(const TcpEndpointIPtr&, const ProtocolInstancePtr&, const std::string&, int);
+        TcpAcceptor(TcpEndpointIPtr, const ProtocolInstancePtr&, const std::string&, int);
         ~TcpAcceptor() override;
         NativeInfoPtr getNativeInfo() final;
 #if defined(ICE_USE_IOCP)
diff --git a/cpp/src/Ice/TcpConnector.cpp b/cpp/src/Ice/TcpConnector.cpp
index ee264183a7a..0f149787677 100644
--- a/cpp/src/Ice/TcpConnector.cpp
+++ b/cpp/src/Ice/TcpConnector.cpp
@@ -12,8 +12,10 @@
 #    include "ProtocolInstance.h"
 #    include "StreamSocket.h"
 #    include "TcpConnector.h"
+
 #    include "TcpEndpointI.h"
 #    include "TcpTransceiver.h"
+#    include <utility>
 
 using namespace std;
 using namespace Ice;
@@ -109,18 +111,18 @@ IceInternal::TcpConnector::operator<(const Connector& r) const
 }
 
 IceInternal::TcpConnector::TcpConnector(
-    const ProtocolInstancePtr& instance,
+    ProtocolInstancePtr instance,
     const Address& addr,
-    const NetworkProxyPtr& proxy,
+    NetworkProxyPtr proxy,
     const Address& sourceAddr,
     int32_t timeout,
-    const string& connectionId)
-    : _instance(instance),
+    string connectionId)
+    : _instance(std::move(instance)),
       _addr(addr),
-      _proxy(proxy),
+      _proxy(std::move(proxy)),
       _sourceAddr(sourceAddr),
       _timeout(timeout),
-      _connectionId(connectionId)
+      _connectionId(std::move(connectionId))
 {
 }
 
diff --git a/cpp/src/Ice/TcpConnector.h b/cpp/src/Ice/TcpConnector.h
index cce4a778b65..eabc944668e 100644
--- a/cpp/src/Ice/TcpConnector.h
+++ b/cpp/src/Ice/TcpConnector.h
@@ -15,13 +15,7 @@ namespace IceInternal
     class TcpConnector final : public Connector
     {
     public:
-        TcpConnector(
-            const ProtocolInstancePtr&,
-            const Address&,
-            const NetworkProxyPtr&,
-            const Address&,
-            std::int32_t,
-            const std::string&);
+        TcpConnector(ProtocolInstancePtr, const Address&, NetworkProxyPtr, const Address&, std::int32_t, std::string);
         ~TcpConnector() override;
         TransceiverPtr connect() final;
 
diff --git a/cpp/src/Ice/TcpEndpointI.cpp b/cpp/src/Ice/TcpEndpointI.cpp
index 7574c068e99..f0dcfe1c34c 100644
--- a/cpp/src/Ice/TcpEndpointI.cpp
+++ b/cpp/src/Ice/TcpEndpointI.cpp
@@ -15,7 +15,9 @@
 #    include "TcpAcceptor.h"
 #    include "TcpConnector.h"
 #    include "TcpEndpointI.h"
+
 #    include "TcpTransceiver.h"
+#    include <utility>
 
 using namespace std;
 using namespace Ice;
@@ -353,7 +355,7 @@ IceInternal::TcpEndpointI::createEndpoint(const string& host, int port, const st
     return make_shared<TcpEndpointI>(_instance, host, port, _sourceAddr, _timeout, connectionId, _compress);
 }
 
-IceInternal::TcpEndpointFactory::TcpEndpointFactory(const ProtocolInstancePtr& instance) : _instance(instance) {}
+IceInternal::TcpEndpointFactory::TcpEndpointFactory(ProtocolInstancePtr instance) : _instance(std::move(instance)) {}
 
 IceInternal::TcpEndpointFactory::~TcpEndpointFactory() {}
 
diff --git a/cpp/src/Ice/TcpEndpointI.h b/cpp/src/Ice/TcpEndpointI.h
index e8b4930523d..4b552b71842 100644
--- a/cpp/src/Ice/TcpEndpointI.h
+++ b/cpp/src/Ice/TcpEndpointI.h
@@ -70,7 +70,7 @@ namespace IceInternal
     class TcpEndpointFactory final : public EndpointFactory
     {
     public:
-        TcpEndpointFactory(const ProtocolInstancePtr&);
+        TcpEndpointFactory(ProtocolInstancePtr);
         ~TcpEndpointFactory() override;
 
         [[nodiscard]] std::int16_t type() const final;
diff --git a/cpp/src/Ice/TcpTransceiver.cpp b/cpp/src/Ice/TcpTransceiver.cpp
index 1105283bd71..5e337b385d5 100644
--- a/cpp/src/Ice/TcpTransceiver.cpp
+++ b/cpp/src/Ice/TcpTransceiver.cpp
@@ -13,6 +13,8 @@
 #    include "ProtocolInstance.h"
 #    include "TcpTransceiver.h"
 
+#    include <utility>
+
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
@@ -137,9 +139,9 @@ IceInternal::TcpTransceiver::setBufferSize(int rcvSize, int sndSize)
     _stream->setBufferSize(rcvSize, sndSize);
 }
 
-IceInternal::TcpTransceiver::TcpTransceiver(const ProtocolInstancePtr& instance, const StreamSocketPtr& stream)
-    : _instance(instance),
-      _stream(stream)
+IceInternal::TcpTransceiver::TcpTransceiver(ProtocolInstancePtr instance, StreamSocketPtr stream)
+    : _instance(std::move(instance)),
+      _stream(std::move(stream))
 {
 }
 
diff --git a/cpp/src/Ice/TcpTransceiver.h b/cpp/src/Ice/TcpTransceiver.h
index 2d482761f43..81a8e5e2edb 100644
--- a/cpp/src/Ice/TcpTransceiver.h
+++ b/cpp/src/Ice/TcpTransceiver.h
@@ -18,7 +18,7 @@ namespace IceInternal
     class TcpTransceiver final : public Transceiver
     {
     public:
-        TcpTransceiver(const ProtocolInstancePtr&, const StreamSocketPtr&);
+        TcpTransceiver(ProtocolInstancePtr, StreamSocketPtr);
         ~TcpTransceiver();
         NativeInfoPtr getNativeInfo() final;
 
diff --git a/cpp/src/Ice/ThreadPool.cpp b/cpp/src/Ice/ThreadPool.cpp
index 707fc40bceb..cc2453371ab 100644
--- a/cpp/src/Ice/ThreadPool.cpp
+++ b/cpp/src/Ice/ThreadPool.cpp
@@ -147,11 +147,11 @@ IceInternal::ThreadPool::create(const InstancePtr& instance, const string& prefi
     return threadPool;
 }
 
-IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& prefix, int timeout)
+IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, string prefix, int timeout)
     : _instance(instance),
       _executor(_instance->initializationData().executor),
       _destroyed(false),
-      _prefix(prefix),
+      _prefix(std::move(prefix)),
       _selector(instance),
       _nextThreadId(0),
       _size(0),
@@ -323,9 +323,9 @@ IceInternal::ThreadPool::initialize(const EventHandlerPtr& handler)
     class ReadyCallbackI final : public ReadyCallback
     {
     public:
-        ReadyCallbackI(const ThreadPoolPtr& threadPool, const EventHandlerPtr& handler)
-            : _threadPool(threadPool),
-              _handler(handler)
+        ReadyCallbackI(ThreadPoolPtr threadPool, EventHandlerPtr handler)
+            : _threadPool(std::move(threadPool)),
+              _handler(std::move(handler))
         {
         }
 
@@ -1012,9 +1012,9 @@ IceInternal::ThreadPool::shutdown(const ThreadPoolCurrent& current, const Instan
     }
 }
 
-IceInternal::ThreadPool::EventHandlerThread::EventHandlerThread(const ThreadPoolPtr& pool, const string& name)
-    : _name(name),
-      _pool(pool),
+IceInternal::ThreadPool::EventHandlerThread::EventHandlerThread(ThreadPoolPtr pool, string name)
+    : _name(std::move(name)),
+      _pool(std::move(pool)),
       _state(ThreadState::ThreadStateIdle)
 {
     updateObserver();
@@ -1122,10 +1122,10 @@ IceInternal::ThreadPool::EventHandlerThread::join()
     }
 }
 
-ThreadPoolCurrent::ThreadPoolCurrent(const ThreadPoolPtr& threadPool, const ThreadPool::EventHandlerThreadPtr& thread)
+ThreadPoolCurrent::ThreadPoolCurrent(const ThreadPoolPtr& threadPool, ThreadPool::EventHandlerThreadPtr thread)
     : operation(SocketOperationNone),
       _threadPool(threadPool.get()),
-      _thread(thread),
+      _thread(std::move(thread)),
       _ioCompleted(false)
 #if !defined(ICE_USE_IOCP)
       ,
diff --git a/cpp/src/Ice/ThreadPool.h b/cpp/src/Ice/ThreadPool.h
index 6ce12571009..5d2030d2d1e 100644
--- a/cpp/src/Ice/ThreadPool.h
+++ b/cpp/src/Ice/ThreadPool.h
@@ -32,7 +32,7 @@ namespace IceInternal
         class EventHandlerThread final : public std::enable_shared_from_this<EventHandlerThread>
         {
         public:
-            EventHandlerThread(const ThreadPoolPtr&, const std::string&);
+            EventHandlerThread(ThreadPoolPtr, std::string);
             void start();
             void run();
             void join();
@@ -78,7 +78,7 @@ namespace IceInternal
         [[nodiscard]] std::string prefix() const;
 
     private:
-        ThreadPool(const InstancePtr&, const std::string&, int);
+        ThreadPool(const InstancePtr&, std::string, int);
         void initialize();
 
         void run(const EventHandlerThreadPtr&);
@@ -136,7 +136,7 @@ namespace IceInternal
     class ThreadPoolCurrent
     {
     public:
-        ThreadPoolCurrent(const ThreadPoolPtr&, const ThreadPool::EventHandlerThreadPtr&);
+        ThreadPoolCurrent(const ThreadPoolPtr&, ThreadPool::EventHandlerThreadPtr);
 
         SocketOperation operation;
 
diff --git a/cpp/src/Ice/UdpConnector.cpp b/cpp/src/Ice/UdpConnector.cpp
index 46095f13b8f..60d18b2b6e1 100644
--- a/cpp/src/Ice/UdpConnector.cpp
+++ b/cpp/src/Ice/UdpConnector.cpp
@@ -115,18 +115,18 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
 }
 
 IceInternal::UdpConnector::UdpConnector(
-    const ProtocolInstancePtr& instance,
+    ProtocolInstancePtr instance,
     const Address& addr,
     const Address& sourceAddr,
-    const string& mcastInterface,
+    string mcastInterface,
     int mcastTtl,
-    const std::string& connectionId)
-    : _instance(instance),
+    std::string connectionId)
+    : _instance(std::move(instance)),
       _addr(addr),
       _sourceAddr(sourceAddr),
-      _mcastInterface(mcastInterface),
+      _mcastInterface(std::move(mcastInterface)),
       _mcastTtl(mcastTtl),
-      _connectionId(connectionId)
+      _connectionId(std::move(connectionId))
 {
 }
 
diff --git a/cpp/src/Ice/UdpConnector.h b/cpp/src/Ice/UdpConnector.h
index b7677869991..b1981d8ac02 100644
--- a/cpp/src/Ice/UdpConnector.h
+++ b/cpp/src/Ice/UdpConnector.h
@@ -15,13 +15,7 @@ namespace IceInternal
     class UdpConnector final : public Connector
     {
     public:
-        UdpConnector(
-            const ProtocolInstancePtr&,
-            const Address&,
-            const Address&,
-            const std::string&,
-            int,
-            const std::string&);
+        UdpConnector(ProtocolInstancePtr, const Address&, const Address&, std::string, int, std::string);
 
         ~UdpConnector() override;
         TransceiverPtr connect() final;
diff --git a/cpp/src/Ice/UdpEndpointI.cpp b/cpp/src/Ice/UdpEndpointI.cpp
index 6d576f3b9a4..e4893197fe3 100644
--- a/cpp/src/Ice/UdpEndpointI.cpp
+++ b/cpp/src/Ice/UdpEndpointI.cpp
@@ -40,13 +40,13 @@ IceInternal::UdpEndpointI::UdpEndpointI(
     const string& host,
     int32_t port,
     const Address& sourceAddr,
-    const string& mcastInterface,
+    string mcastInterface,
     int32_t mttl,
     const string& connectionId,
     bool compress)
     : IPEndpointI(instance, host, port, sourceAddr, connectionId),
       _mcastTtl(mttl),
-      _mcastInterface(mcastInterface),
+      _mcastInterface(std::move(mcastInterface)),
       _compress(compress)
 {
 }
@@ -435,7 +435,7 @@ IceInternal::UdpEndpointI::createEndpoint(const string& host, int port, const st
         UdpEndpointI>(_instance, host, port, _sourceAddr, _mcastInterface, _mcastTtl, connectionId, _compress);
 }
 
-IceInternal::UdpEndpointFactory::UdpEndpointFactory(const ProtocolInstancePtr& instance) : _instance(instance) {}
+IceInternal::UdpEndpointFactory::UdpEndpointFactory(ProtocolInstancePtr instance) : _instance(std::move(instance)) {}
 
 IceInternal::UdpEndpointFactory::~UdpEndpointFactory() {}
 
diff --git a/cpp/src/Ice/UdpEndpointI.h b/cpp/src/Ice/UdpEndpointI.h
index eba6eb0fb1b..86fc99ddde3 100644
--- a/cpp/src/Ice/UdpEndpointI.h
+++ b/cpp/src/Ice/UdpEndpointI.h
@@ -23,7 +23,7 @@ namespace IceInternal
             const std::string&,
             std::int32_t,
             const Address&,
-            const std::string&,
+            std::string,
             std::int32_t,
             const std::string&,
             bool);
@@ -76,7 +76,7 @@ namespace IceInternal
     class UdpEndpointFactory final : public EndpointFactory
     {
     public:
-        UdpEndpointFactory(const ProtocolInstancePtr&);
+        UdpEndpointFactory(ProtocolInstancePtr);
         ~UdpEndpointFactory() override;
 
         [[nodiscard]] std::int16_t type() const final;
diff --git a/cpp/src/Ice/UdpTransceiver.cpp b/cpp/src/Ice/UdpTransceiver.cpp
index 9dbf4cf5ffe..363dd5fa819 100644
--- a/cpp/src/Ice/UdpTransceiver.cpp
+++ b/cpp/src/Ice/UdpTransceiver.cpp
@@ -601,12 +601,12 @@ IceInternal::UdpTransceiver::effectivePort() const
 }
 
 IceInternal::UdpTransceiver::UdpTransceiver(
-    const ProtocolInstancePtr& instance,
+    ProtocolInstancePtr instance,
     const Address& addr,
     const Address& sourceAddr,
     const string& mcastInterface,
     int mcastTtl)
-    : _instance(instance),
+    : _instance(std::move(instance)),
       _incoming(false),
       _bound(false),
       _addr(addr),
@@ -664,17 +664,17 @@ IceInternal::UdpTransceiver::UdpTransceiver(
 }
 
 IceInternal::UdpTransceiver::UdpTransceiver(
-    const UdpEndpointIPtr& endpoint,
+    UdpEndpointIPtr endpoint,
     const ProtocolInstancePtr& instance,
     const string& host,
     int port,
-    const string& mcastInterface)
-    : _endpoint(endpoint),
+    string mcastInterface)
+    : _endpoint(std::move(endpoint)),
       _instance(instance),
       _incoming(true),
       _bound(false),
       _addr(getAddressForServer(host, port, instance->protocolSupport(), instance->preferIPv6(), true)),
-      _mcastInterface(mcastInterface),
+      _mcastInterface(std::move(mcastInterface)),
 #ifdef _WIN32
       _port(port),
 #endif
diff --git a/cpp/src/Ice/UdpTransceiver.h b/cpp/src/Ice/UdpTransceiver.h
index 899d258fc0d..701ae34e6d6 100644
--- a/cpp/src/Ice/UdpTransceiver.h
+++ b/cpp/src/Ice/UdpTransceiver.h
@@ -26,8 +26,8 @@ namespace IceInternal
         };
 
     public:
-        UdpTransceiver(const ProtocolInstancePtr&, const Address&, const Address&, const std::string&, int);
-        UdpTransceiver(const UdpEndpointIPtr&, const ProtocolInstancePtr&, const std::string&, int, const std::string&);
+        UdpTransceiver(ProtocolInstancePtr, const Address&, const Address&, const std::string&, int);
+        UdpTransceiver(UdpEndpointIPtr, const ProtocolInstancePtr&, const std::string&, int, std::string);
 
         ~UdpTransceiver() final;
 
diff --git a/cpp/src/Ice/WSAcceptor.cpp b/cpp/src/Ice/WSAcceptor.cpp
index 2de833c4f08..0de67c153d6 100644
--- a/cpp/src/Ice/WSAcceptor.cpp
+++ b/cpp/src/Ice/WSAcceptor.cpp
@@ -79,13 +79,10 @@ IceInternal::WSAcceptor::toDetailedString() const
     return _delegate->toDetailedString();
 }
 
-IceInternal::WSAcceptor::WSAcceptor(
-    const WSEndpointPtr& endpoint,
-    const ProtocolInstancePtr& instance,
-    const AcceptorPtr& del)
-    : _endpoint(endpoint),
-      _instance(instance),
-      _delegate(del)
+IceInternal::WSAcceptor::WSAcceptor(WSEndpointPtr endpoint, ProtocolInstancePtr instance, AcceptorPtr del)
+    : _endpoint(std::move(endpoint)),
+      _instance(std::move(instance)),
+      _delegate(std::move(del))
 {
 }
 
diff --git a/cpp/src/Ice/WSAcceptor.h b/cpp/src/Ice/WSAcceptor.h
index 1b79bf5da97..f79c346b6cb 100644
--- a/cpp/src/Ice/WSAcceptor.h
+++ b/cpp/src/Ice/WSAcceptor.h
@@ -18,7 +18,7 @@ namespace IceInternal
     class WSAcceptor final : public Acceptor, public NativeInfo
     {
     public:
-        WSAcceptor(const WSEndpointPtr&, const ProtocolInstancePtr&, const AcceptorPtr&);
+        WSAcceptor(WSEndpointPtr, ProtocolInstancePtr, AcceptorPtr);
         ~WSAcceptor() override;
         NativeInfoPtr getNativeInfo() final;
 #if defined(ICE_USE_IOCP)
diff --git a/cpp/src/Ice/WSConnector.cpp b/cpp/src/Ice/WSConnector.cpp
index e8b6b82053a..59d76f18ad8 100644
--- a/cpp/src/Ice/WSConnector.cpp
+++ b/cpp/src/Ice/WSConnector.cpp
@@ -77,15 +77,11 @@ IceInternal::WSConnector::operator<(const Connector& r) const
     return Ice::targetLess(_delegate, p->_delegate);
 }
 
-IceInternal::WSConnector::WSConnector(
-    const ProtocolInstancePtr& instance,
-    const ConnectorPtr& del,
-    const string& host,
-    const string& resource)
-    : _instance(instance),
-      _delegate(del),
-      _host(host),
-      _resource(resource)
+IceInternal::WSConnector::WSConnector(ProtocolInstancePtr instance, ConnectorPtr del, string host, string resource)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _host(std::move(host)),
+      _resource(std::move(resource))
 {
 }
 
diff --git a/cpp/src/Ice/WSConnector.h b/cpp/src/Ice/WSConnector.h
index f6e7ccdf5f7..6d4d574e9ba 100644
--- a/cpp/src/Ice/WSConnector.h
+++ b/cpp/src/Ice/WSConnector.h
@@ -17,7 +17,7 @@ namespace IceInternal
     class WSConnector final : public Connector
     {
     public:
-        WSConnector(const ProtocolInstancePtr&, const ConnectorPtr&, const std::string&, const std::string&);
+        WSConnector(ProtocolInstancePtr, ConnectorPtr, std::string, std::string);
         ~WSConnector() override;
         TransceiverPtr connect() final;
 
diff --git a/cpp/src/Ice/WSEndpoint.cpp b/cpp/src/Ice/WSEndpoint.cpp
index 706db48d6d7..bb2c7dbbbcf 100644
--- a/cpp/src/Ice/WSEndpoint.cpp
+++ b/cpp/src/Ice/WSEndpoint.cpp
@@ -77,16 +77,16 @@ WSEndpointFactoryPlugin::destroy()
 {
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, const string& res)
-    : _instance(instance),
-      _delegate(del),
-      _resource(res)
+IceInternal::WSEndpoint::WSEndpoint(ProtocolInstancePtr instance, EndpointIPtr del, string res)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _resource(std::move(res))
 {
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& inst, const EndpointIPtr& del, vector<string>& args)
-    : _instance(inst),
-      _delegate(del)
+IceInternal::WSEndpoint::WSEndpoint(ProtocolInstancePtr inst, EndpointIPtr del, vector<string>& args)
+    : _instance(std::move(inst)),
+      _delegate(std::move(del))
 {
     initWithOptions(args);
 
@@ -96,9 +96,9 @@ IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& inst, const Endpo
     }
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, InputStream* s)
-    : _instance(instance),
-      _delegate(del)
+IceInternal::WSEndpoint::WSEndpoint(ProtocolInstancePtr instance, EndpointIPtr del, InputStream* s)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del))
 {
     s->read(const_cast<string&>(_resource), false);
 }
diff --git a/cpp/src/Ice/WSEndpoint.h b/cpp/src/Ice/WSEndpoint.h
index 3eed1f88efc..526506e9802 100644
--- a/cpp/src/Ice/WSEndpoint.h
+++ b/cpp/src/Ice/WSEndpoint.h
@@ -20,9 +20,9 @@ namespace IceInternal
     class WSEndpoint final : public EndpointI, public std::enable_shared_from_this<WSEndpoint>
     {
     public:
-        WSEndpoint(const ProtocolInstancePtr&, const EndpointIPtr&, const std::string&);
-        WSEndpoint(const ProtocolInstancePtr&, const EndpointIPtr&, std::vector<std::string>&);
-        WSEndpoint(const ProtocolInstancePtr&, const EndpointIPtr&, Ice::InputStream*);
+        WSEndpoint(ProtocolInstancePtr, EndpointIPtr, std::string);
+        WSEndpoint(ProtocolInstancePtr, EndpointIPtr, std::vector<std::string>&);
+        WSEndpoint(ProtocolInstancePtr, EndpointIPtr, Ice::InputStream*);
 
         void streamWriteImpl(Ice::OutputStream*) const final;
 
diff --git a/cpp/src/Ice/WSTransceiver.cpp b/cpp/src/Ice/WSTransceiver.cpp
index 2ab3301600e..4fefd20534a 100644
--- a/cpp/src/Ice/WSTransceiver.cpp
+++ b/cpp/src/Ice/WSTransceiver.cpp
@@ -816,14 +816,14 @@ IceInternal::WSTransceiver::setBufferSize(int rcvSize, int sndSize)
 }
 
 IceInternal::WSTransceiver::WSTransceiver(
-    const ProtocolInstancePtr& instance,
-    const TransceiverPtr& del,
-    const string& host,
-    const string& resource)
-    : _instance(instance),
-      _delegate(del),
-      _host(host),
-      _resource(resource),
+    ProtocolInstancePtr instance,
+    TransceiverPtr del,
+    string host,
+    string resource)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _host(std::move(host)),
+      _resource(std::move(resource)),
       _incoming(false),
       _state(StateInitializeDelegate),
       _parser(make_shared<HttpParser>()),
@@ -849,9 +849,9 @@ IceInternal::WSTransceiver::WSTransceiver(
     //
 }
 
-IceInternal::WSTransceiver::WSTransceiver(const ProtocolInstancePtr& instance, const TransceiverPtr& del)
-    : _instance(instance),
-      _delegate(del),
+IceInternal::WSTransceiver::WSTransceiver(ProtocolInstancePtr instance, TransceiverPtr del)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
       _incoming(true),
       _state(StateInitializeDelegate),
       _parser(make_shared<HttpParser>()),
diff --git a/cpp/src/Ice/WSTransceiver.h b/cpp/src/Ice/WSTransceiver.h
index 4c7d48b739b..21eaf354e5f 100644
--- a/cpp/src/Ice/WSTransceiver.h
+++ b/cpp/src/Ice/WSTransceiver.h
@@ -6,11 +6,10 @@
 #define ICE_WS_TRANSCEIVER_I_H
 
 #include "HttpParser.h"
-#include "ProtocolInstance.h"
-
 #include "Ice/Buffer.h"
 #include "Ice/Logger.h"
 #include "Network.h"
+#include "ProtocolInstance.h"
 #include "Transceiver.h"
 
 namespace IceInternal
@@ -21,8 +20,8 @@ namespace IceInternal
     class WSTransceiver final : public Transceiver
     {
     public:
-        WSTransceiver(const ProtocolInstancePtr&, const TransceiverPtr&, const std::string&, const std::string&);
-        WSTransceiver(const ProtocolInstancePtr&, const TransceiverPtr&);
+        WSTransceiver(ProtocolInstancePtr, TransceiverPtr, std::string, std::string);
+        WSTransceiver(ProtocolInstancePtr, TransceiverPtr);
         ~WSTransceiver();
 
         NativeInfoPtr getNativeInfo() final;
diff --git a/cpp/src/IceBT/AcceptorI.cpp b/cpp/src/IceBT/AcceptorI.cpp
index 08f739e569d..62e43adff0e 100644
--- a/cpp/src/IceBT/AcceptorI.cpp
+++ b/cpp/src/IceBT/AcceptorI.cpp
@@ -3,18 +3,17 @@
 //
 
 #include "AcceptorI.h"
-#include "EndpointI.h"
-#include "Engine.h"
-#include "Instance.h"
-#include "TransceiverI.h"
-#include "Util.h"
-
 #include "../Ice/Network.h"
 #include "../Ice/StreamSocket.h"
+#include "EndpointI.h"
+#include "Engine.h"
 #include "Ice/Communicator.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/Properties.h"
 #include "Ice/StringUtil.h"
+#include "Instance.h"
+#include "TransceiverI.h"
+#include "Util.h"
 
 using namespace std;
 using namespace Ice;
diff --git a/cpp/src/IceBT/ConnectorI.cpp b/cpp/src/IceBT/ConnectorI.cpp
index d13a05071c1..864c7e81571 100644
--- a/cpp/src/IceBT/ConnectorI.cpp
+++ b/cpp/src/IceBT/ConnectorI.cpp
@@ -3,11 +3,10 @@
 //
 
 #include "ConnectorI.h"
+#include "Ice/LocalExceptions.h"
 #include "Instance.h"
 #include "TransceiverI.h"
 
-#include "Ice/LocalExceptions.h"
-
 using namespace std;
 using namespace Ice;
 using namespace IceBT;
diff --git a/cpp/src/IceBT/ConnectorI.h b/cpp/src/IceBT/ConnectorI.h
index 9ba06462fef..a37d822ee6d 100644
--- a/cpp/src/IceBT/ConnectorI.h
+++ b/cpp/src/IceBT/ConnectorI.h
@@ -5,13 +5,12 @@
 #ifndef ICE_BT_CONNECTOR_I_H
 #define ICE_BT_CONNECTOR_I_H
 
+#include "../Ice/Connector.h"
+#include "../Ice/TransceiverF.h"
 #include "Config.h"
 #include "Engine.h"
 #include "InstanceF.h"
 
-#include "../Ice/Connector.h"
-#include "../Ice/TransceiverF.h"
-
 namespace IceBT
 {
     class ConnectorI final : public IceInternal::Connector
diff --git a/cpp/src/IceBT/StreamSocket.cpp b/cpp/src/IceBT/StreamSocket.cpp
index 789df7e27f9..a66e60edc76 100644
--- a/cpp/src/IceBT/StreamSocket.cpp
+++ b/cpp/src/IceBT/StreamSocket.cpp
@@ -3,13 +3,12 @@
 //
 
 #include "StreamSocket.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
 #include "IceBT/EndpointInfo.h"
 #include "Instance.h"
 #include "Util.h"
 
-#include "Ice/LoggerUtil.h"
-#include "Ice/Properties.h"
-
 using namespace std;
 using namespace Ice;
 using namespace IceBT;
diff --git a/cpp/src/IceBT/StreamSocket.h b/cpp/src/IceBT/StreamSocket.h
index 007e9f33acc..bcc775b12f2 100644
--- a/cpp/src/IceBT/StreamSocket.h
+++ b/cpp/src/IceBT/StreamSocket.h
@@ -5,11 +5,10 @@
 #ifndef ICE_BT_STREAM_SOCKET_H
 #define ICE_BT_STREAM_SOCKET_H
 
-#include "Config.h"
-#include "InstanceF.h"
-
 #include "../Ice/Network.h"
+#include "Config.h"
 #include "Ice/Buffer.h"
+#include "InstanceF.h"
 
 namespace IceBT
 {
diff --git a/cpp/src/IceBT/TransceiverI.cpp b/cpp/src/IceBT/TransceiverI.cpp
index 4ae9e22bb48..75aca447a2a 100644
--- a/cpp/src/IceBT/TransceiverI.cpp
+++ b/cpp/src/IceBT/TransceiverI.cpp
@@ -4,13 +4,12 @@
 
 #include "TransceiverI.h"
 #include "Engine.h"
+#include "Ice/Connection.h"
+#include "Ice/LocalExceptions.h"
 #include "IceBT/ConnectionInfo.h"
 #include "Instance.h"
 #include "Util.h"
 
-#include "Ice/Connection.h"
-#include "Ice/LocalExceptions.h"
-
 #include "../Ice/DisableWarnings.h"
 
 using namespace std;
diff --git a/cpp/src/IceBT/TransceiverI.h b/cpp/src/IceBT/TransceiverI.h
index c28a48b7154..cbe38c4a06c 100644
--- a/cpp/src/IceBT/TransceiverI.h
+++ b/cpp/src/IceBT/TransceiverI.h
@@ -5,12 +5,11 @@
 #ifndef ICE_BT_TRANSCEIVER_H
 #define ICE_BT_TRANSCEIVER_H
 
+#include "../Ice/Transceiver.h"
 #include "Engine.h"
 #include "InstanceF.h"
 #include "StreamSocket.h"
 
-#include "../Ice/Transceiver.h"
-
 namespace IceBT
 {
     class ConnectorI;
diff --git a/cpp/src/IceBT/Util.cpp b/cpp/src/IceBT/Util.cpp
index bbf2bd135d8..ac3508bdf02 100644
--- a/cpp/src/IceBT/Util.cpp
+++ b/cpp/src/IceBT/Util.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "Util.h"
-
 #include "../Ice/Network.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/StringUtil.h"
diff --git a/cpp/src/IceBT/Util.h b/cpp/src/IceBT/Util.h
index 3003ded83b9..a339d66c2ef 100644
--- a/cpp/src/IceBT/Util.h
+++ b/cpp/src/IceBT/Util.h
@@ -5,11 +5,10 @@
 #ifndef ICE_BT_UTIL_H
 #define ICE_BT_UTIL_H
 
+#include "../Ice/Network.h"
 #include "Config.h"
 #include "IceBT/Types.h"
 
-#include "../Ice/Network.h"
-
 namespace IceBT
 {
     bool isValidDeviceAddress(const std::string&);
diff --git a/cpp/src/IceBox/ServiceManagerI.cpp b/cpp/src/IceBox/ServiceManagerI.cpp
index b3eeba9cf3a..de866d6e5dd 100644
--- a/cpp/src/IceBox/ServiceManagerI.cpp
+++ b/cpp/src/IceBox/ServiceManagerI.cpp
@@ -77,7 +77,7 @@ namespace
 }
 
 IceBox::ServiceManagerI::ServiceManagerI(CommunicatorPtr communicator, int& argc, char* argv[])
-    : _communicator(communicator),
+    : _communicator(std::move(communicator)),
       _adminEnabled(false),
       _pendingStatusChanges(false),
       _traceServiceObserver(0)
diff --git a/cpp/src/IceBridge/IceBridge.cpp b/cpp/src/IceBridge/IceBridge.cpp
index 0cb66523374..92a4dd4e761 100644
--- a/cpp/src/IceBridge/IceBridge.cpp
+++ b/cpp/src/IceBridge/IceBridge.cpp
@@ -30,11 +30,11 @@ namespace
             pair<const byte*, const byte*> p,
             function<void(bool, pair<const byte*, const byte*>)>&& r,
             function<void(exception_ptr)>&& e,
-            const Current& c)
+            Current c)
             : inParams(p.first, p.second),
               response(std::move(r)),
               error(std::move(e)),
-              current(c)
+              current(std::move(c))
         {
         }
 
diff --git a/cpp/src/IceDB/IceDB.h b/cpp/src/IceDB/IceDB.h
index d29af04b7b7..ee0b29d5183 100644
--- a/cpp/src/IceDB/IceDB.h
+++ b/cpp/src/IceDB/IceDB.h
@@ -167,9 +167,9 @@ namespace IceDB
     template<typename K, typename D, typename C, typename H> class Dbi : public DbiBase
     {
     public:
-        Dbi(const Txn& txn, const std::string& name, const C& ctx, unsigned int flags = 0, MDB_cmp_func* cmp = nullptr)
+        Dbi(const Txn& txn, const std::string& name, C ctx, unsigned int flags = 0, MDB_cmp_func* cmp = nullptr)
             : DbiBase(txn, name, flags, cmp),
-              _marshalingContext(ctx)
+              _marshalingContext(std::move(ctx))
         {
         }
 
diff --git a/cpp/src/IceDiscovery/LocatorI.cpp b/cpp/src/IceDiscovery/LocatorI.cpp
index 72e7e30f4bd..825f78ff32a 100644
--- a/cpp/src/IceDiscovery/LocatorI.cpp
+++ b/cpp/src/IceDiscovery/LocatorI.cpp
@@ -3,13 +3,11 @@
 //
 
 #include "LocatorI.h"
-#include "LookupI.h"
-
+#include "../Ice/Random.h"
 #include "Ice/Communicator.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/ObjectAdapter.h"
-
-#include "../Ice/Random.h"
+#include "LookupI.h"
 
 #include <iterator>
 
@@ -185,7 +183,9 @@ LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) con
     return nullopt;
 }
 
-LocatorI::LocatorI(const LookupIPtr& lookup, const LocatorRegistryPrx& registry) : _lookup(lookup), _registry(registry)
+LocatorI::LocatorI(LookupIPtr lookup, LocatorRegistryPrx registry)
+    : _lookup(std::move(lookup)),
+      _registry(std::move(registry))
 {
 }
 
diff --git a/cpp/src/IceDiscovery/LocatorI.h b/cpp/src/IceDiscovery/LocatorI.h
index d204772e4d3..9608e87632e 100644
--- a/cpp/src/IceDiscovery/LocatorI.h
+++ b/cpp/src/IceDiscovery/LocatorI.h
@@ -55,7 +55,7 @@ namespace IceDiscovery
     class LocatorI final : public Ice::Locator
     {
     public:
-        LocatorI(const LookupIPtr&, const Ice::LocatorRegistryPrx&);
+        LocatorI(LookupIPtr, Ice::LocatorRegistryPrx);
 
         void findObjectByIdAsync(
             Ice::Identity,
diff --git a/cpp/src/IceDiscovery/LookupI.cpp b/cpp/src/IceDiscovery/LookupI.cpp
index 60c1675a1b7..15feff734d0 100644
--- a/cpp/src/IceDiscovery/LookupI.cpp
+++ b/cpp/src/IceDiscovery/LookupI.cpp
@@ -2,6 +2,7 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
+#include "LookupI.h"
 #include "Ice/Communicator.h"
 #include "Ice/Connection.h"
 #include "Ice/Initialize.h"
@@ -10,15 +11,14 @@
 #include "Ice/ObjectAdapter.h"
 #include "Ice/UUID.h"
 
-#include "LookupI.h"
 #include <iterator>
 
 using namespace std;
 using namespace Ice;
 using namespace IceDiscovery;
 
-IceDiscovery::Request::Request(const LookupIPtr& lookup, int retryCount)
-    : _lookup(lookup),
+IceDiscovery::Request::Request(LookupIPtr lookup, int retryCount)
+    : _lookup(std::move(lookup)),
       _requestId(Ice::generateUUID()),
       _retryCount(retryCount),
       _lookupCount(0),
@@ -169,8 +169,8 @@ ObjectRequest::runTimerTask()
     _lookup->objectRequestTimedOut(shared_from_this());
 }
 
-LookupI::LookupI(const LocatorRegistryIPtr& registry, const LookupPrx& lookup, const Ice::PropertiesPtr& properties)
-    : _registry(registry),
+LookupI::LookupI(LocatorRegistryIPtr registry, const LookupPrx& lookup, const Ice::PropertiesPtr& properties)
+    : _registry(std::move(registry)),
       _lookup(lookup),
       _timeout(chrono::milliseconds(properties->getIcePropertyAsInt("IceDiscovery.Timeout"))),
       _retryCount(properties->getIcePropertyAsInt("IceDiscovery.RetryCount")),
@@ -482,7 +482,7 @@ LookupI::objectRequestException(const ObjectRequestPtr& request, exception_ptr e
     }
 }
 
-LookupReplyI::LookupReplyI(const LookupIPtr& lookup) : _lookup(lookup) {}
+LookupReplyI::LookupReplyI(LookupIPtr lookup) : _lookup(std::move(lookup)) {}
 
 void
 LookupReplyI::foundObjectById(Identity id, optional<ObjectPrx> proxy, const Current& current)
diff --git a/cpp/src/IceDiscovery/LookupI.h b/cpp/src/IceDiscovery/LookupI.h
index 6fa40c8ec69..844c5c2e5a2 100644
--- a/cpp/src/IceDiscovery/LookupI.h
+++ b/cpp/src/IceDiscovery/LookupI.h
@@ -5,12 +5,11 @@
 #ifndef LOOKUPI_H
 #define LOOKUPI_H
 
-#include "IceDiscovery.h"
-#include "LocatorI.h"
-
 #include "Ice/Comparable.h"
 #include "Ice/Properties.h"
 #include "Ice/Timer.h"
+#include "IceDiscovery.h"
+#include "LocatorI.h"
 
 #include <chrono>
 #include <set>
@@ -22,7 +21,7 @@ namespace IceDiscovery
     class Request : public IceInternal::TimerTask
     {
     public:
-        Request(const LookupIPtr&, int);
+        Request(LookupIPtr, int);
 
         virtual bool retry();
         void invoke(const std::string&, const std::vector<std::pair<LookupPrx, LookupReplyPrx>>&);
@@ -45,7 +44,7 @@ namespace IceDiscovery
     template<class T, class CB> class RequestT : public Request
     {
     public:
-        RequestT(const LookupIPtr& lookup, T id, int retryCount) : Request(lookup, retryCount), _id(id) {}
+        RequestT(const LookupIPtr& lookup, T id, int retryCount) : Request(lookup, retryCount), _id(std::move(id)) {}
 
         [[nodiscard]] T getId() const { return _id; }
 
@@ -116,7 +115,7 @@ namespace IceDiscovery
     class LookupI final : public Lookup, public std::enable_shared_from_this<LookupI>
     {
     public:
-        LookupI(const LocatorRegistryIPtr&, const LookupPrx&, const Ice::PropertiesPtr&);
+        LookupI(LocatorRegistryIPtr, const LookupPrx&, const Ice::PropertiesPtr&);
 
         void destroy();
 
@@ -159,7 +158,7 @@ namespace IceDiscovery
     class LookupReplyI final : public LookupReply
     {
     public:
-        LookupReplyI(const LookupIPtr&);
+        LookupReplyI(LookupIPtr);
 
         void foundObjectById(Ice::Identity, std::optional<Ice::ObjectPrx>, const Ice::Current&) final;
         void foundAdapterById(std::string, std::optional<Ice::ObjectPrx>, bool, const Ice::Current&) final;
diff --git a/cpp/src/IceDiscovery/PluginI.cpp b/cpp/src/IceDiscovery/PluginI.cpp
index f4a2906ce67..9d11b2740d9 100644
--- a/cpp/src/IceDiscovery/PluginI.cpp
+++ b/cpp/src/IceDiscovery/PluginI.cpp
@@ -2,12 +2,11 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
+#include "PluginI.h"
 #include "../Ice/Network.h" // For getInterfacesForMulticast
 #include "Ice/Ice.h"
-
 #include "LocatorI.h"
 #include "LookupI.h"
-#include "PluginI.h"
 
 using namespace std;
 using namespace IceDiscovery;
@@ -40,7 +39,7 @@ namespace Ice
     }
 }
 
-PluginI::PluginI(const Ice::CommunicatorPtr& communicator) : _communicator(communicator) {}
+PluginI::PluginI(Ice::CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 PluginI::initialize()
diff --git a/cpp/src/IceDiscovery/PluginI.h b/cpp/src/IceDiscovery/PluginI.h
index de1c9d9970f..1cb13bb800f 100644
--- a/cpp/src/IceDiscovery/PluginI.h
+++ b/cpp/src/IceDiscovery/PluginI.h
@@ -13,7 +13,7 @@ namespace IceDiscovery
     class PluginI : public Ice::Plugin
     {
     public:
-        PluginI(const Ice::CommunicatorPtr&);
+        PluginI(Ice::CommunicatorPtr);
 
         void initialize() override;
         void destroy() override;
diff --git a/cpp/src/IceGrid/AdapterCache.cpp b/cpp/src/IceGrid/AdapterCache.cpp
index 450d4b9b96e..56f4b95dfb8 100644
--- a/cpp/src/IceGrid/AdapterCache.cpp
+++ b/cpp/src/IceGrid/AdapterCache.cpp
@@ -319,10 +319,10 @@ AdapterCache::removeImpl(const string& id)
     Cache<string, AdapterEntry>::removeImpl(id);
 }
 
-AdapterEntry::AdapterEntry(AdapterCache& cache, const string& id, const string& application)
+AdapterEntry::AdapterEntry(AdapterCache& cache, string id, string application)
     : _cache(cache),
-      _id(id),
-      _application(application)
+      _id(std::move(id)),
+      _application(std::move(application))
 {
 }
 
@@ -348,11 +348,11 @@ ServerAdapterEntry::ServerAdapterEntry(
     AdapterCache& cache,
     const string& id,
     const string& application,
-    const string& replicaGroupId,
+    string replicaGroupId,
     int priority,
     const shared_ptr<ServerEntry>& server)
     : AdapterEntry(cache, id, application),
-      _replicaGroupId(replicaGroupId),
+      _replicaGroupId(std::move(replicaGroupId)),
       _priority(priority),
       _server(server)
 {
diff --git a/cpp/src/IceGrid/AdapterCache.h b/cpp/src/IceGrid/AdapterCache.h
index f6c7640ca22..75bf86a20ea 100644
--- a/cpp/src/IceGrid/AdapterCache.h
+++ b/cpp/src/IceGrid/AdapterCache.h
@@ -45,7 +45,7 @@ namespace IceGrid
     class AdapterEntry
     {
     public:
-        AdapterEntry(AdapterCache&, const std::string&, const std::string&);
+        AdapterEntry(AdapterCache&, std::string, std::string);
 
         virtual bool addSyncCallback(const std::shared_ptr<SynchronizationCallback>&, const std::set<std::string>&) = 0;
 
@@ -79,7 +79,7 @@ namespace IceGrid
             AdapterCache&,
             const std::string&,
             const std::string&,
-            const std::string&,
+            std::string,
             int,
             const std::shared_ptr<ServerEntry>&);
 
diff --git a/cpp/src/IceGrid/AdminI.cpp b/cpp/src/IceGrid/AdminI.cpp
index d6b753fd9ba..218fe650210 100644
--- a/cpp/src/IceGrid/AdminI.cpp
+++ b/cpp/src/IceGrid/AdminI.cpp
@@ -2,22 +2,19 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
-#include "Ice/UUID.h"
-
-#include "../Ice/TraceUtil.h"
-#include "Ice/Ice.h"
-#include "Ice/LoggerUtil.h"
-
 #include "AdminI.h"
+#include "../Ice/TraceUtil.h"
 #include "AdminSessionI.h"
 #include "Database.h"
 #include "DescriptorHelper.h"
 #include "DescriptorParser.h"
+#include "Ice/Ice.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/UUID.h"
 #include "NodeSessionI.h"
 #include "RegistryI.h"
-#include "Util.h"
-
 #include "SynchronizationException.h"
+#include "Util.h"
 
 using namespace std;
 using namespace std::chrono;
diff --git a/cpp/src/IceGrid/AdminSessionI.cpp b/cpp/src/IceGrid/AdminSessionI.cpp
index 44f9ef5058b..b1a2cd021c8 100644
--- a/cpp/src/IceGrid/AdminSessionI.cpp
+++ b/cpp/src/IceGrid/AdminSessionI.cpp
@@ -48,12 +48,12 @@ namespace
 FileIteratorI::FileIteratorI(
     shared_ptr<AdminSessionI> session,
     FileReaderPrx reader,
-    const string& filename,
+    string filename,
     int64_t offset,
     int messageSizeMax)
     : _session(std::move(session)),
       _reader(std::move(reader)),
-      _filename(filename),
+      _filename(std::move(filename)),
       _offset(offset),
       _messageSizeMax(messageSizeMax - 256) // Room for the header
 {
diff --git a/cpp/src/IceGrid/AdminSessionI.h b/cpp/src/IceGrid/AdminSessionI.h
index e40ed57fd72..3fb2be2c785 100644
--- a/cpp/src/IceGrid/AdminSessionI.h
+++ b/cpp/src/IceGrid/AdminSessionI.h
@@ -130,7 +130,7 @@ namespace IceGrid
     class FileIteratorI final : public FileIterator
     {
     public:
-        FileIteratorI(std::shared_ptr<AdminSessionI>, FileReaderPrx, const std::string&, std::int64_t, int);
+        FileIteratorI(std::shared_ptr<AdminSessionI>, FileReaderPrx, std::string, std::int64_t, int);
 
         bool read(int, Ice::StringSeq&, const Ice::Current&) final;
         void destroy(const Ice::Current&) final;
diff --git a/cpp/src/IceGrid/Allocatable.h b/cpp/src/IceGrid/Allocatable.h
index fdc760f33d0..43d9cb09e38 100644
--- a/cpp/src/IceGrid/Allocatable.h
+++ b/cpp/src/IceGrid/Allocatable.h
@@ -6,7 +6,6 @@
 #define ICEGRID_ALLOCATABLE_H
 
 #include "Ice/Timer.h"
-
 #include "IceGrid/Session.h"
 
 #include <list>
diff --git a/cpp/src/IceGrid/AllocatableObjectCache.cpp b/cpp/src/IceGrid/AllocatableObjectCache.cpp
index a9d0d109e62..a306169e26c 100644
--- a/cpp/src/IceGrid/AllocatableObjectCache.cpp
+++ b/cpp/src/IceGrid/AllocatableObjectCache.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "AllocatableObjectCache.h"
+
 #include "../Ice/Random.h"
 #include "Ice/Communicator.h"
 #include "Ice/LocalExceptions.h"
@@ -252,11 +253,11 @@ AllocatableObjectCache::canTryAllocate(const shared_ptr<AllocatableObjectEntry>&
 
 AllocatableObjectEntry::AllocatableObjectEntry(
     AllocatableObjectCache& cache,
-    const ObjectInfo& info,
+    ObjectInfo info,
     const shared_ptr<ServerEntry>& parent)
     : Allocatable(true, parent),
       _cache(cache),
-      _info(info),
+      _info(std::move(info)),
       _server(parent),
       _destroyed(false)
 {
diff --git a/cpp/src/IceGrid/AllocatableObjectCache.h b/cpp/src/IceGrid/AllocatableObjectCache.h
index 8b63031f819..ba872d62bbf 100644
--- a/cpp/src/IceGrid/AllocatableObjectCache.h
+++ b/cpp/src/IceGrid/AllocatableObjectCache.h
@@ -18,7 +18,7 @@ namespace IceGrid
     class AllocatableObjectEntry : public Allocatable
     {
     public:
-        AllocatableObjectEntry(AllocatableObjectCache&, const ObjectInfo&, const std::shared_ptr<ServerEntry>&);
+        AllocatableObjectEntry(AllocatableObjectCache&, ObjectInfo, const std::shared_ptr<ServerEntry>&);
         [[nodiscard]] Ice::ObjectPrx getProxy() const;
         [[nodiscard]] std::string getType() const;
 
diff --git a/cpp/src/IceGrid/Database.cpp b/cpp/src/IceGrid/Database.cpp
index 8b7390d6ca1..5d74cc7416e 100644
--- a/cpp/src/IceGrid/Database.cpp
+++ b/cpp/src/IceGrid/Database.cpp
@@ -196,14 +196,14 @@ Database::create(
 Database::Database(
     const Ice::ObjectAdapterPtr& registryAdapter,
     IceStorm::TopicManagerPrx topicManager,
-    const string& instanceName,
+    string instanceName,
     const shared_ptr<TraceLevels>& traceLevels,
     const RegistryInfo& info,
     bool readonly)
     : _communicator(registryAdapter->getCommunicator()),
       _internalAdapter(registryAdapter),
       _topicManager(std::move(topicManager)),
-      _instanceName(instanceName),
+      _instanceName(std::move(instanceName)),
       _traceLevels(traceLevels),
       _master(info.name == "Master"),
       _readonly(readonly || !_master),
diff --git a/cpp/src/IceGrid/Database.h b/cpp/src/IceGrid/Database.h
index 265eccaedff..9ab2269b44e 100644
--- a/cpp/src/IceGrid/Database.h
+++ b/cpp/src/IceGrid/Database.h
@@ -170,7 +170,7 @@ namespace IceGrid
         Database(
             const Ice::ObjectAdapterPtr&,
             IceStorm::TopicManagerPrx,
-            const std::string&,
+            std::string,
             const std::shared_ptr<TraceLevels>&,
             const RegistryInfo&,
             bool);
@@ -276,9 +276,9 @@ namespace IceGrid
             std::vector<std::pair<std::function<void()>, std::function<void(std::exception_ptr)>>> cbs;
             bool updated;
 
-            UpdateInfo(const std::string& n, const std::string& u, int r)
-                : name(n),
-                  uuid(u),
+            UpdateInfo(std::string n, std::string u, int r)
+                : name(std::move(n)),
+                  uuid(std::move(u)),
                   revision(r),
                   updated(false)
             {
diff --git a/cpp/src/IceGrid/DescriptorBuilder.cpp b/cpp/src/IceGrid/DescriptorBuilder.cpp
index ff3e0bd8b05..372033e8c35 100644
--- a/cpp/src/IceGrid/DescriptorBuilder.cpp
+++ b/cpp/src/IceGrid/DescriptorBuilder.cpp
@@ -14,14 +14,10 @@
 using namespace std;
 using namespace IceGrid;
 
-XmlAttributesHelper::XmlAttributesHelper(
-    const XMLAttributes& attrs,
-    const Ice::LoggerPtr& logger,
-    const string& filename,
-    int line)
+XmlAttributesHelper::XmlAttributesHelper(const XMLAttributes& attrs, Ice::LoggerPtr logger, string filename, int line)
     : _attributes(attrs),
-      _logger(logger),
-      _filename(filename),
+      _logger(std::move(logger)),
+      _filename(std::move(filename)),
       _line(line)
 {
 }
@@ -228,11 +224,11 @@ ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(
 
 ApplicationDescriptorBuilder::ApplicationDescriptorBuilder(
     const shared_ptr<Ice::Communicator>& communicator,
-    const ApplicationDescriptor& app,
+    ApplicationDescriptor app,
     const XmlAttributesHelper& attrs,
     const map<string, string>& overrides)
     : _communicator(communicator),
-      _descriptor(app),
+      _descriptor(std::move(app)),
       _overrides(overrides)
 {
     _descriptor.name = attrs("name");
@@ -444,10 +440,10 @@ ServerInstanceDescriptorBuilder::addPropertySet(const string& service, const Pro
 
 NodeDescriptorBuilder::NodeDescriptorBuilder(
     ApplicationDescriptorBuilder& app,
-    const NodeDescriptor& desc,
+    NodeDescriptor desc,
     const XmlAttributesHelper& attrs)
     : _application(app),
-      _descriptor(desc)
+      _descriptor(std::move(desc))
 {
     _name = attrs("name");
     _descriptor.loadFactor = attrs("load-factor", "");
diff --git a/cpp/src/IceGrid/DescriptorBuilder.h b/cpp/src/IceGrid/DescriptorBuilder.h
index e0b4eb44f60..082e8cee1ec 100644
--- a/cpp/src/IceGrid/DescriptorBuilder.h
+++ b/cpp/src/IceGrid/DescriptorBuilder.h
@@ -15,7 +15,7 @@ namespace IceGrid
     class XmlAttributesHelper
     {
     public:
-        XmlAttributesHelper(const XMLAttributes&, const Ice::LoggerPtr&, const std::string&, int);
+        XmlAttributesHelper(const XMLAttributes&, Ice::LoggerPtr, std::string, int);
 
         void checkUnknownAttributes();
         bool contains(const std::string&) const;          // NOLINT:modernize-use-nodiscard
@@ -80,7 +80,7 @@ namespace IceGrid
             const std::map<std::string, std::string>&);
         ApplicationDescriptorBuilder(
             const Ice::CommunicatorPtr&,
-            const ApplicationDescriptor&,
+            ApplicationDescriptor,
             const XmlAttributesHelper&,
             const std::map<std::string, std::string>&);
 
@@ -135,7 +135,7 @@ namespace IceGrid
     {
     public:
         NodeDescriptorBuilder(ApplicationDescriptorBuilder&, const XmlAttributesHelper&);
-        NodeDescriptorBuilder(ApplicationDescriptorBuilder&, const NodeDescriptor&, const XmlAttributesHelper&);
+        NodeDescriptorBuilder(ApplicationDescriptorBuilder&, NodeDescriptor, const XmlAttributesHelper&);
 
         virtual ServerDescriptorBuilder* createServer(const XmlAttributesHelper&);
         virtual ServerDescriptorBuilder* createIceBox(const XmlAttributesHelper&);
diff --git a/cpp/src/IceGrid/DescriptorHelper.cpp b/cpp/src/IceGrid/DescriptorHelper.cpp
index 8bcde3165f2..5d54234c154 100644
--- a/cpp/src/IceGrid/DescriptorHelper.cpp
+++ b/cpp/src/IceGrid/DescriptorHelper.cpp
@@ -1725,7 +1725,7 @@ InstanceHelper::instantiateParams(
     return params;
 }
 
-ServiceInstanceHelper::ServiceInstanceHelper(const ServiceInstanceDescriptor& desc, bool ignoreProps) : _def(desc)
+ServiceInstanceHelper::ServiceInstanceHelper(ServiceInstanceDescriptor desc, bool ignoreProps) : _def(std::move(desc))
 {
     //
     // If the service instance is not a template instance, its
@@ -1843,11 +1843,8 @@ ServiceInstanceHelper::print(const shared_ptr<Ice::Communicator>& communicator,
     }
 }
 
-ServerInstanceHelper::ServerInstanceHelper(
-    const ServerInstanceDescriptor& desc,
-    const Resolver& resolve,
-    bool instantiate)
-    : _def(desc)
+ServerInstanceHelper::ServerInstanceHelper(ServerInstanceDescriptor desc, const Resolver& resolve, bool instantiate)
+    : _def(std::move(desc))
 {
     init(nullptr, resolve, instantiate);
 }
@@ -2012,13 +2009,9 @@ ServerInstanceHelper::getReplicaGroups(set<string>& replicaGroups) const
     _serverInstance->getReplicaGroups(replicaGroups);
 }
 
-NodeHelper::NodeHelper(
-    const string& name,
-    const NodeDescriptor& descriptor,
-    const Resolver& appResolve,
-    bool instantiate)
-    : _name(name),
-      _def(descriptor),
+NodeHelper::NodeHelper(string name, NodeDescriptor descriptor, const Resolver& appResolve, bool instantiate)
+    : _name(std::move(name)),
+      _def(std::move(descriptor)),
       _instantiated(instantiate)
 {
     if (_name.empty())
@@ -2488,11 +2481,11 @@ NodeHelper::printDiff(Output& out, const NodeHelper& helper) const
 
 ApplicationHelper::ApplicationHelper(
     const shared_ptr<Ice::Communicator>& communicator,
-    const ApplicationDescriptor& appDesc,
+    ApplicationDescriptor appDesc,
     bool enableWarning,
     bool instantiate)
     : _communicator(communicator),
-      _def(appDesc)
+      _def(std::move(appDesc))
 {
     if (_def.name.empty())
     {
diff --git a/cpp/src/IceGrid/DescriptorHelper.h b/cpp/src/IceGrid/DescriptorHelper.h
index b8a4a69b279..848c8bf7f4f 100644
--- a/cpp/src/IceGrid/DescriptorHelper.h
+++ b/cpp/src/IceGrid/DescriptorHelper.h
@@ -170,7 +170,7 @@ namespace IceGrid
     class ServiceInstanceHelper final : public InstanceHelper
     {
     public:
-        ServiceInstanceHelper(const ServiceInstanceDescriptor&, bool);
+        ServiceInstanceHelper(ServiceInstanceDescriptor, bool);
 
         bool operator==(const ServiceInstanceHelper&) const;
         bool operator!=(const ServiceInstanceHelper&) const;
@@ -219,7 +219,7 @@ namespace IceGrid
     class ServerInstanceHelper final : public InstanceHelper
     {
     public:
-        ServerInstanceHelper(const ServerInstanceDescriptor&, const Resolver&, bool);
+        ServerInstanceHelper(ServerInstanceDescriptor, const Resolver&, bool);
         ServerInstanceHelper(const std::shared_ptr<ServerDescriptor>&, const Resolver&, bool);
 
         bool operator==(const ServerInstanceHelper&) const;
@@ -249,7 +249,7 @@ namespace IceGrid
     class NodeHelper final
     {
     public:
-        NodeHelper(const std::string&, const NodeDescriptor&, const Resolver&, bool);
+        NodeHelper(std::string, NodeDescriptor, const Resolver&, bool);
 
         bool operator==(const NodeHelper&) const;
         bool operator!=(const NodeHelper&) const;
@@ -283,7 +283,7 @@ namespace IceGrid
     class ApplicationHelper final
     {
     public:
-        ApplicationHelper(const Ice::CommunicatorPtr&, const ApplicationDescriptor&, bool = false, bool = true);
+        ApplicationHelper(const Ice::CommunicatorPtr&, ApplicationDescriptor, bool = false, bool = true);
 
         [[nodiscard]] ApplicationUpdateDescriptor diff(const ApplicationHelper&) const;
         [[nodiscard]] ApplicationDescriptor update(const ApplicationUpdateDescriptor&) const;
diff --git a/cpp/src/IceGrid/DescriptorParser.cpp b/cpp/src/IceGrid/DescriptorParser.cpp
index 86e3babc62b..894810926a7 100644
--- a/cpp/src/IceGrid/DescriptorParser.cpp
+++ b/cpp/src/IceGrid/DescriptorParser.cpp
@@ -21,7 +21,7 @@ namespace
     class DescriptorHandler final : public XMLHandler
     {
     public:
-        DescriptorHandler(const string&, const shared_ptr<Ice::Communicator>&);
+        DescriptorHandler(string, const shared_ptr<Ice::Communicator>&);
 
         void setAdmin(IceGrid::AdminPrx);
         void setVariables(const map<string, string>&, const vector<string>&);
@@ -67,9 +67,9 @@ namespace
         bool _inReplicaGroup;
     };
 
-    DescriptorHandler::DescriptorHandler(const string& filename, const shared_ptr<Ice::Communicator>& communicator)
+    DescriptorHandler::DescriptorHandler(string filename, const shared_ptr<Ice::Communicator>& communicator)
         : _communicator(communicator),
-          _filename(filename),
+          _filename(std::move(filename)),
           _isCurrentTargetDeployable(true),
           _currentCommunicator(nullptr),
           _isTopLevel(true),
diff --git a/cpp/src/IceGrid/FileCache.cpp b/cpp/src/IceGrid/FileCache.cpp
index 37d124f6daa..19a9897fc03 100644
--- a/cpp/src/IceGrid/FileCache.cpp
+++ b/cpp/src/IceGrid/FileCache.cpp
@@ -2,12 +2,10 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
+#include "FileCache.h"
+#include "../Ice/FileUtil.h"
 #include "Ice/Communicator.h"
 #include "Ice/Properties.h"
-
-#include "../Ice/FileUtil.h"
-
-#include "FileCache.h"
 #include "IceGrid/Exception.h"
 
 #include <deque>
diff --git a/cpp/src/IceGrid/InternalRegistryI.cpp b/cpp/src/IceGrid/InternalRegistryI.cpp
index 267703e8a25..1fd0a4e94d0 100644
--- a/cpp/src/IceGrid/InternalRegistryI.cpp
+++ b/cpp/src/IceGrid/InternalRegistryI.cpp
@@ -2,14 +2,12 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
-#include "../Ice/DisableWarnings.h"
-
+#include "InternalRegistryI.h"
 #include "../Ice/SSL/RFC2253.h"
 #include "../Ice/SSL/SSLUtil.h"
 #include "Database.h"
 #include "FileCache.h"
 #include "Ice/Ice.h"
-#include "InternalRegistryI.h"
 #include "NodeSessionI.h"
 #include "ReapThread.h"
 #include "RegistryI.h"
@@ -18,6 +16,8 @@
 #include "Topics.h"
 #include "WellKnownObjectsManager.h"
 
+#include "../Ice/DisableWarnings.h"
+
 using namespace std;
 using namespace IceGrid;
 
diff --git a/cpp/src/IceGrid/LocatorI.cpp b/cpp/src/IceGrid/LocatorI.cpp
index 5c0578804dc..6429c173067 100644
--- a/cpp/src/IceGrid/LocatorI.cpp
+++ b/cpp/src/IceGrid/LocatorI.cpp
@@ -25,11 +25,11 @@ namespace
             function<void(const optional<Ice::ObjectPrx>&)> response,
             const shared_ptr<LocatorI>& locator,
             const Ice::EncodingVersion& encoding,
-            const LocatorAdapterInfo& adapter)
+            LocatorAdapterInfo adapter)
             : _response(std::move(response)),
               _locator(locator),
               _encoding(encoding),
-              _adapter(adapter),
+              _adapter(std::move(adapter)),
               _traceLevels(locator->getTraceLevels())
         {
             assert(_adapter.proxy);
@@ -83,16 +83,16 @@ namespace
         ReplicaGroupRequest(
             function<void(const optional<Ice::ObjectPrx>&)> response,
             const shared_ptr<LocatorI>& locator,
-            const string& id,
+            string id,
             const Ice::EncodingVersion& encoding,
-            const LocatorAdapterInfoSeq& adapters,
+            LocatorAdapterInfoSeq adapters,
             int count,
             optional<Ice::ObjectPrx> firstProxy)
             : _response(std::move(response)),
               _locator(locator),
-              _id(id),
+              _id(std::move(id)),
               _encoding(encoding),
-              _adapters(adapters),
+              _adapters(std::move(adapters)),
               _traceLevels(locator->getTraceLevels()),
               _count(static_cast<unsigned int>(count)),
               _lastAdapter(_adapters.begin())
@@ -299,19 +299,19 @@ namespace
             function<void(exception_ptr)> exception,
             const shared_ptr<LocatorI>& locator,
             const shared_ptr<Database> database,
-            const string& id,
+            string id,
             const Ice::Current& current,
-            const LocatorAdapterInfoSeq& adapters,
+            LocatorAdapterInfoSeq adapters,
             int count)
             : _response(std::move(response)),
               _exception(std::move(exception)),
               _locator(locator),
               _database(database),
-              _id(id),
+              _id(std::move(id)),
               _encoding(current.encoding),
               _connection(current.con),
               _context(current.ctx),
-              _adapters(adapters),
+              _adapters(std::move(adapters)),
               _traceLevels(locator->getTraceLevels()),
               _count(count),
               _waitForActivation(false)
@@ -610,13 +610,13 @@ namespace
             const shared_ptr<LocatorI>& locator,
             function<void(const optional<Ice::ObjectPrx>&)> response,
             function<void(exception_ptr)> exception,
-            const string& id,
-            const Ice::Current& current)
+            string id,
+            Ice::Current current)
             : _locator(locator),
               _response(std::move(response)),
               _exception(std::move(exception)),
-              _id(id),
-              _current(current)
+              _id(std::move(id)),
+              _current(std::move(current))
         {
         }
 
diff --git a/cpp/src/IceGrid/LocatorRegistryI.cpp b/cpp/src/IceGrid/LocatorRegistryI.cpp
index 29515994b35..1ff9356e330 100644
--- a/cpp/src/IceGrid/LocatorRegistryI.cpp
+++ b/cpp/src/IceGrid/LocatorRegistryI.cpp
@@ -77,14 +77,14 @@ namespace IceGrid
             const shared_ptr<LocatorRegistryI>& registry,
             function<void()> response,
             function<void(exception_ptr)> exception,
-            const string& adapterId,
-            const string& replicaGroupId,
+            string adapterId,
+            string replicaGroupId,
             optional<Ice::ObjectPrx> proxy)
             : _registry(registry),
               _response(std::move(response)),
               _exception(std::move(exception)),
-              _adapterId(adapterId),
-              _replicaGroupId(replicaGroupId),
+              _adapterId(std::move(adapterId)),
+              _replicaGroupId(std::move(replicaGroupId)),
               _proxy(std::move(proxy))
         {
         }
@@ -119,12 +119,12 @@ namespace IceGrid
             const shared_ptr<LocatorRegistryI>& registry,
             const function<void()> response,
             const function<void(exception_ptr)> exception,
-            const string& id,
+            string id,
             Ice::ProcessPrx proxy)
             : _registry(registry),
               _response(std::move(response)),
               _exception(std::move(exception)),
-              _id(id),
+              _id(std::move(id)),
               _proxy(std::move(proxy))
         {
         }
diff --git a/cpp/src/IceGrid/NodeCache.cpp b/cpp/src/IceGrid/NodeCache.cpp
index 3795d76f4df..6fe6348c29f 100644
--- a/cpp/src/IceGrid/NodeCache.cpp
+++ b/cpp/src/IceGrid/NodeCache.cpp
@@ -37,12 +37,9 @@ namespace
     }
 }
 
-NodeCache::NodeCache(
-    const shared_ptr<Ice::Communicator>& communicator,
-    ReplicaCache& replicaCache,
-    const string& replicaName)
+NodeCache::NodeCache(const shared_ptr<Ice::Communicator>& communicator, ReplicaCache& replicaCache, string replicaName)
     : _communicator(communicator),
-      _replicaName(replicaName),
+      _replicaName(std::move(replicaName)),
       _replicaCache(replicaCache)
 {
 }
@@ -91,9 +88,9 @@ NodeCache::get(const string& name, bool create) const
     return entry;
 }
 
-NodeEntry::NodeEntry(NodeCache& cache, const std::string& name)
+NodeEntry::NodeEntry(NodeCache& cache, std::string name)
     : _cache(cache),
-      _name(name),
+      _name(std::move(name)),
       _registering(false),
       _selfRemovingRefCount(0)
 {
diff --git a/cpp/src/IceGrid/NodeCache.h b/cpp/src/IceGrid/NodeCache.h
index 8b480015f8a..5c3e73e6e49 100644
--- a/cpp/src/IceGrid/NodeCache.h
+++ b/cpp/src/IceGrid/NodeCache.h
@@ -21,7 +21,7 @@ namespace IceGrid
     class NodeEntry final
     {
     public:
-        NodeEntry(NodeCache&, const std::string&);
+        NodeEntry(NodeCache&, std::string);
 
         void addDescriptor(const std::string&, const NodeDescriptor&);
         void removeDescriptor(const std::string&);
@@ -90,7 +90,7 @@ namespace IceGrid
     public:
         using ValueType = NodeEntry*;
 
-        NodeCache(const Ice::CommunicatorPtr&, ReplicaCache&, const std::string&);
+        NodeCache(const Ice::CommunicatorPtr&, ReplicaCache&, std::string);
 
         [[nodiscard]] std::shared_ptr<NodeEntry> get(const std::string&, bool = false) const;
 
diff --git a/cpp/src/IceGrid/NodeI.cpp b/cpp/src/IceGrid/NodeI.cpp
index 348b8d31a8d..c688eb396b7 100644
--- a/cpp/src/IceGrid/NodeI.cpp
+++ b/cpp/src/IceGrid/NodeI.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "NodeI.h"
+
 #include "../Ice/FileUtil.h"
 #include "Activator.h"
 #include "Ice/Ice.h"
@@ -48,24 +49,24 @@ NodeI::NodeI(
     const Ice::ObjectAdapterPtr& adapter,
     NodeSessionManager& sessions,
     const shared_ptr<Activator>& activator,
-    const IceInternal::TimerPtr& timer,
+    IceInternal::TimerPtr timer,
     const shared_ptr<TraceLevels>& traceLevels,
     NodePrx proxy,
-    const string& name,
+    string name,
     const optional<UserAccountMapperPrx>& mapper,
-    const string& instanceName)
+    string instanceName)
     : _communicator(adapter->getCommunicator()),
       _adapter(adapter),
       _sessions(sessions),
       _activator(activator),
-      _timer(timer),
+      _timer(std::move(timer)),
       _traceLevels(traceLevels),
-      _name(name),
+      _name(std::move(name)),
       _proxy(std::move(proxy)),
       _redirectErrToOut(false),
       _allowEndpointsOverride(false),
       _waitTime(0),
-      _instanceName(instanceName),
+      _instanceName(std::move(instanceName)),
       _userAccountMapper(mapper),
       _platform("IceGrid.Node", _communicator, _traceLevels),
       _fileCache(make_shared<FileCache>(_communicator)),
diff --git a/cpp/src/IceGrid/NodeI.h b/cpp/src/IceGrid/NodeI.h
index 2e986f8e55c..28d2d8af314 100644
--- a/cpp/src/IceGrid/NodeI.h
+++ b/cpp/src/IceGrid/NodeI.h
@@ -44,12 +44,12 @@ namespace IceGrid
             const Ice::ObjectAdapterPtr&,
             NodeSessionManager&,
             const std::shared_ptr<Activator>&,
-            const IceInternal::TimerPtr&,
+            IceInternal::TimerPtr,
             const std::shared_ptr<TraceLevels>&,
             NodePrx,
-            const std::string&,
+            std::string,
             const std::optional<UserAccountMapperPrx>&,
-            const std::string&);
+            std::string);
 
         void loadServerAsync(
             std::shared_ptr<InternalServerDescriptor>,
diff --git a/cpp/src/IceGrid/ObjectCache.cpp b/cpp/src/IceGrid/ObjectCache.cpp
index f6bfac88960..3228d73c3f3 100644
--- a/cpp/src/IceGrid/ObjectCache.cpp
+++ b/cpp/src/IceGrid/ObjectCache.cpp
@@ -160,10 +160,10 @@ ObjectCache::getAllByType(const string& type)
     return infos;
 }
 
-ObjectEntry::ObjectEntry(const ObjectInfo& info, const string& application, const string& server)
-    : _info(info),
-      _application(application),
-      _server(server)
+ObjectEntry::ObjectEntry(ObjectInfo info, string application, string server)
+    : _info(std::move(info)),
+      _application(std::move(application)),
+      _server(std::move(server))
 {
 }
 
diff --git a/cpp/src/IceGrid/ObjectCache.h b/cpp/src/IceGrid/ObjectCache.h
index f1fb916dcf6..53bc073d2ef 100644
--- a/cpp/src/IceGrid/ObjectCache.h
+++ b/cpp/src/IceGrid/ObjectCache.h
@@ -16,7 +16,7 @@ namespace IceGrid
     class ObjectEntry
     {
     public:
-        ObjectEntry(const ObjectInfo&, const std::string&, const std::string&);
+        ObjectEntry(ObjectInfo, std::string, std::string);
         [[nodiscard]] Ice::ObjectPrx getProxy() const;
         [[nodiscard]] std::string getType() const;
         [[nodiscard]] std::string getApplication() const;
diff --git a/cpp/src/IceGrid/Parser.cpp b/cpp/src/IceGrid/Parser.cpp
index 60f4d290063..fd10829c44e 100644
--- a/cpp/src/IceGrid/Parser.cpp
+++ b/cpp/src/IceGrid/Parser.cpp
@@ -4,7 +4,6 @@
 
 #include "Parser.h"
 #include "../Ice/ConsoleUtil.h"
-#include "../Ice/DisableWarnings.h"
 #include "../Ice/Options.h"
 #include "../Ice/TimeUtil.h"
 #include "DescriptorHelper.h"
@@ -14,6 +13,8 @@
 #include "Util.h"
 #include "XMLParser.h"
 
+#include "../Ice/DisableWarnings.h"
+
 #if defined(__APPLE__) || defined(__linux__)
 #    include <editline/readline.h>
 #    include <unistd.h>
diff --git a/cpp/src/IceGrid/PlatformInfo.cpp b/cpp/src/IceGrid/PlatformInfo.cpp
index 03c73e7834e..a936169b144 100644
--- a/cpp/src/IceGrid/PlatformInfo.cpp
+++ b/cpp/src/IceGrid/PlatformInfo.cpp
@@ -2,15 +2,13 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
+#include "PlatformInfo.h"
 #include "../Ice/FileUtil.h"
-#include "Ice/StringUtil.h"
-
 #include "Ice/Communicator.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/LoggerUtil.h"
 #include "Ice/Properties.h"
-
-#include "PlatformInfo.h"
+#include "Ice/StringUtil.h"
 #include "TraceLevels.h"
 
 #include <climits>
diff --git a/cpp/src/IceGrid/QueryI.cpp b/cpp/src/IceGrid/QueryI.cpp
index 32417d6f7c2..e5912b56882 100644
--- a/cpp/src/IceGrid/QueryI.cpp
+++ b/cpp/src/IceGrid/QueryI.cpp
@@ -10,8 +10,8 @@ using namespace std;
 using namespace Ice;
 using namespace IceGrid;
 
-QueryI::QueryI(const CommunicatorPtr& communicator, const shared_ptr<Database>& database)
-    : _communicator(communicator),
+QueryI::QueryI(CommunicatorPtr communicator, const shared_ptr<Database>& database)
+    : _communicator(std::move(communicator)),
       _database(database)
 {
 }
diff --git a/cpp/src/IceGrid/QueryI.h b/cpp/src/IceGrid/QueryI.h
index ecb0bc66f51..72aea6218da 100644
--- a/cpp/src/IceGrid/QueryI.h
+++ b/cpp/src/IceGrid/QueryI.h
@@ -15,7 +15,7 @@ namespace IceGrid
     class QueryI final : public Query
     {
     public:
-        QueryI(const Ice::CommunicatorPtr&, const std::shared_ptr<Database>&);
+        QueryI(Ice::CommunicatorPtr, const std::shared_ptr<Database>&);
 
         [[nodiscard]] std::optional<Ice::ObjectPrx> findObjectById(Ice::Identity, const Ice::Current&) const override;
 
diff --git a/cpp/src/IceGrid/ReapThread.h b/cpp/src/IceGrid/ReapThread.h
index 4d190329cff..1035483a27e 100644
--- a/cpp/src/IceGrid/ReapThread.h
+++ b/cpp/src/IceGrid/ReapThread.h
@@ -27,8 +27,8 @@ namespace IceGrid
     template<class T> class SessionReapable final : public Reapable
     {
     public:
-        SessionReapable(const Ice::LoggerPtr& logger, const std::shared_ptr<T>& session)
-            : _logger(logger),
+        SessionReapable(Ice::LoggerPtr logger, const std::shared_ptr<T>& session)
+            : _logger(std::move(logger)),
               _session(session)
         {
         }
diff --git a/cpp/src/IceGrid/RegistryAdminRouter.cpp b/cpp/src/IceGrid/RegistryAdminRouter.cpp
index f28789a5abb..8e2aca9e68d 100644
--- a/cpp/src/IceGrid/RegistryAdminRouter.cpp
+++ b/cpp/src/IceGrid/RegistryAdminRouter.cpp
@@ -21,12 +21,12 @@ namespace
             pair<const byte*, const byte*> inParams,
             function<void(bool, pair<const byte*, const byte*>)> response,
             function<void(exception_ptr)> exception,
-            const Current& current)
+            Current current)
             : _adminRouter(adminRouter),
               _response(std::move(response)),
               _exception(std::move(exception)),
               _inParams(inParams.first, inParams.second),
-              _current(current)
+              _current(std::move(current))
         {
         }
 
@@ -106,9 +106,9 @@ RegistryServerAdminRouter::ice_invokeAsync(
     invokeOnTarget(target->ice_facet(current.facet), inParams, std::move(response), std::move(exception), current);
 }
 
-RegistryNodeAdminRouter::RegistryNodeAdminRouter(const string& collocNodeName, const shared_ptr<Database>& database)
+RegistryNodeAdminRouter::RegistryNodeAdminRouter(string collocNodeName, const shared_ptr<Database>& database)
     : AdminRouter(database->getTraceLevels()),
-      _collocNodeName(collocNodeName),
+      _collocNodeName(std::move(collocNodeName)),
       _database(database)
 {
 }
@@ -155,9 +155,9 @@ RegistryNodeAdminRouter::ice_invokeAsync(
     invokeOnTarget(target->ice_facet(current.facet), inParams, std::move(response), std::move(exception), current);
 }
 
-RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(const string& name, const shared_ptr<Database>& database)
+RegistryReplicaAdminRouter::RegistryReplicaAdminRouter(string name, const shared_ptr<Database>& database)
     : AdminRouter(database->getTraceLevels()),
-      _name(name),
+      _name(std::move(name)),
       _database(database)
 {
 }
diff --git a/cpp/src/IceGrid/RegistryAdminRouter.h b/cpp/src/IceGrid/RegistryAdminRouter.h
index cfcca83e900..5c2ef939e4c 100644
--- a/cpp/src/IceGrid/RegistryAdminRouter.h
+++ b/cpp/src/IceGrid/RegistryAdminRouter.h
@@ -29,7 +29,7 @@ namespace IceGrid
     class RegistryNodeAdminRouter final : public AdminRouter
     {
     public:
-        RegistryNodeAdminRouter(const std::string&, const std::shared_ptr<Database>&);
+        RegistryNodeAdminRouter(std::string, const std::shared_ptr<Database>&);
 
         void ice_invokeAsync(
             std::pair<const std::byte*, const std::byte*>,
@@ -45,7 +45,7 @@ namespace IceGrid
     class RegistryReplicaAdminRouter final : public AdminRouter
     {
     public:
-        RegistryReplicaAdminRouter(const std::string&, const std::shared_ptr<Database>&);
+        RegistryReplicaAdminRouter(std::string, const std::shared_ptr<Database>&);
 
         void ice_invokeAsync(
             std::pair<const std::byte*, const std::byte*>,
diff --git a/cpp/src/IceGrid/RegistryI.cpp b/cpp/src/IceGrid/RegistryI.cpp
index 5c068fb29fe..d61a8663caa 100644
--- a/cpp/src/IceGrid/RegistryI.cpp
+++ b/cpp/src/IceGrid/RegistryI.cpp
@@ -24,13 +24,12 @@
 #include "LocatorRegistryI.h"
 #include "QueryI.h"
 #include "ReapThread.h"
+#include "RegistryAdminRouter.h"
 #include "SessionI.h"
 #include "SessionServantManager.h"
 #include "TraceLevels.h"
 #include "WellKnownObjectsManager.h"
 
-#include "RegistryAdminRouter.h"
-
 #include <fstream>
 
 #include <sys/types.h>
@@ -45,10 +44,10 @@ namespace
     {
     public:
         LookupI(
-            const string& instanceName,
+            string instanceName,
             const shared_ptr<WellKnownObjectsManager>& wellKnownObjects,
             const shared_ptr<TraceLevels>& traceLevels)
-            : _instanceName(instanceName),
+            : _instanceName(std::move(instanceName)),
               _wellKnownObjects(wellKnownObjects),
               _traceLevels(traceLevels)
         {
@@ -142,14 +141,14 @@ RegistryI::RegistryI(
     const shared_ptr<TraceLevels>& traceLevels,
     bool nowarn,
     bool readonly,
-    const string& initFromReplica,
-    const string& collocatedNodeName)
+    string initFromReplica,
+    string collocatedNodeName)
     : _communicator(communicator),
       _traceLevels(traceLevels),
       _nowarn(nowarn),
       _readonly(readonly),
-      _initFromReplica(initFromReplica),
-      _collocatedNodeName(collocatedNodeName),
+      _initFromReplica(std::move(initFromReplica)),
+      _collocatedNodeName(std::move(collocatedNodeName)),
       _platform("IceGrid.Registry", communicator, traceLevels)
 {
 }
diff --git a/cpp/src/IceGrid/RegistryI.h b/cpp/src/IceGrid/RegistryI.h
index 610432f05a4..631f8f5eb08 100644
--- a/cpp/src/IceGrid/RegistryI.h
+++ b/cpp/src/IceGrid/RegistryI.h
@@ -34,8 +34,8 @@ namespace IceGrid
             const std::shared_ptr<TraceLevels>&,
             bool,
             bool,
-            const std::string&,
-            const std::string&);
+            std::string,
+            std::string);
         ~RegistryI() override = default;
 
         bool start();
diff --git a/cpp/src/IceGrid/ReplicaCache.cpp b/cpp/src/IceGrid/ReplicaCache.cpp
index 69cac6632c7..4d932a2781c 100644
--- a/cpp/src/IceGrid/ReplicaCache.cpp
+++ b/cpp/src/IceGrid/ReplicaCache.cpp
@@ -275,8 +275,8 @@ ReplicaCache::getInternalRegistry() const
     return *_self;
 }
 
-ReplicaEntry::ReplicaEntry(const std::string& name, const shared_ptr<ReplicaSessionI>& session)
-    : _name(name),
+ReplicaEntry::ReplicaEntry(std::string name, const shared_ptr<ReplicaSessionI>& session)
+    : _name(std::move(name)),
       _session(session)
 {
 }
diff --git a/cpp/src/IceGrid/ReplicaCache.h b/cpp/src/IceGrid/ReplicaCache.h
index 6a1fa1a0672..56df2b7b3fb 100644
--- a/cpp/src/IceGrid/ReplicaCache.h
+++ b/cpp/src/IceGrid/ReplicaCache.h
@@ -17,7 +17,7 @@ namespace IceGrid
     class ReplicaEntry final
     {
     public:
-        ReplicaEntry(const std::string&, const std::shared_ptr<ReplicaSessionI>&);
+        ReplicaEntry(std::string, const std::shared_ptr<ReplicaSessionI>&);
 
         [[nodiscard]] bool canRemove() const { return true; }
         [[nodiscard]] const std::shared_ptr<ReplicaSessionI>& getSession() const;
diff --git a/cpp/src/IceGrid/ServerAdapterI.cpp b/cpp/src/IceGrid/ServerAdapterI.cpp
index 06cbf1e5ec1..c937b379229 100644
--- a/cpp/src/IceGrid/ServerAdapterI.cpp
+++ b/cpp/src/IceGrid/ServerAdapterI.cpp
@@ -14,14 +14,14 @@ using namespace IceGrid;
 ServerAdapterI::ServerAdapterI(
     const shared_ptr<NodeI>& node,
     ServerI* server,
-    const string& serverName,
+    string serverName,
     AdapterPrx proxy,
-    const string& id,
+    string id,
     bool enabled)
     : _node(node),
       _this(std::move(proxy)),
-      _serverId(serverName),
-      _id(id),
+      _serverId(std::move(serverName)),
+      _id(std::move(id)),
       _server(server),
       _enabled(enabled)
 {
diff --git a/cpp/src/IceGrid/ServerAdapterI.h b/cpp/src/IceGrid/ServerAdapterI.h
index c13756b6506..2fd9675261c 100644
--- a/cpp/src/IceGrid/ServerAdapterI.h
+++ b/cpp/src/IceGrid/ServerAdapterI.h
@@ -15,13 +15,7 @@ namespace IceGrid
     class ServerAdapterI : public Adapter
     {
     public:
-        ServerAdapterI(
-            const std::shared_ptr<NodeI>&,
-            ServerI*,
-            const std::string&,
-            AdapterPrx,
-            const std::string&,
-            bool);
+        ServerAdapterI(const std::shared_ptr<NodeI>&, ServerI*, std::string, AdapterPrx, std::string, bool);
         ~ServerAdapterI() override;
 
         void activateAsync(
diff --git a/cpp/src/IceGrid/ServerCache.cpp b/cpp/src/IceGrid/ServerCache.cpp
index 0cde1e5a884..d4d66f6d257 100644
--- a/cpp/src/IceGrid/ServerCache.cpp
+++ b/cpp/src/IceGrid/ServerCache.cpp
@@ -20,14 +20,9 @@
 using namespace std;
 using namespace IceGrid;
 
-CheckUpdateResult::CheckUpdateResult(
-    const string& server,
-    const string& node,
-    bool noRestart,
-    bool remove,
-    future<bool>&& result)
-    : _server(server),
-      _node(node),
+CheckUpdateResult::CheckUpdateResult(string server, string node, bool noRestart, bool remove, future<bool>&& result)
+    : _server(std::move(server)),
+      _node(std::move(node)),
       _remove(remove),
       _noRestart(noRestart),
       _result(std::move(result))
@@ -72,13 +67,13 @@ CheckUpdateResult::getResult()
 
 ServerCache::ServerCache(
     const shared_ptr<Ice::Communicator>& communicator,
-    const string& instanceName,
+    string instanceName,
     NodeCache& nodeCache,
     AdapterCache& adapterCache,
     ObjectCache& objectCache,
     AllocatableObjectCache& allocatableObjectCache)
     : _communicator(communicator),
-      _instanceName(instanceName),
+      _instanceName(std::move(instanceName)),
       _nodeCache(nodeCache),
       _adapterCache(adapterCache),
       _objectCache(objectCache),
@@ -322,10 +317,10 @@ ServerCache::removeCommunicator(
     }
 }
 
-ServerEntry::ServerEntry(ServerCache& cache, const string& id)
+ServerEntry::ServerEntry(ServerCache& cache, string id)
     : Allocatable(false, nullptr),
       _cache(cache),
-      _id(id),
+      _id(std::move(id)),
       _activationTimeout(-1),
       _deactivationTimeout(-1),
       _synchronizing(false),
diff --git a/cpp/src/IceGrid/ServerCache.h b/cpp/src/IceGrid/ServerCache.h
index d246ce48230..ad0a227058e 100644
--- a/cpp/src/IceGrid/ServerCache.h
+++ b/cpp/src/IceGrid/ServerCache.h
@@ -25,7 +25,7 @@ namespace IceGrid
     class CheckUpdateResult final
     {
     public:
-        CheckUpdateResult(const std::string&, const std::string&, bool, bool, std::future<bool>&&);
+        CheckUpdateResult(std::string, std::string, bool, bool, std::future<bool>&&);
 
         bool getResult();
 
@@ -42,7 +42,7 @@ namespace IceGrid
     class ServerEntry final : public Allocatable
     {
     public:
-        ServerEntry(ServerCache&, const std::string&);
+        ServerEntry(ServerCache&, std::string);
 
         void sync();
         void waitForSync(std::chrono::seconds);
@@ -122,7 +122,7 @@ namespace IceGrid
     public:
         ServerCache(
             const Ice::CommunicatorPtr&,
-            const std::string&,
+            std::string,
             NodeCache&,
             AdapterCache&,
             ObjectCache&,
diff --git a/cpp/src/IceGrid/ServerI.cpp b/cpp/src/IceGrid/ServerI.cpp
index bf21a21b640..0852866ed78 100644
--- a/cpp/src/IceGrid/ServerI.cpp
+++ b/cpp/src/IceGrid/ServerI.cpp
@@ -381,10 +381,10 @@ ServerCommand::ServerCommand(const shared_ptr<ServerI>& server) : _server(server
 
 TimedServerCommand::TimedServerCommand(
     const shared_ptr<ServerI>& server,
-    const IceInternal::TimerPtr& timer,
+    IceInternal::TimerPtr timer,
     chrono::seconds timeout)
     : ServerCommand(server),
-      _timer(timer),
+      _timer(std::move(timer)),
       _timeout(timeout)
 {
 }
diff --git a/cpp/src/IceGrid/ServerI.h b/cpp/src/IceGrid/ServerI.h
index 6e9734e811d..41d13b77380 100644
--- a/cpp/src/IceGrid/ServerI.h
+++ b/cpp/src/IceGrid/ServerI.h
@@ -190,7 +190,7 @@ namespace IceGrid
     class TimedServerCommand : public ServerCommand, public std::enable_shared_from_this<TimedServerCommand>
     {
     public:
-        TimedServerCommand(const std::shared_ptr<ServerI>&, const IceInternal::TimerPtr&, std::chrono::seconds);
+        TimedServerCommand(const std::shared_ptr<ServerI>&, IceInternal::TimerPtr, std::chrono::seconds);
         virtual void timeout() = 0;
 
         void startTimer();
diff --git a/cpp/src/IceGrid/SessionI.cpp b/cpp/src/IceGrid/SessionI.cpp
index 93d1b56ae65..120619f5c23 100644
--- a/cpp/src/IceGrid/SessionI.cpp
+++ b/cpp/src/IceGrid/SessionI.cpp
@@ -48,9 +48,9 @@ namespace IceGrid
     };
 }
 
-BaseSessionI::BaseSessionI(const string& id, const string& prefix, const shared_ptr<Database>& database)
-    : _id(id),
-      _prefix(prefix),
+BaseSessionI::BaseSessionI(string id, string prefix, const shared_ptr<Database>& database)
+    : _id(std::move(id)),
+      _prefix(std::move(prefix)),
       _traceLevels(database->getTraceLevels()),
       _database(database),
       _destroyed(false)
@@ -110,9 +110,9 @@ BaseSessionI::getGlacier2AdapterIdSet()
     return _servantManager->getGlacier2AdapterIdSet(shared_from_this());
 }
 
-SessionI::SessionI(const string& id, const shared_ptr<Database>& database, const IceInternal::TimerPtr& timer)
+SessionI::SessionI(const string& id, const shared_ptr<Database>& database, IceInternal::TimerPtr timer)
     : BaseSessionI(id, "client", database),
-      _timer(timer),
+      _timer(std::move(timer)),
       _allocationTimeout(-1)
 {
 }
@@ -260,11 +260,11 @@ SessionI::destroyImpl(bool shutdown)
 ClientSessionFactory::ClientSessionFactory(
     const shared_ptr<SessionServantManager>& servantManager,
     const shared_ptr<Database>& database,
-    const IceInternal::TimerPtr& timer,
+    IceInternal::TimerPtr timer,
     const shared_ptr<ReapThread>& reaper)
     : _servantManager(servantManager),
       _database(database),
-      _timer(timer),
+      _timer(std::move(timer)),
       _reaper(reaper),
       _filters(false)
 {
diff --git a/cpp/src/IceGrid/SessionI.h b/cpp/src/IceGrid/SessionI.h
index 9c6da3573b6..17ffd61fb4a 100644
--- a/cpp/src/IceGrid/SessionI.h
+++ b/cpp/src/IceGrid/SessionI.h
@@ -35,7 +35,7 @@ namespace IceGrid
         virtual void destroyImpl(bool);
 
     protected:
-        BaseSessionI(const std::string&, const std::string&, const std::shared_ptr<Database>&);
+        BaseSessionI(std::string, std::string, const std::shared_ptr<Database>&);
 
         const std::string _id;
         const std::string _prefix;
@@ -54,7 +54,7 @@ namespace IceGrid
     class SessionI final : public BaseSessionI, public Session
     {
     public:
-        SessionI(const std::string&, const std::shared_ptr<Database>&, const IceInternal::TimerPtr&);
+        SessionI(const std::string&, const std::shared_ptr<Database>&, IceInternal::TimerPtr);
 
         Ice::ObjectPrx _register(const std::shared_ptr<SessionServantManager>&, const Ice::ConnectionPtr&);
 
@@ -96,7 +96,7 @@ namespace IceGrid
         ClientSessionFactory(
             const std::shared_ptr<SessionServantManager>&,
             const std::shared_ptr<Database>&,
-            const IceInternal::TimerPtr&,
+            IceInternal::TimerPtr,
             const std::shared_ptr<ReapThread>&);
 
         Glacier2::SessionPrx createGlacier2Session(
diff --git a/cpp/src/IceGrid/SessionManager.h b/cpp/src/IceGrid/SessionManager.h
index 5a54d8280d8..be3169bc3af 100644
--- a/cpp/src/IceGrid/SessionManager.h
+++ b/cpp/src/IceGrid/SessionManager.h
@@ -7,7 +7,6 @@
 
 #include "Ice/Logger.h"
 #include "Ice/LoggerUtil.h"
-
 #include "IceGrid/Registry.h"
 #include "Internal.h"
 #include "Util.h"
@@ -33,9 +32,9 @@ namespace IceGrid
         };
 
     public:
-        SessionKeepAliveThread(std::optional<InternalRegistryPrx> registry, const Ice::LoggerPtr& logger)
+        SessionKeepAliveThread(std::optional<InternalRegistryPrx> registry, Ice::LoggerPtr logger)
             : _registry(std::move(registry)),
-              _logger(logger),
+              _logger(std::move(logger)),
               _state(InProgress),
               _nextAction(None),
               _thread([this] { run(); })
diff --git a/cpp/src/IceGrid/SessionServantManager.cpp b/cpp/src/IceGrid/SessionServantManager.cpp
index 3de31aa0a53..7551df02dc4 100644
--- a/cpp/src/IceGrid/SessionServantManager.cpp
+++ b/cpp/src/IceGrid/SessionServantManager.cpp
@@ -12,25 +12,25 @@ using namespace std;
 using namespace IceGrid;
 
 SessionServantManager::SessionServantManager(
-    const Ice::ObjectAdapterPtr& adapter,
-    const string& instanceName,
+    Ice::ObjectAdapterPtr adapter,
+    string instanceName,
     bool checkConnection,
-    const string& serverAdminCategory,
-    const Ice::ObjectPtr& serverAdminRouter,
-    const string& nodeAdminCategory,
-    const Ice::ObjectPtr& nodeAdminRouter,
-    const string& replicaAdminCategory,
-    const Ice::ObjectPtr& replicaAdminRouter,
+    string serverAdminCategory,
+    Ice::ObjectPtr serverAdminRouter,
+    string nodeAdminCategory,
+    Ice::ObjectPtr nodeAdminRouter,
+    string replicaAdminCategory,
+    Ice::ObjectPtr replicaAdminRouter,
     const shared_ptr<AdminCallbackRouter>& adminCallbackRouter)
-    : _adapter(adapter),
-      _instanceName(instanceName),
+    : _adapter(std::move(adapter)),
+      _instanceName(std::move(instanceName)),
       _checkConnection(checkConnection),
-      _serverAdminCategory(serverAdminCategory),
-      _serverAdminRouter(serverAdminRouter),
-      _nodeAdminCategory(nodeAdminCategory),
-      _nodeAdminRouter(nodeAdminRouter),
-      _replicaAdminCategory(replicaAdminCategory),
-      _replicaAdminRouter(replicaAdminRouter),
+      _serverAdminCategory(std::move(serverAdminCategory)),
+      _serverAdminRouter(std::move(serverAdminRouter)),
+      _nodeAdminCategory(std::move(nodeAdminCategory)),
+      _nodeAdminRouter(std::move(nodeAdminRouter)),
+      _replicaAdminCategory(std::move(replicaAdminCategory)),
+      _replicaAdminRouter(std::move(replicaAdminRouter)),
       _adminCallbackRouter(adminCallbackRouter)
 {
 }
diff --git a/cpp/src/IceGrid/SessionServantManager.h b/cpp/src/IceGrid/SessionServantManager.h
index bb1ebf8c54b..6f2c2c4d286 100644
--- a/cpp/src/IceGrid/SessionServantManager.h
+++ b/cpp/src/IceGrid/SessionServantManager.h
@@ -6,9 +6,8 @@
 #define ICEGRID_SESSIONSERVANTLOCATOR_H
 
 #include "AdminCallbackRouter.h"
-#include "Ice/ServantLocator.h"
-
 #include "Glacier2/Session.h"
+#include "Ice/ServantLocator.h"
 
 #include <set>
 
@@ -18,15 +17,15 @@ namespace IceGrid
     {
     public:
         SessionServantManager(
-            const Ice::ObjectAdapterPtr&,
-            const std::string&,
+            Ice::ObjectAdapterPtr,
+            std::string,
             bool,
-            const std::string&,
-            const Ice::ObjectPtr&,
-            const std::string&,
-            const Ice::ObjectPtr&,
-            const std::string&,
-            const Ice::ObjectPtr&,
+            std::string,
+            Ice::ObjectPtr,
+            std::string,
+            Ice::ObjectPtr,
+            std::string,
+            Ice::ObjectPtr,
             const std::shared_ptr<AdminCallbackRouter>&);
 
         Ice::ObjectPtr locate(const Ice::Current&, std::shared_ptr<void>&) override;
@@ -49,10 +48,10 @@ namespace IceGrid
 
         struct ServantInfo
         {
-            ServantInfo(const Ice::ObjectPtr& s, const Ice::ConnectionPtr& con, const Ice::ObjectPtr& ss)
-                : servant(s),
-                  connection(con),
-                  session(ss)
+            ServantInfo(Ice::ObjectPtr s, Ice::ConnectionPtr con, Ice::ObjectPtr ss)
+                : servant(std::move(s)),
+                  connection(std::move(con)),
+                  session(std::move(ss))
             {
             }
 
@@ -63,7 +62,7 @@ namespace IceGrid
 
         struct SessionInfo
         {
-            SessionInfo(const Ice::ConnectionPtr& c, const std::string& cat) : connection(c), category(cat) {}
+            SessionInfo(Ice::ConnectionPtr c, std::string cat) : connection(std::move(c)), category(std::move(cat)) {}
 
             const Ice::ConnectionPtr connection;
             const std::string category;
diff --git a/cpp/src/IceLocatorDiscovery/PluginI.cpp b/cpp/src/IceLocatorDiscovery/PluginI.cpp
index 6e3f836e50c..c1454b9b69d 100644
--- a/cpp/src/IceLocatorDiscovery/PluginI.cpp
+++ b/cpp/src/IceLocatorDiscovery/PluginI.cpp
@@ -5,7 +5,6 @@
 #include "../Ice/Network.h" // For getInterfacesForMulticast
 #include "Ice/Ice.h"
 #include "Ice/LoggerUtil.h"
-
 #include "IceLocatorDiscovery.h"
 #include "Plugin.h"
 
@@ -22,16 +21,16 @@ namespace
     public:
         Request(
             LocatorI* locator,
-            const string& operation,
+            string operation,
             Ice::OperationMode mode,
             pair<const byte*, const byte*> inParams,
-            const Ice::Context& ctx,
+            Ice::Context ctx,
             function<void(bool, pair<const byte*, const byte*>)> responseCallback,
             function<void(exception_ptr)> exceptionCallback)
             : _locator(locator),
-              _operation(operation),
+              _operation(std::move(operation)),
               _mode(mode),
-              _context(ctx),
+              _context(std::move(ctx)),
               _inParams(inParams.first, inParams.second),
               _responseCallback(std::move(responseCallback)),
               _exceptionCallback(std::move(exceptionCallback))
@@ -61,7 +60,7 @@ namespace
                            public std::enable_shared_from_this<LocatorI>
     {
     public:
-        LocatorI(const LookupPrx&, const Ice::PropertiesPtr&, const string&, const Ice::LocatorPrx&);
+        LocatorI(const LookupPrx&, const Ice::PropertiesPtr&, string, Ice::LocatorPrx);
         void setLookupReply(const LookupReplyPrx&);
 
         void ice_invokeAsync(
@@ -108,7 +107,7 @@ namespace
     class LookupReplyI final : public LookupReply
     {
     public:
-        LookupReplyI(const LocatorIPtr& locator) : _locator(locator) {}
+        LookupReplyI(LocatorIPtr locator) : _locator(std::move(locator)) {}
 
         void foundLocator(optional<Ice::LocatorPrx>, const Ice::Current&) final;
 
@@ -146,7 +145,7 @@ namespace
     class PluginI final : public Plugin
     {
     public:
-        PluginI(const Ice::CommunicatorPtr&);
+        PluginI(Ice::CommunicatorPtr);
 
         void initialize() final;
         void destroy() final;
@@ -183,7 +182,7 @@ namespace Ice
     }
 }
 
-PluginI::PluginI(const Ice::CommunicatorPtr& communicator) : _communicator(communicator) {}
+PluginI::PluginI(Ice::CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 PluginI::initialize()
@@ -376,18 +375,18 @@ Request::exception(std::exception_ptr ex)
 LocatorI::LocatorI(
     const LookupPrx& lookup,
     const Ice::PropertiesPtr& p,
-    const string& instanceName,
-    const Ice::LocatorPrx& voidLocator)
+    string instanceName,
+    Ice::LocatorPrx voidLocator)
     : _lookup(lookup),
       _timeout(chrono::milliseconds(p->getIcePropertyAsInt("IceLocatorDiscovery.Timeout"))),
       _retryCount(p->getIcePropertyAsInt("IceLocatorDiscovery.RetryCount")),
       _retryDelay(chrono::milliseconds(p->getIcePropertyAsInt("IceLocatorDiscovery.RetryDelay"))),
       _timer(IceInternal::getInstanceTimer(lookup->ice_getCommunicator())),
       _traceLevel(p->getIcePropertyAsInt("IceLocatorDiscovery.Trace.Lookup")),
-      _instanceName(instanceName),
+      _instanceName(std::move(instanceName)),
       _warned(false),
       _locator(lookup->ice_getCommunicator()->getDefaultLocator()),
-      _voidLocator(voidLocator),
+      _voidLocator(std::move(voidLocator)),
       _pending(false),
       _pendingRetryCount(0),
       _failureCount(0),
diff --git a/cpp/src/IceStorm/Instance.cpp b/cpp/src/IceStorm/Instance.cpp
index 303348cd30e..dc415c97170 100644
--- a/cpp/src/IceStorm/Instance.cpp
+++ b/cpp/src/IceStorm/Instance.cpp
@@ -53,14 +53,14 @@ TopicReaper::consumeReapedTopics()
 }
 
 Instance::Instance(
-    const string& instanceName,
+    string instanceName,
     const string& serviceName,
     shared_ptr<Ice::Communicator> communicator,
     Ice::ObjectAdapterPtr publishAdapter,
     Ice::ObjectAdapterPtr topicAdapter,
     Ice::ObjectAdapterPtr nodeAdapter,
     optional<NodePrx> nodeProxy)
-    : _instanceName(instanceName),
+    : _instanceName(std::move(instanceName)),
       _serviceName(serviceName),
       _communicator(std::move(communicator)),
       _publishAdapter(std::move(publishAdapter)),
diff --git a/cpp/src/IceStorm/Instance.h b/cpp/src/IceStorm/Instance.h
index ba67d42ef1f..c81d2a95ac9 100644
--- a/cpp/src/IceStorm/Instance.h
+++ b/cpp/src/IceStorm/Instance.h
@@ -44,7 +44,7 @@ namespace IceStorm
         };
 
         Instance(
-            const std::string&,
+            std::string,
             const std::string&,
             Ice::CommunicatorPtr,
             Ice::ObjectAdapterPtr,
diff --git a/cpp/src/IceStorm/Parser.cpp b/cpp/src/IceStorm/Parser.cpp
index abd4912a8f5..ed1cf616399 100644
--- a/cpp/src/IceStorm/Parser.cpp
+++ b/cpp/src/IceStorm/Parser.cpp
@@ -4,9 +4,11 @@
 
 #include "Parser.h"
 #include "../Ice/ConsoleUtil.h"
-#include "../Ice/DisableWarnings.h"
 #include "Ice/Ice.h"
 #include "IceStormInternal.h"
+
+#include "../Ice/DisableWarnings.h"
+
 #include <algorithm>
 
 #if defined(__APPLE__) || defined(__linux__)
@@ -40,7 +42,7 @@ namespace
     class UnknownManagerException : public std::exception
     {
     public:
-        explicit UnknownManagerException(const std::string& name) : _name(name) {}
+        explicit UnknownManagerException(std::string name) : _name(std::move(name)) {}
 
         [[nodiscard]] const char* what() const noexcept override { return _name.c_str(); }
 
diff --git a/cpp/src/IceStorm/TopicI.cpp b/cpp/src/IceStorm/TopicI.cpp
index 21bc116c5b5..1100a2783e1 100644
--- a/cpp/src/IceStorm/TopicI.cpp
+++ b/cpp/src/IceStorm/TopicI.cpp
@@ -380,12 +380,12 @@ TopicImpl::create(
 
 TopicImpl::TopicImpl(
     shared_ptr<PersistentInstance> instance,
-    const string& name,
-    const Ice::Identity& id,
+    string name,
+    Ice::Identity id,
     const SubscriberRecordSeq& subscribers)
     : _instance(std::move(instance)),
-      _name(name),
-      _id(id),
+      _name(std::move(name)),
+      _id(std::move(id)),
       _destroyed(false),
       _lluMap(_instance->lluMap()),
       _subscriberMap(_instance->subscriberMap())
diff --git a/cpp/src/IceStorm/TopicI.h b/cpp/src/IceStorm/TopicI.h
index cb527e4b4f1..b78878dc47d 100644
--- a/cpp/src/IceStorm/TopicI.h
+++ b/cpp/src/IceStorm/TopicI.h
@@ -63,11 +63,7 @@ namespace IceStorm
         void updateSubscriberObservers();
 
     private:
-        TopicImpl(
-            std::shared_ptr<PersistentInstance>,
-            const std::string&,
-            const Ice::Identity&,
-            const SubscriberRecordSeq&);
+        TopicImpl(std::shared_ptr<PersistentInstance>, std::string, Ice::Identity, const SubscriberRecordSeq&);
 
         IceStormElection::LogUpdate destroyInternal(const IceStormElection::LogUpdate&, bool);
         void removeSubscribers(const Ice::IdentitySeq&);
diff --git a/cpp/src/IceStorm/TransientTopicI.cpp b/cpp/src/IceStorm/TransientTopicI.cpp
index 38c8bdc096d..d7548ee5c16 100644
--- a/cpp/src/IceStorm/TransientTopicI.cpp
+++ b/cpp/src/IceStorm/TransientTopicI.cpp
@@ -101,10 +101,10 @@ TransientTopicImpl::create(const shared_ptr<Instance>& instance, const std::stri
     return topicImpl;
 }
 
-TransientTopicImpl::TransientTopicImpl(shared_ptr<Instance> instance, const std::string& name, const Ice::Identity& id)
+TransientTopicImpl::TransientTopicImpl(shared_ptr<Instance> instance, std::string name, Ice::Identity id)
     : _instance(std::move(instance)),
-      _name(name),
-      _id(id),
+      _name(std::move(name)),
+      _id(std::move(id)),
       _destroyed(false)
 {
 }
diff --git a/cpp/src/IceStorm/TransientTopicI.h b/cpp/src/IceStorm/TransientTopicI.h
index 0396fa24420..3aab0acc6a6 100644
--- a/cpp/src/IceStorm/TransientTopicI.h
+++ b/cpp/src/IceStorm/TransientTopicI.h
@@ -41,7 +41,7 @@ namespace IceStorm
         void shutdown();
 
     private:
-        TransientTopicImpl(std::shared_ptr<Instance>, const std::string&, const Ice::Identity&);
+        TransientTopicImpl(std::shared_ptr<Instance>, std::string, Ice::Identity);
 
         //
         // Immutable members.
diff --git a/cpp/src/Slice/GrammarUtil.h b/cpp/src/Slice/GrammarUtil.h
index d12f5e53b24..f6f87af16e3 100644
--- a/cpp/src/Slice/GrammarUtil.h
+++ b/cpp/src/Slice/GrammarUtil.h
@@ -33,7 +33,7 @@ namespace Slice
 
     struct TypeStringTok final : public GrammarBase
     {
-        TypeStringTok(TypePtr type, std::string name) : type(type), name(name) {}
+        TypeStringTok(TypePtr type, std::string name) : type(std::move(type)), name(std::move(name)) {}
         TypePtr type;
         std::string name;
     };
@@ -79,7 +79,11 @@ namespace Slice
     struct ConstDefTok final : public GrammarBase
     {
         ConstDefTok() {}
-        ConstDefTok(SyntaxTreeBasePtr value, std::string stringValue) : v(value), valueAsString(stringValue) {}
+        ConstDefTok(SyntaxTreeBasePtr value, std::string stringValue)
+            : v(std::move(value)),
+              valueAsString(std::move(stringValue))
+        {
+        }
 
         SyntaxTreeBasePtr v;
         std::string valueAsString;
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 2840b4d2677..d1ec38da6d2 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -10,6 +10,7 @@
 #include <cstring>
 #include <iterator>
 #include <limits>
+#include <utility>
 
 // TODO: fix this warning once we no longer support VS2013 and earlier
 #if defined(_MSC_VER)
@@ -165,7 +166,7 @@ Slice::Metadata::line() const
 
 Slice::DefinitionContext::DefinitionContext(int includeLevel, MetadataList metadata)
     : _includeLevel(includeLevel),
-      _metadata(metadata),
+      _metadata(std::move(metadata)),
       _seenDefinition(false)
 {
     initSuppressedWarnings();
@@ -367,7 +368,7 @@ Slice::SyntaxTreeBase::visit(ParserVisitor* /*visitor*/)
 {
 }
 
-Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unit) : _unit(unit)
+Slice::SyntaxTreeBase::SyntaxTreeBase(UnitPtr unit) : _unit(std::move(unit))
 {
     if (_unit)
     {
@@ -1045,10 +1046,10 @@ Slice::Contained::getDeprecationReason() const
     return (reasonMessage.empty()) ? nullopt : optional{reasonMessage};
 }
 
-Slice::Contained::Contained(const ContainerPtr& container, const string& name)
+Slice::Contained::Contained(const ContainerPtr& container, string name)
     : SyntaxTreeBase(container->unit()),
       _container(container),
-      _name(name)
+      _name(std::move(name))
 {
     ContainedPtr cont = dynamic_pointer_cast<Contained>(_container);
     if (cont)
@@ -2717,11 +2718,11 @@ Slice::ClassDef::appendMetadata(MetadataList metadata)
     _declaration->appendMetadata(std::move(metadata));
 }
 
-Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int id, const ClassDefPtr& base)
+Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int id, ClassDefPtr base)
     : SyntaxTreeBase(container->unit()),
       Container(container->unit()),
       Contained(container, name),
-      _base(base),
+      _base(std::move(base)),
       _compactId(id)
 {
     if (_compactId >= 0)
@@ -3178,11 +3179,11 @@ Slice::InterfaceDef::appendMetadata(MetadataList metadata)
     _declaration->appendMetadata(std::move(metadata));
 }
 
-Slice::InterfaceDef::InterfaceDef(const ContainerPtr& container, const string& name, const InterfaceList& bases)
+Slice::InterfaceDef::InterfaceDef(const ContainerPtr& container, const string& name, InterfaceList bases)
     : SyntaxTreeBase(container->unit()),
       Container(container->unit()),
       Contained(container, name),
-      _bases(bases)
+      _bases(std::move(bases))
 {
 }
 
@@ -3550,14 +3551,14 @@ Slice::Operation::visit(ParserVisitor* visitor)
 Slice::Operation::Operation(
     const ContainerPtr& container,
     const string& name,
-    const TypePtr& returnType,
+    TypePtr returnType,
     bool returnIsOptional,
     int returnTag,
     Mode mode)
     : SyntaxTreeBase(container->unit()),
       Contained(container, name),
       Container(container->unit()),
-      _returnType(returnType),
+      _returnType(std::move(returnType)),
       _returnIsOptional(returnIsOptional),
       _returnTag(returnTag),
       _mode(mode)
@@ -3813,11 +3814,11 @@ Slice::Exception::visit(ParserVisitor* visitor)
     }
 }
 
-Slice::Exception::Exception(const ContainerPtr& container, const string& name, const ExceptionPtr& base)
+Slice::Exception::Exception(const ContainerPtr& container, const string& name, ExceptionPtr base)
     : SyntaxTreeBase(container->unit()),
       Container(container->unit()),
       Contained(container, name),
-      _base(base)
+      _base(std::move(base))
 {
 }
 
@@ -4046,16 +4047,12 @@ Slice::Sequence::visit(ParserVisitor* visitor)
     visitor->visitSequence(shared_from_this());
 }
 
-Slice::Sequence::Sequence(
-    const ContainerPtr& container,
-    const string& name,
-    const TypePtr& type,
-    MetadataList typeMetadata)
+Slice::Sequence::Sequence(const ContainerPtr& container, const string& name, TypePtr type, MetadataList typeMetadata)
     : SyntaxTreeBase(container->unit()),
       Type(container->unit()),
       Contained(container, name),
       Constructed(container, name),
-      _type(type),
+      _type(std::move(type)),
       _typeMetadata(std::move(typeMetadata))
 {
 }
@@ -4191,16 +4188,16 @@ Slice::Dictionary::isLegalKeyType(const TypePtr& type)
 Slice::Dictionary::Dictionary(
     const ContainerPtr& container,
     const string& name,
-    const TypePtr& keyType,
+    TypePtr keyType,
     MetadataList keyMetadata,
-    const TypePtr& valueType,
+    TypePtr valueType,
     MetadataList valueMetadata)
     : SyntaxTreeBase(container->unit()),
       Type(container->unit()),
       Contained(container, name),
       Constructed(container, name),
-      _keyType(keyType),
-      _valueType(valueType),
+      _keyType(std::move(keyType)),
+      _valueType(std::move(valueType)),
       _keyMetadata(std::move(keyMetadata)),
       _valueMetadata(std::move(valueMetadata))
 {
@@ -4440,16 +4437,16 @@ Slice::Const::visit(ParserVisitor* visitor)
 Slice::Const::Const(
     const ContainerPtr& container,
     const string& name,
-    const TypePtr& type,
+    TypePtr type,
     MetadataList typeMetadata,
-    const SyntaxTreeBasePtr& valueType,
-    const string& valueString)
+    SyntaxTreeBasePtr valueType,
+    string valueString)
     : SyntaxTreeBase(container->unit()),
       Contained(container, name),
-      _type(type),
+      _type(std::move(type)),
       _typeMetadata(std::move(typeMetadata)),
-      _valueType(valueType),
-      _value(valueString)
+      _valueType(std::move(valueType)),
+      _value(std::move(valueString))
 {
 }
 
@@ -4496,13 +4493,13 @@ Slice::Parameter::visit(ParserVisitor* visitor)
 Slice::Parameter::Parameter(
     const ContainerPtr& container,
     const string& name,
-    const TypePtr& type,
+    TypePtr type,
     bool isOutParam,
     bool isOptional,
     int tag)
     : SyntaxTreeBase(container->unit()),
       Contained(container, name),
-      _type(type),
+      _type(std::move(type)),
       _isOutParam(isOutParam),
       _optional(isOptional),
       _tag(tag)
@@ -4558,18 +4555,18 @@ Slice::DataMember::visit(ParserVisitor* visitor)
 Slice::DataMember::DataMember(
     const ContainerPtr& container,
     const string& name,
-    const TypePtr& type,
+    TypePtr type,
     bool isOptional,
     int tag,
-    const SyntaxTreeBasePtr& defaultValueType,
-    const string& defaultValueString)
+    SyntaxTreeBasePtr defaultValueType,
+    string defaultValueString)
     : SyntaxTreeBase(container->unit()),
       Contained(container, name),
-      _type(type),
+      _type(std::move(type)),
       _optional(isOptional),
       _tag(tag),
-      _defaultValueType(defaultValueType),
-      _defaultValue(defaultValueString)
+      _defaultValueType(std::move(defaultValueType)),
+      _defaultValue(std::move(defaultValueString))
 {
 }
 
diff --git a/cpp/src/Slice/Parser.h b/cpp/src/Slice/Parser.h
index dbd6b8cbb27..6fe2478eda7 100644
--- a/cpp/src/Slice/Parser.h
+++ b/cpp/src/Slice/Parser.h
@@ -285,7 +285,7 @@ namespace Slice
     class SyntaxTreeBase : public GrammarBase
     {
     public:
-        SyntaxTreeBase(const UnitPtr& unit);
+        SyntaxTreeBase(UnitPtr unit);
         virtual void destroy();
         [[nodiscard]] UnitPtr unit() const;
         [[nodiscard]] DefinitionContextPtr definitionContext() const; // May be nil
@@ -397,7 +397,7 @@ namespace Slice
         [[nodiscard]] virtual std::string kindOf() const = 0;
 
     protected:
-        Contained(const ContainerPtr& container, const std::string& name);
+        Contained(const ContainerPtr& container, std::string name);
 
         ContainerPtr _container;
         std::string _name;
@@ -553,7 +553,7 @@ namespace Slice
     class ClassDef final : public virtual Container, public virtual Contained
     {
     public:
-        ClassDef(const ContainerPtr& container, const std::string& name, int id, const ClassDefPtr& base);
+        ClassDef(const ContainerPtr& container, const std::string& name, int id, ClassDefPtr base);
         void destroy() final;
         DataMemberPtr createDataMember(
             const std::string& name,
@@ -645,7 +645,7 @@ namespace Slice
             Idempotent = 2
         };
 
-        Operation(const ContainerPtr&, const std::string&, const TypePtr&, bool, int, Mode);
+        Operation(const ContainerPtr&, const std::string&, TypePtr, bool, int, Mode);
         [[nodiscard]] InterfaceDefPtr interface() const;
         [[nodiscard]] TypePtr returnType() const;
         [[nodiscard]] bool returnIsOptional() const;
@@ -694,7 +694,7 @@ namespace Slice
     class InterfaceDef final : public virtual Container, public virtual Contained
     {
     public:
-        InterfaceDef(const ContainerPtr& container, const std::string& name, const InterfaceList& bases);
+        InterfaceDef(const ContainerPtr& container, const std::string& name, InterfaceList bases);
         void destroy() final;
         OperationPtr createOperation(
             const std::string& name,
@@ -738,7 +738,7 @@ namespace Slice
     class Exception final : public virtual Container, public virtual Contained
     {
     public:
-        Exception(const ContainerPtr& container, const std::string& name, const ExceptionPtr& base);
+        Exception(const ContainerPtr& container, const std::string& name, ExceptionPtr base);
         void destroy() final;
         DataMemberPtr createDataMember(
             const std::string& name,
@@ -795,11 +795,7 @@ namespace Slice
     class Sequence final : public virtual Constructed, public std::enable_shared_from_this<Sequence>
     {
     public:
-        Sequence(
-            const ContainerPtr& container,
-            const std::string& name,
-            const TypePtr& type,
-            MetadataList typeMetadata);
+        Sequence(const ContainerPtr& container, const std::string& name, TypePtr type, MetadataList typeMetadata);
         [[nodiscard]] TypePtr type() const;
         [[nodiscard]] MetadataList typeMetadata() const;
         void setTypeMetadata(MetadataList metadata);
@@ -825,9 +821,9 @@ namespace Slice
         Dictionary(
             const ContainerPtr& container,
             const std::string& name,
-            const TypePtr& keyType,
+            TypePtr keyType,
             MetadataList keyMetadata,
-            const TypePtr& valueType,
+            TypePtr valueType,
             MetadataList valueMetadata);
         [[nodiscard]] TypePtr keyType() const;
         [[nodiscard]] TypePtr valueType() const;
@@ -906,10 +902,10 @@ namespace Slice
         Const(
             const ContainerPtr& container,
             const std::string& name,
-            const TypePtr& type,
+            TypePtr type,
             MetadataList typeMetadata,
-            const SyntaxTreeBasePtr& valueType,
-            const std::string& valueString);
+            SyntaxTreeBasePtr valueType,
+            std::string valueString);
         [[nodiscard]] TypePtr type() const;
         [[nodiscard]] MetadataList typeMetadata() const;
         void setTypeMetadata(MetadataList metadata);
@@ -935,7 +931,7 @@ namespace Slice
         Parameter(
             const ContainerPtr& container,
             const std::string& name,
-            const TypePtr& type,
+            TypePtr type,
             bool isOutParam,
             bool isOptional,
             int tag);
@@ -963,11 +959,11 @@ namespace Slice
         DataMember(
             const ContainerPtr& container,
             const std::string& name,
-            const TypePtr& type,
+            TypePtr type,
             bool isOptional,
             int tag,
-            const SyntaxTreeBasePtr& defaultValueType,
-            const std::string& defaultValueString);
+            SyntaxTreeBasePtr defaultValueType,
+            std::string defaultValueString);
         [[nodiscard]] TypePtr type() const;
         [[nodiscard]] bool optional() const;
         [[nodiscard]] int tag() const;
diff --git a/cpp/src/Slice/Preprocessor.cpp b/cpp/src/Slice/Preprocessor.cpp
index 5f862929315..5d1bdcc8719 100644
--- a/cpp/src/Slice/Preprocessor.cpp
+++ b/cpp/src/Slice/Preprocessor.cpp
@@ -48,8 +48,8 @@ Slice::Preprocessor::create(const string& path, const string& fileName, const ve
     return make_shared<Preprocessor>(path, fileName, args);
 }
 
-Slice::Preprocessor::Preprocessor(const string& path, const string& fileName, const vector<string>& args)
-    : _path(path),
+Slice::Preprocessor::Preprocessor(string path, const string& fileName, const vector<string>& args)
+    : _path(std::move(path)),
       _fileName(fullPath(fileName)),
       _shortFileName(fileName),
       _args(args),
diff --git a/cpp/src/Slice/Preprocessor.h b/cpp/src/Slice/Preprocessor.h
index b22c7f58f69..3024eec5008 100644
--- a/cpp/src/Slice/Preprocessor.h
+++ b/cpp/src/Slice/Preprocessor.h
@@ -18,7 +18,7 @@ namespace Slice
         static PreprocessorPtr
         create(const std::string& path, const std::string& fileName, const std::vector<std::string>& args);
 
-        Preprocessor(const std::string& path, const std::string& fileName, const std::vector<std::string>& args);
+        Preprocessor(std::string path, const std::string& fileName, const std::vector<std::string>& args);
         ~Preprocessor();
 
         FILE* preprocess(bool keepComments, const std::string& languageArg = "");
diff --git a/cpp/src/Slice/StringLiteralUtil.cpp b/cpp/src/Slice/StringLiteralUtil.cpp
index b2527f8aae2..820e77cacf2 100644
--- a/cpp/src/Slice/StringLiteralUtil.cpp
+++ b/cpp/src/Slice/StringLiteralUtil.cpp
@@ -18,7 +18,7 @@ namespace
     class StringLiteralGenerator final
     {
     public:
-        StringLiteralGenerator(const string&, const string&, EscapeMode, unsigned char);
+        StringLiteralGenerator(string, const string&, EscapeMode, unsigned char);
 
         string escapeASCIIChar(char);
         string escapeCodePoint(unsigned int);
@@ -45,11 +45,11 @@ namespace
     };
 
     StringLiteralGenerator::StringLiteralGenerator(
-        const string& nonPrintableEscaped,
+        string nonPrintableEscaped,
         const string& printableEscaped,
         EscapeMode escapeMode,
         unsigned char cutOff)
-        : _nonPrintableEscaped(nonPrintableEscaped),
+        : _nonPrintableEscaped(std::move(nonPrintableEscaped)),
           _printableEscaped(printableEscaped + "\\"),
           _escapeMode(escapeMode),
           _cutOff(cutOff),
diff --git a/cpp/src/ice2slice/Gen.cpp b/cpp/src/ice2slice/Gen.cpp
index 98608b7e950..b85e7fd4198 100644
--- a/cpp/src/ice2slice/Gen.cpp
+++ b/cpp/src/ice2slice/Gen.cpp
@@ -402,7 +402,7 @@ namespace
     }
 }
 
-Gen::Gen(const std::string& fileBase) : _fileBase(fileBase) {}
+Gen::Gen(std::string fileBase) : _fileBase(std::move(fileBase)) {}
 
 void
 Gen::generate(const UnitPtr& p)
@@ -466,8 +466,8 @@ Gen::OutputModulesVisitor::modules() const
     return _modules;
 }
 
-Gen::TypesVisitor::TypesVisitor(const std::string& fileBase, const std::set<std::string>& modules)
-    : _fileBase(fileBase),
+Gen::TypesVisitor::TypesVisitor(std::string fileBase, const std::set<std::string>& modules)
+    : _fileBase(std::move(fileBase)),
       _modules(modules)
 {
 }
diff --git a/cpp/src/ice2slice/Gen.h b/cpp/src/ice2slice/Gen.h
index ef85c0dfb43..83262d09267 100644
--- a/cpp/src/ice2slice/Gen.h
+++ b/cpp/src/ice2slice/Gen.h
@@ -15,7 +15,7 @@ namespace Slice
     class Gen
     {
     public:
-        Gen(const std::string&);
+        Gen(std::string);
 
         void generate(const UnitPtr&);
 
@@ -57,7 +57,7 @@ namespace Slice
         class TypesVisitor final : public ParserVisitor
         {
         public:
-            TypesVisitor(const std::string& fileBase, const std::set<std::string>& modules);
+            TypesVisitor(std::string fileBase, const std::set<std::string>& modules);
 
             void visitUnitEnd(const UnitPtr&) final;
             bool visitClassDefStart(const ClassDefPtr&) final;
diff --git a/cpp/src/icegriddb/IceGridDB.cpp b/cpp/src/icegriddb/IceGridDB.cpp
index 0b88630ce74..5febca632c0 100644
--- a/cpp/src/icegriddb/IceGridDB.cpp
+++ b/cpp/src/icegriddb/IceGridDB.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "../Ice/ConsoleUtil.h"
-#include "../Ice/DisableWarnings.h"
 #include "../Ice/FileUtil.h"
 #include "../Ice/Options.h"
 #include "../IceDB/IceDB.h"
@@ -12,6 +11,8 @@
 #include "Ice/StringUtil.h"
 #include "IceGrid/Admin.h"
 
+#include "../Ice/DisableWarnings.h"
+
 #include <fstream>
 #include <iterator>
 
@@ -23,7 +24,7 @@ namespace
     class ServerDescriptorI : public IceGrid::ServerDescriptor
     {
     public:
-        ServerDescriptorI(const string& serverVersion) : _serverVersion(serverVersion) {}
+        ServerDescriptorI(string serverVersion) : _serverVersion(std::move(serverVersion)) {}
 
     protected:
         void ice_postUnmarshal() override { iceVersion = _serverVersion; }
@@ -35,7 +36,7 @@ namespace
     class IceBoxDescriptorI : public IceGrid::IceBoxDescriptor
     {
     public:
-        IceBoxDescriptorI(const string& serverVersion) : _serverVersion(serverVersion) {}
+        IceBoxDescriptorI(string serverVersion) : _serverVersion(std::move(serverVersion)) {}
 
     protected:
         void ice_postUnmarshal() override { iceVersion = _serverVersion; }
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index a188943a20e..053fbca7b6d 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -587,22 +587,22 @@ namespace
 }
 
 Slice::Gen::Gen(
-    const string& base,
-    const string& headerExtension,
-    const string& sourceExtension,
+    string base,
+    string headerExtension,
+    string sourceExtension,
     const vector<string>& extraHeaders,
-    const string& include,
+    string include,
     const vector<string>& includePaths,
-    const string& dllExport,
-    const string& dir)
-    : _base(base),
-      _headerExtension(headerExtension),
-      _sourceExtension(sourceExtension),
+    string dllExport,
+    string dir)
+    : _base(std::move(base)),
+      _headerExtension(std::move(headerExtension)),
+      _sourceExtension(std::move(sourceExtension)),
       _extraHeaders(extraHeaders),
-      _include(include),
+      _include(std::move(include)),
       _includePaths(includePaths),
-      _dllExport(dllExport),
-      _dir(dir)
+      _dllExport(std::move(dllExport)),
+      _dir(std::move(dir))
 {
     for (vector<string>::iterator p = _includePaths.begin(); p != _includePaths.end(); ++p)
     {
@@ -1264,10 +1264,10 @@ Slice::Gen::DefaultFactoryVisitor::visitExceptionStart(const ExceptionPtr& p)
     return false;
 }
 
-Slice::Gen::ProxyVisitor::ProxyVisitor(Output& h, Output& c, const string& dllExport)
+Slice::Gen::ProxyVisitor::ProxyVisitor(Output& h, Output& c, string dllExport)
     : H(h),
       C(c),
-      _dllExport(dllExport),
+      _dllExport(std::move(dllExport)),
       _useWstring(TypeContext::None)
 {
 }
@@ -2473,13 +2473,10 @@ Slice::Gen::DataDefVisitor::emitDataMember(const DataMemberPtr& p)
     H << ";";
 }
 
-Slice::Gen::InterfaceVisitor::InterfaceVisitor(
-    ::IceInternal::Output& h,
-    ::IceInternal::Output& c,
-    const string& dllExport)
+Slice::Gen::InterfaceVisitor::InterfaceVisitor(::IceInternal::Output& h, ::IceInternal::Output& c, string dllExport)
     : H(h),
       C(c),
-      _dllExport(dllExport),
+      _dllExport(std::move(dllExport)),
       _useWstring(TypeContext::None)
 {
 }
diff --git a/cpp/src/slice2cpp/Gen.h b/cpp/src/slice2cpp/Gen.h
index d8fb8a27568..f2b5e801920 100644
--- a/cpp/src/slice2cpp/Gen.h
+++ b/cpp/src/slice2cpp/Gen.h
@@ -14,14 +14,14 @@ namespace Slice
     class Gen final
     {
     public:
-        Gen(const std::string&,
-            const std::string&,
-            const std::string&,
+        Gen(std::string,
+            std::string,
+            std::string,
             const std::vector<std::string>&,
-            const std::string&,
+            std::string,
             const std::vector<std::string>&,
-            const std::string&,
-            const std::string&);
+            std::string,
+            std::string);
         ~Gen();
 
         Gen(const Gen&) = delete;
@@ -105,7 +105,7 @@ namespace Slice
         class ProxyVisitor final : public ParserVisitor
         {
         public:
-            ProxyVisitor(::IceInternal::Output&, ::IceInternal::Output&, const std::string&);
+            ProxyVisitor(::IceInternal::Output&, ::IceInternal::Output&, std::string);
             ProxyVisitor(const ProxyVisitor&) = delete;
 
             bool visitModuleStart(const ModulePtr&) final;
@@ -164,7 +164,7 @@ namespace Slice
         class InterfaceVisitor final : public ParserVisitor
         {
         public:
-            InterfaceVisitor(::IceInternal::Output&, ::IceInternal::Output&, const std::string&);
+            InterfaceVisitor(::IceInternal::Output&, ::IceInternal::Output&, std::string);
             InterfaceVisitor(const InterfaceVisitor&) = delete;
 
             bool visitModuleStart(const ModulePtr&) final;
diff --git a/cpp/src/slice2cpp/Main.cpp b/cpp/src/slice2cpp/Main.cpp
index c690b34bd98..c523d577886 100644
--- a/cpp/src/slice2cpp/Main.cpp
+++ b/cpp/src/slice2cpp/Main.cpp
@@ -4,12 +4,11 @@
 
 #include "../Ice/ConsoleUtil.h"
 #include "../Ice/Options.h"
-#include "Ice/CtrlCHandler.h"
-
 #include "../Slice/FileTracker.h"
 #include "../Slice/Preprocessor.h"
 #include "../Slice/Util.h"
 #include "Gen.h"
+#include "Ice/CtrlCHandler.h"
 
 #include <algorithm>
 #include <cassert>
diff --git a/cpp/src/slice2java/Gen.cpp b/cpp/src/slice2java/Gen.cpp
index 188faec8043..123daba24f3 100644
--- a/cpp/src/slice2java/Gen.cpp
+++ b/cpp/src/slice2java/Gen.cpp
@@ -2217,10 +2217,10 @@ Slice::JavaVisitor::writeSeeAlso(Output& out, const UnitPtr& unt, const string&
     }
 }
 
-Slice::Gen::Gen(const string& /*name*/, const string& base, const vector<string>& includePaths, const string& dir)
-    : _base(base),
+Slice::Gen::Gen(const string& /*name*/, string base, const vector<string>& includePaths, string dir)
+    : _base(std::move(base)),
       _includePaths(includePaths),
-      _dir(dir)
+      _dir(std::move(dir))
 {
 }
 
diff --git a/cpp/src/slice2java/Gen.h b/cpp/src/slice2java/Gen.h
index 13268dd22a5..41e368ec74b 100644
--- a/cpp/src/slice2java/Gen.h
+++ b/cpp/src/slice2java/Gen.h
@@ -118,7 +118,7 @@ namespace Slice
     class Gen final
     {
     public:
-        Gen(const std::string&, const std::string&, const std::vector<std::string>&, const std::string&);
+        Gen(const std::string&, std::string, const std::vector<std::string>&, std::string);
         Gen(const Gen&) = delete;
         ~Gen();
 
diff --git a/cpp/src/slice2java/JavaUtil.cpp b/cpp/src/slice2java/JavaUtil.cpp
index ea02dd5f346..d24827f8f91 100644
--- a/cpp/src/slice2java/JavaUtil.cpp
+++ b/cpp/src/slice2java/JavaUtil.cpp
@@ -301,7 +301,7 @@ Slice::JavaOutput::printHeader()
     print("//\n");
 }
 
-Slice::JavaGenerator::JavaGenerator(const string& dir) : _dir(dir), _out(nullptr) {}
+Slice::JavaGenerator::JavaGenerator(string dir) : _dir(std::move(dir)), _out(nullptr) {}
 
 Slice::JavaGenerator::~JavaGenerator()
 {
diff --git a/cpp/src/slice2java/JavaUtil.h b/cpp/src/slice2java/JavaUtil.h
index 5eec8a204fc..17f37b05acb 100644
--- a/cpp/src/slice2java/JavaUtil.h
+++ b/cpp/src/slice2java/JavaUtil.h
@@ -79,7 +79,7 @@ namespace Slice
         // If a match is found, return the symbol with a leading underscore.
         static std::string fixKwd(const std::string&);
 
-        JavaGenerator(const std::string&);
+        JavaGenerator(std::string);
 
         //
         // Given the fully-scoped Java class name, create any intermediate
diff --git a/cpp/src/slice2js/Gen.cpp b/cpp/src/slice2js/Gen.cpp
index 5591fb828d2..8c151e52490 100644
--- a/cpp/src/slice2js/Gen.cpp
+++ b/cpp/src/slice2js/Gen.cpp
@@ -679,7 +679,7 @@ Slice::Gen::ImportVisitor::ImportVisitor(IceInternal::Output& out, vector<string
       _seenObjectSeq(false),
       _seenObjectDict(false),
       _seenObjectProxyDict(false),
-      _includePaths(includePaths)
+      _includePaths(std::move(includePaths))
 {
     for (vector<string>::iterator p = _includePaths.begin(); p != _includePaths.end(); ++p)
     {
@@ -1035,7 +1035,7 @@ Slice::Gen::ImportVisitor::writeImports(const UnitPtr& p)
 
 Slice::Gen::ExportsVisitor::ExportsVisitor(::IceInternal::Output& out, std::set<std::string> importedModules)
     : JsVisitor(out),
-      _importedModules(importedModules)
+      _importedModules(std::move(importedModules))
 {
 }
 
diff --git a/cpp/src/slice2matlab/Main.cpp b/cpp/src/slice2matlab/Main.cpp
index c624001a112..5ddee9943ba 100644
--- a/cpp/src/slice2matlab/Main.cpp
+++ b/cpp/src/slice2matlab/Main.cpp
@@ -1292,7 +1292,7 @@ namespace
 class CodeVisitor final : public ParserVisitor
 {
 public:
-    CodeVisitor(const string&);
+    CodeVisitor(string);
 
     bool visitClassDefStart(const ClassDefPtr&) final;
     bool visitInterfaceDefStart(const InterfaceDefPtr&) final;
@@ -1353,7 +1353,7 @@ class CodeVisitor final : public ParserVisitor
 //
 // CodeVisitor implementation.
 //
-CodeVisitor::CodeVisitor(const string& dir) : _dir(dir) {}
+CodeVisitor::CodeVisitor(string dir) : _dir(std::move(dir)) {}
 
 bool
 CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
diff --git a/cpp/src/slice2swift/SwiftUtil.cpp b/cpp/src/slice2swift/SwiftUtil.cpp
index 2b7b14ca2e8..a6c8c3f2fbd 100644
--- a/cpp/src/slice2swift/SwiftUtil.cpp
+++ b/cpp/src/slice2swift/SwiftUtil.cpp
@@ -3,12 +3,10 @@
 //
 //
 
+#include "SwiftUtil.h"
 #include "../Ice/OutputUtil.h"
-#include "Ice/StringUtil.h"
-
 #include "../Slice/Util.h"
-
-#include "SwiftUtil.h"
+#include "Ice/StringUtil.h"
 
 #include <cassert>
 
diff --git a/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h b/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h
index 47f4b1fe12f..dab4658c6f4 100644
--- a/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h
+++ b/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h
@@ -38,7 +38,7 @@ struct TestCase
     std::string proxy;
     bool expectedResult;
 
-    TestCase(const std::string& s, const bool b) : proxy(s), expectedResult(b) {}
+    TestCase(std::string s, const bool b) : proxy(std::move(s)), expectedResult(b) {}
 };
 
 struct TestConfiguration
diff --git a/cpp/test/Glacier2/staticFiltering/Server.cpp b/cpp/test/Glacier2/staticFiltering/Server.cpp
index efb09d2d4db..415cea9851d 100644
--- a/cpp/test/Glacier2/staticFiltering/Server.cpp
+++ b/cpp/test/Glacier2/staticFiltering/Server.cpp
@@ -53,9 +53,9 @@ class ServerLocatorRegistry final : public LocatorRegistry
 class ServerLocatorI final : public Locator
 {
 public:
-    ServerLocatorI(shared_ptr<Backend> backend, const ObjectAdapterPtr& adapter)
+    ServerLocatorI(shared_ptr<Backend> backend, ObjectAdapterPtr adapter)
         : _backend(std::move(backend)),
-          _adapter(adapter),
+          _adapter(std::move(adapter)),
           _registryPrx(_adapter->add<LocatorRegistryPrx>(
               make_shared<ServerLocatorRegistry>(),
               Ice::stringToIdentity("registry")))
diff --git a/cpp/test/Ice/admin/TestI.cpp b/cpp/test/Ice/admin/TestI.cpp
index a7486c718f7..b03135d74be 100644
--- a/cpp/test/Ice/admin/TestI.cpp
+++ b/cpp/test/Ice/admin/TestI.cpp
@@ -32,8 +32,8 @@ namespace
     };
 }
 
-RemoteCommunicatorI::RemoteCommunicatorI(const CommunicatorPtr& communicator)
-    : _communicator(communicator),
+RemoteCommunicatorI::RemoteCommunicatorI(CommunicatorPtr communicator)
+    : _communicator(std::move(communicator)),
       _removeCallback(nullptr)
 {
 }
diff --git a/cpp/test/Ice/admin/TestI.h b/cpp/test/Ice/admin/TestI.h
index 2f9496efd17..1dcabd17318 100644
--- a/cpp/test/Ice/admin/TestI.h
+++ b/cpp/test/Ice/admin/TestI.h
@@ -12,7 +12,7 @@
 class RemoteCommunicatorI final : public Test::RemoteCommunicator
 {
 public:
-    RemoteCommunicatorI(const Ice::CommunicatorPtr&);
+    RemoteCommunicatorI(Ice::CommunicatorPtr);
 
     std::optional<Ice::ObjectPrx> getAdmin(const Ice::Current&) final;
     Ice::PropertyDict getChanges(const Ice::Current&) final;
diff --git a/cpp/test/Ice/ami/TestI.cpp b/cpp/test/Ice/ami/TestI.cpp
index 330edc2789a..2117ad3859c 100644
--- a/cpp/test/Ice/ami/TestI.cpp
+++ b/cpp/test/Ice/ami/TestI.cpp
@@ -239,7 +239,7 @@ TestIntfControllerI::resumeAdapter(const Ice::Current&)
     _adapter->activate();
 }
 
-TestIntfControllerI::TestIntfControllerI(const Ice::ObjectAdapterPtr& adapter) : _adapter(adapter) {}
+TestIntfControllerI::TestIntfControllerI(Ice::ObjectAdapterPtr adapter) : _adapter(std::move(adapter)) {}
 
 int32_t
 TestIntfII::op(int32_t i, int32_t& j, const Ice::Current&)
diff --git a/cpp/test/Ice/ami/TestI.h b/cpp/test/Ice/ami/TestI.h
index adbcd73e4a7..aea6f9cd85c 100644
--- a/cpp/test/Ice/ami/TestI.h
+++ b/cpp/test/Ice/ami/TestI.h
@@ -67,7 +67,7 @@ class TestIntfControllerI : public Test::TestIntfController
     void holdAdapter(const Ice::Current&) final;
     void resumeAdapter(const Ice::Current&) final;
 
-    TestIntfControllerI(const Ice::ObjectAdapterPtr&);
+    TestIntfControllerI(Ice::ObjectAdapterPtr);
 
 private:
     Ice::ObjectAdapterPtr _adapter;
diff --git a/cpp/test/Ice/background/Acceptor.cpp b/cpp/test/Ice/background/Acceptor.cpp
index 22f7e5b1f39..8c200e2191e 100644
--- a/cpp/test/Ice/background/Acceptor.cpp
+++ b/cpp/test/Ice/background/Acceptor.cpp
@@ -69,8 +69,8 @@ Acceptor::toDetailedString() const
     return _acceptor->toDetailedString();
 }
 
-Acceptor::Acceptor(const EndpointIPtr& endpoint, const IceInternal::AcceptorPtr& acceptor)
-    : _endpoint(endpoint),
-      _acceptor(acceptor)
+Acceptor::Acceptor(EndpointIPtr endpoint, IceInternal::AcceptorPtr acceptor)
+    : _endpoint(std::move(endpoint)),
+      _acceptor(std::move(acceptor))
 {
 }
diff --git a/cpp/test/Ice/background/Acceptor.h b/cpp/test/Ice/background/Acceptor.h
index 487c780670c..ad9e18302dd 100644
--- a/cpp/test/Ice/background/Acceptor.h
+++ b/cpp/test/Ice/background/Acceptor.h
@@ -11,7 +11,7 @@
 class Acceptor : public IceInternal::Acceptor
 {
 public:
-    Acceptor(const EndpointIPtr&, const IceInternal::AcceptorPtr&);
+    Acceptor(EndpointIPtr, IceInternal::AcceptorPtr);
     IceInternal::NativeInfoPtr getNativeInfo() override;
 
     void close() override;
diff --git a/cpp/test/Ice/background/Connector.cpp b/cpp/test/Ice/background/Connector.cpp
index 97181cdbee9..1a9c177c142 100644
--- a/cpp/test/Ice/background/Connector.cpp
+++ b/cpp/test/Ice/background/Connector.cpp
@@ -55,8 +55,8 @@ Connector::operator<(const IceInternal::Connector& r) const
     return *_connector < *p->_connector;
 }
 
-Connector::Connector(const IceInternal::ConnectorPtr& connector)
-    : _connector(connector),
+Connector::Connector(IceInternal::ConnectorPtr connector)
+    : _connector(std::move(connector)),
       _configuration(Configuration::getInstance())
 {
 }
diff --git a/cpp/test/Ice/background/Connector.h b/cpp/test/Ice/background/Connector.h
index ffe4217d496..926827706a0 100644
--- a/cpp/test/Ice/background/Connector.h
+++ b/cpp/test/Ice/background/Connector.h
@@ -19,7 +19,7 @@ class Connector : public IceInternal::Connector
     bool operator==(const IceInternal::Connector&) const override;
     bool operator<(const IceInternal::Connector&) const override;
 
-    Connector(const IceInternal::ConnectorPtr& connector);
+    Connector(IceInternal::ConnectorPtr connector);
 
 private:
     const IceInternal::ConnectorPtr _connector;
diff --git a/cpp/test/Ice/background/EndpointFactory.cpp b/cpp/test/Ice/background/EndpointFactory.cpp
index 0312fff43bf..0f3b15946b7 100644
--- a/cpp/test/Ice/background/EndpointFactory.cpp
+++ b/cpp/test/Ice/background/EndpointFactory.cpp
@@ -6,14 +6,13 @@
 #    define TEST_API_EXPORTS
 #endif
 
-#include "Ice/EndpointFactoryManager.h"
-
 #include "EndpointFactory.h"
 #include "EndpointI.h"
+#include "Ice/EndpointFactoryManager.h"
 
 using namespace std;
 
-EndpointFactory::EndpointFactory(const IceInternal::EndpointFactoryPtr& factory) : _factory(factory) {}
+EndpointFactory::EndpointFactory(IceInternal::EndpointFactoryPtr factory) : _factory(std::move(factory)) {}
 
 int16_t
 EndpointFactory::type() const
diff --git a/cpp/test/Ice/background/EndpointFactory.h b/cpp/test/Ice/background/EndpointFactory.h
index c063bfd5158..76679a325b2 100644
--- a/cpp/test/Ice/background/EndpointFactory.h
+++ b/cpp/test/Ice/background/EndpointFactory.h
@@ -10,7 +10,7 @@
 class EndpointFactory final : public IceInternal::EndpointFactory, public std::enable_shared_from_this<EndpointFactory>
 {
 public:
-    EndpointFactory(const IceInternal::EndpointFactoryPtr&);
+    EndpointFactory(IceInternal::EndpointFactoryPtr);
 
     [[nodiscard]] std::int16_t type() const final;
     [[nodiscard]] std::string protocol() const final;
diff --git a/cpp/test/Ice/background/EndpointI.cpp b/cpp/test/Ice/background/EndpointI.cpp
index 0b41fb7f02e..521c21973a4 100644
--- a/cpp/test/Ice/background/EndpointI.cpp
+++ b/cpp/test/Ice/background/EndpointI.cpp
@@ -7,6 +7,7 @@
 #endif
 
 #include "EndpointI.h"
+
 #include "Acceptor.h"
 #include "Connector.h"
 #include "Transceiver.h"
@@ -24,8 +25,8 @@ using namespace std;
 
 int16_t EndpointI::TYPE_BASE = 100;
 
-EndpointI::EndpointI(const IceInternal::EndpointIPtr& endpoint)
-    : _endpoint(endpoint),
+EndpointI::EndpointI(IceInternal::EndpointIPtr endpoint)
+    : _endpoint(std::move(endpoint)),
       _configuration(Configuration::getInstance())
 {
 }
diff --git a/cpp/test/Ice/background/EndpointI.h b/cpp/test/Ice/background/EndpointI.h
index d26e4868878..f75f0e262c0 100644
--- a/cpp/test/Ice/background/EndpointI.h
+++ b/cpp/test/Ice/background/EndpointI.h
@@ -18,7 +18,7 @@ class EndpointI final : public IceInternal::EndpointI, public std::enable_shared
 public:
     static std::int16_t TYPE_BASE;
 
-    EndpointI(const IceInternal::EndpointIPtr&);
+    EndpointI(IceInternal::EndpointIPtr);
 
     // From EndpointI
     void streamWriteImpl(Ice::OutputStream*) const final;
diff --git a/cpp/test/Ice/background/PluginI.cpp b/cpp/test/Ice/background/PluginI.cpp
index 16ec2a33f75..b3c1aa3a5e0 100644
--- a/cpp/test/Ice/background/PluginI.cpp
+++ b/cpp/test/Ice/background/PluginI.cpp
@@ -6,19 +6,18 @@
 #    define TEST_API_EXPORTS
 #endif
 
+#include "PluginI.h"
+#include "EndpointFactory.h"
 #include "Ice/EndpointFactoryManager.h"
 #include "Ice/Initialize.h"
 #include "Ice/ProtocolPluginFacade.h"
 
-#include "EndpointFactory.h"
-#include "PluginI.h"
-
 using namespace std;
 
 class TestPluginI final : public PluginI
 {
 public:
-    TestPluginI(const Ice::CommunicatorPtr&);
+    TestPluginI(Ice::CommunicatorPtr);
 
     void initialize() final;
     void destroy() final;
@@ -41,8 +40,8 @@ extern "C"
     }
 }
 
-TestPluginI::TestPluginI(const Ice::CommunicatorPtr& communicator)
-    : _communicator(communicator),
+TestPluginI::TestPluginI(Ice::CommunicatorPtr communicator)
+    : _communicator(std::move(communicator)),
       _configuration(make_shared<Configuration>())
 {
     _configuration->init();
diff --git a/cpp/test/Ice/background/Server.cpp b/cpp/test/Ice/background/Server.cpp
index 8cbf7bf8813..bb4c88f7e6d 100644
--- a/cpp/test/Ice/background/Server.cpp
+++ b/cpp/test/Ice/background/Server.cpp
@@ -51,7 +51,7 @@ class LocatorI final : public Locator
 
     [[nodiscard]] optional<LocatorRegistryPrx> getRegistry(const Current&) const override { return nullopt; }
 
-    LocatorI(const BackgroundControllerIPtr& controller) : _controller(controller) {}
+    LocatorI(BackgroundControllerIPtr controller) : _controller(std::move(controller)) {}
 
 private:
     BackgroundControllerIPtr _controller;
diff --git a/cpp/test/Ice/background/TestI.cpp b/cpp/test/Ice/background/TestI.cpp
index 2a0ae3d8731..89c81c4c410 100644
--- a/cpp/test/Ice/background/TestI.cpp
+++ b/cpp/test/Ice/background/TestI.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "TestI.h"
-#include "Ice/Ice.h"
 
 using namespace std;
 using namespace Ice;
@@ -26,7 +25,7 @@ BackgroundI::shutdown(const Current& current)
     current.adapter->getCommunicator()->shutdown();
 }
 
-BackgroundI::BackgroundI(const BackgroundControllerIPtr& controller) : _controller(controller) {}
+BackgroundI::BackgroundI(BackgroundControllerIPtr controller) : _controller(std::move(controller)) {}
 
 void
 BackgroundControllerI::pauseCall(string opName, const Current&)
@@ -107,8 +106,8 @@ BackgroundControllerI::buffered(bool enable, const Current&)
     _configuration->buffered(enable);
 }
 
-BackgroundControllerI::BackgroundControllerI(const ObjectAdapterPtr& adapter, const ConfigurationPtr& configuration)
-    : _adapter(adapter),
-      _configuration(configuration)
+BackgroundControllerI::BackgroundControllerI(ObjectAdapterPtr adapter, ConfigurationPtr configuration)
+    : _adapter(std::move(adapter)),
+      _configuration(std::move(configuration))
 {
 }
diff --git a/cpp/test/Ice/background/TestI.h b/cpp/test/Ice/background/TestI.h
index a78e0c1c5de..2251e3b6050 100644
--- a/cpp/test/Ice/background/TestI.h
+++ b/cpp/test/Ice/background/TestI.h
@@ -16,7 +16,7 @@ using BackgroundControllerIPtr = std::shared_ptr<BackgroundControllerI>;
 class BackgroundI final : public Test::Background
 {
 public:
-    BackgroundI(const BackgroundControllerIPtr&);
+    BackgroundI(BackgroundControllerIPtr);
 
     void op(const Ice::Current&) final;
     void opWithPayload(Ice::ByteSeq, const Ice::Current&) final;
@@ -29,7 +29,7 @@ class BackgroundI final : public Test::Background
 class BackgroundControllerI final : public Test::BackgroundController
 {
 public:
-    BackgroundControllerI(const Ice::ObjectAdapterPtr&, const ConfigurationPtr&);
+    BackgroundControllerI(Ice::ObjectAdapterPtr, ConfigurationPtr);
 
     void pauseCall(std::string, const Ice::Current&) final;
     void resumeCall(std::string, const Ice::Current&) final;
diff --git a/cpp/test/Ice/background/Transceiver.cpp b/cpp/test/Ice/background/Transceiver.cpp
index 22e6ec52462..59cdafc0f42 100644
--- a/cpp/test/Ice/background/Transceiver.cpp
+++ b/cpp/test/Ice/background/Transceiver.cpp
@@ -251,8 +251,8 @@ Transceiver::setBufferSize(int rcvSize, int sndSize)
 //
 // Only for use by Connector, Acceptor
 //
-Transceiver::Transceiver(const IceInternal::TransceiverPtr& transceiver)
-    : _transceiver(transceiver),
+Transceiver::Transceiver(IceInternal::TransceiverPtr transceiver)
+    : _transceiver(std::move(transceiver)),
       _configuration(Configuration::getInstance()),
       _initialized(false),
       _buffered(_configuration->buffered())
diff --git a/cpp/test/Ice/background/Transceiver.h b/cpp/test/Ice/background/Transceiver.h
index fea3e6e7fbe..823d07c40c6 100644
--- a/cpp/test/Ice/background/Transceiver.h
+++ b/cpp/test/Ice/background/Transceiver.h
@@ -12,7 +12,7 @@
 class Transceiver final : public IceInternal::Transceiver
 {
 public:
-    Transceiver(const IceInternal::TransceiverPtr&);
+    Transceiver(IceInternal::TransceiverPtr);
     IceInternal::NativeInfoPtr getNativeInfo() final;
 
     IceInternal::SocketOperation closing(bool, std::exception_ptr) final;
diff --git a/cpp/test/Ice/binding/TestI.cpp b/cpp/test/Ice/binding/TestI.cpp
index f97479f00c5..444391cb271 100644
--- a/cpp/test/Ice/binding/TestI.cpp
+++ b/cpp/test/Ice/binding/TestI.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "TestI.h"
-#include "Ice/Ice.h"
 #include "TestHelper.h"
 
 using namespace std;
@@ -56,8 +55,8 @@ RemoteCommunicatorI::shutdown(const Current& current)
     current.adapter->getCommunicator()->shutdown();
 }
 
-RemoteObjectAdapterI::RemoteObjectAdapterI(const ObjectAdapterPtr& adapter)
-    : _adapter(adapter),
+RemoteObjectAdapterI::RemoteObjectAdapterI(ObjectAdapterPtr adapter)
+    : _adapter(std::move(adapter)),
       _testIntf(_adapter->add<TestIntfPrx>(make_shared<TestI>(), stringToIdentity("test")))
 {
     _adapter->activate();
diff --git a/cpp/test/Ice/binding/TestI.h b/cpp/test/Ice/binding/TestI.h
index c90b7eda473..f8364cf69ea 100644
--- a/cpp/test/Ice/binding/TestI.h
+++ b/cpp/test/Ice/binding/TestI.h
@@ -25,7 +25,7 @@ class RemoteCommunicatorI final : public Test::RemoteCommunicator
 class RemoteObjectAdapterI final : public Test::RemoteObjectAdapter
 {
 public:
-    RemoteObjectAdapterI(const Ice::ObjectAdapterPtr&);
+    RemoteObjectAdapterI(Ice::ObjectAdapterPtr);
 
     std::optional<Test::TestIntfPrx> getTestIntf(const Ice::Current&) final;
     void deactivate(const Ice::Current&) final;
diff --git a/cpp/test/Ice/echo/Server.cpp b/cpp/test/Ice/echo/Server.cpp
index c98ad2e7bd6..346adf0eb81 100644
--- a/cpp/test/Ice/echo/Server.cpp
+++ b/cpp/test/Ice/echo/Server.cpp
@@ -5,6 +5,7 @@
 #include "BlobjectI.h"
 #include "Ice/Ice.h"
 #include "Test.h"
+
 #include "TestHelper.h"
 
 using namespace std;
@@ -12,7 +13,7 @@ using namespace std;
 class EchoI : public Test::Echo
 {
 public:
-    EchoI(const BlobjectIPtr& blob) : _blob(blob) {}
+    EchoI(BlobjectIPtr blob) : _blob(std::move(blob)) {}
 
     void setConnection(const Ice::Current& current) override { _blob->setConnection(current.con); }
 
diff --git a/cpp/test/Ice/executor/TestI.cpp b/cpp/test/Ice/executor/TestI.cpp
index 7e99d7571d1..a67165b2643 100644
--- a/cpp/test/Ice/executor/TestI.cpp
+++ b/cpp/test/Ice/executor/TestI.cpp
@@ -51,4 +51,4 @@ TestIntfControllerI::resumeAdapter(const Ice::Current&)
     _adapter->activate();
 }
 
-TestIntfControllerI::TestIntfControllerI(const Ice::ObjectAdapterPtr& adapter) : _adapter(adapter) {}
+TestIntfControllerI::TestIntfControllerI(Ice::ObjectAdapterPtr adapter) : _adapter(std::move(adapter)) {}
diff --git a/cpp/test/Ice/executor/TestI.h b/cpp/test/Ice/executor/TestI.h
index 3e46857991c..bd317795a5d 100644
--- a/cpp/test/Ice/executor/TestI.h
+++ b/cpp/test/Ice/executor/TestI.h
@@ -26,7 +26,7 @@ class TestIntfControllerI : public Test::TestIntfController
     void holdAdapter(const Ice::Current&) override;
     void resumeAdapter(const Ice::Current&) override;
 
-    TestIntfControllerI(const Ice::ObjectAdapterPtr&);
+    TestIntfControllerI(Ice::ObjectAdapterPtr);
 
 private:
     Ice::ObjectAdapterPtr _adapter;
diff --git a/cpp/test/Ice/hold/TestI.cpp b/cpp/test/Ice/hold/TestI.cpp
index fa77c902d07..1d01be9f5b5 100644
--- a/cpp/test/Ice/hold/TestI.cpp
+++ b/cpp/test/Ice/hold/TestI.cpp
@@ -13,7 +13,7 @@
 
 using namespace std;
 
-HoldI::HoldI(const Ice::ObjectAdapterPtr& adapter) : _last(0), _adapter(adapter) {}
+HoldI::HoldI(Ice::ObjectAdapterPtr adapter) : _last(0), _adapter(std::move(adapter)) {}
 
 void
 HoldI::putOnHoldAsync(int32_t delay, function<void()> response, function<void(std::exception_ptr)>, const Ice::Current&)
diff --git a/cpp/test/Ice/hold/TestI.h b/cpp/test/Ice/hold/TestI.h
index e1fc2571b20..1ddbdc7f1de 100644
--- a/cpp/test/Ice/hold/TestI.h
+++ b/cpp/test/Ice/hold/TestI.h
@@ -10,7 +10,7 @@
 class HoldI final : public Test::Hold
 {
 public:
-    HoldI(const Ice::ObjectAdapterPtr&);
+    HoldI(Ice::ObjectAdapterPtr);
 
     void putOnHoldAsync(
         std::int32_t delay,
diff --git a/cpp/test/Ice/location/ServerLocator.cpp b/cpp/test/Ice/location/ServerLocator.cpp
index f32f2ece306..a7f0ef2dfde 100644
--- a/cpp/test/Ice/location/ServerLocator.cpp
+++ b/cpp/test/Ice/location/ServerLocator.cpp
@@ -102,8 +102,8 @@ ServerLocatorRegistry::addObject(const optional<ObjectPrx>& object)
     _objects[object->ice_getIdentity()] = object;
 }
 
-ServerLocator::ServerLocator(const ServerLocatorRegistryPtr& registry, const optional<LocatorRegistryPrx>& registryPrx)
-    : _registry(registry),
+ServerLocator::ServerLocator(ServerLocatorRegistryPtr registry, const optional<LocatorRegistryPrx>& registryPrx)
+    : _registry(std::move(registry)),
       _registryPrx(registryPrx),
       _requestCount(0)
 {
diff --git a/cpp/test/Ice/location/ServerLocator.h b/cpp/test/Ice/location/ServerLocator.h
index 1ee0fe358b6..c7fcecb6f93 100644
--- a/cpp/test/Ice/location/ServerLocator.h
+++ b/cpp/test/Ice/location/ServerLocator.h
@@ -53,7 +53,7 @@ using ServerLocatorRegistryPtr = std::shared_ptr<ServerLocatorRegistry>;
 class ServerLocator final : public Test::TestLocator
 {
 public:
-    ServerLocator(const ::ServerLocatorRegistryPtr&, const std::optional<Ice::LocatorRegistryPrx>&);
+    ServerLocator(::ServerLocatorRegistryPtr, const std::optional<Ice::LocatorRegistryPrx>&);
 
     void findObjectByIdAsync(
         Ice::Identity,
diff --git a/cpp/test/Ice/location/TestI.cpp b/cpp/test/Ice/location/TestI.cpp
index c58c8e6f286..d1002aeba55 100644
--- a/cpp/test/Ice/location/TestI.cpp
+++ b/cpp/test/Ice/location/TestI.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "TestI.h"
-#include "Ice/Ice.h"
 #include "Ice/Locator.h"
 #include "TestHelper.h"
 
@@ -11,9 +10,9 @@ using namespace std;
 using namespace Ice;
 using namespace Test;
 
-ServerManagerI::ServerManagerI(const ServerLocatorRegistryPtr& registry, const InitializationData& initData)
-    : _registry(registry),
-      _initData(initData),
+ServerManagerI::ServerManagerI(ServerLocatorRegistryPtr registry, InitializationData initData)
+    : _registry(std::move(registry)),
+      _initData(std::move(initData)),
       _nextPort(1)
 {
     _initData.properties->setProperty("TestAdapter.AdapterId", "TestAdapter");
@@ -109,13 +108,10 @@ ServerManagerI::shutdown(const Current& current)
     current.adapter->getCommunicator()->shutdown();
 }
 
-TestI::TestI(
-    const ObjectAdapterPtr& adapter,
-    const ObjectAdapterPtr& adapter2,
-    const ServerLocatorRegistryPtr& registry)
-    : _adapter1(adapter),
-      _adapter2(adapter2),
-      _registry(registry)
+TestI::TestI(ObjectAdapterPtr adapter, ObjectAdapterPtr adapter2, ServerLocatorRegistryPtr registry)
+    : _adapter1(std::move(adapter)),
+      _adapter2(std::move(adapter2)),
+      _registry(std::move(registry))
 {
     _registry->addObject(_adapter1->add(make_shared<HelloI>(), stringToIdentity("hello")));
 }
diff --git a/cpp/test/Ice/location/TestI.h b/cpp/test/Ice/location/TestI.h
index 37f7490b10a..dcbffce02ba 100644
--- a/cpp/test/Ice/location/TestI.h
+++ b/cpp/test/Ice/location/TestI.h
@@ -13,7 +13,7 @@
 class ServerManagerI final : public Test::ServerManager
 {
 public:
-    ServerManagerI(const ServerLocatorRegistryPtr&, const Ice::InitializationData&);
+    ServerManagerI(ServerLocatorRegistryPtr, Ice::InitializationData);
 
     void startServer(const Ice::Current&) final;
     void shutdown(const Ice::Current&) final;
@@ -34,7 +34,7 @@ class HelloI final : public Test::Hello
 class TestI final : public Test::TestIntf
 {
 public:
-    TestI(const Ice::ObjectAdapterPtr&, const Ice::ObjectAdapterPtr&, const ServerLocatorRegistryPtr&);
+    TestI(Ice::ObjectAdapterPtr, Ice::ObjectAdapterPtr, ServerLocatorRegistryPtr);
 
     void shutdown(const Ice::Current&) final;
     std::optional<Test::HelloPrx> getHello(const Ice::Current&) final;
diff --git a/cpp/test/Ice/metrics/AllTests.cpp b/cpp/test/Ice/metrics/AllTests.cpp
index df9c86face6..1668765f093 100644
--- a/cpp/test/Ice/metrics/AllTests.cpp
+++ b/cpp/test/Ice/metrics/AllTests.cpp
@@ -93,7 +93,7 @@ namespace
     class UpdateCallbackI
     {
     public:
-        UpdateCallbackI(const Ice::PropertiesAdminPrx& serverProps) : _updated(false), _serverProps(serverProps) {}
+        UpdateCallbackI(Ice::PropertiesAdminPrx serverProps) : _updated(false), _serverProps(std::move(serverProps)) {}
 
         void waitForUpdate()
         {
@@ -227,7 +227,7 @@ namespace
 
     struct Connect
     {
-        Connect(const Ice::ObjectPrx& proxyP) : proxy(proxyP) {}
+        Connect(Ice::ObjectPrx proxyP) : proxy(std::move(proxyP)) {}
 
         void operator()() const
         {
@@ -253,7 +253,7 @@ namespace
 
     struct InvokeOp
     {
-        InvokeOp(const Test::MetricsPrx& proxyP) : proxy(proxyP) {}
+        InvokeOp(Test::MetricsPrx proxyP) : proxy(std::move(proxyP)) {}
 
         void operator()() const
         {
diff --git a/cpp/test/Ice/metrics/TestAMDI.cpp b/cpp/test/Ice/metrics/TestAMDI.cpp
index 34e1d008dd7..73cb7434525 100644
--- a/cpp/test/Ice/metrics/TestAMDI.cpp
+++ b/cpp/test/Ice/metrics/TestAMDI.cpp
@@ -76,7 +76,7 @@ MetricsI::shutdown(const Ice::Current& current)
     current.adapter->getCommunicator()->shutdown();
 }
 
-ControllerI::ControllerI(const Ice::ObjectAdapterPtr& adapter) : _adapter(adapter) {}
+ControllerI::ControllerI(Ice::ObjectAdapterPtr adapter) : _adapter(std::move(adapter)) {}
 
 void
 ControllerI::hold(const Ice::Current&)
diff --git a/cpp/test/Ice/metrics/TestAMDI.h b/cpp/test/Ice/metrics/TestAMDI.h
index 071abcb3c9b..89d157b1d23 100644
--- a/cpp/test/Ice/metrics/TestAMDI.h
+++ b/cpp/test/Ice/metrics/TestAMDI.h
@@ -41,7 +41,7 @@ class MetricsI final : public Test::Metrics
 class ControllerI final : public Test::Controller
 {
 public:
-    ControllerI(const Ice::ObjectAdapterPtr&);
+    ControllerI(Ice::ObjectAdapterPtr);
 
     void hold(const Ice::Current&) final;
 
diff --git a/cpp/test/Ice/metrics/TestI.cpp b/cpp/test/Ice/metrics/TestI.cpp
index c347e8ff1ea..6b700a5e9b1 100644
--- a/cpp/test/Ice/metrics/TestI.cpp
+++ b/cpp/test/Ice/metrics/TestI.cpp
@@ -61,7 +61,7 @@ MetricsI::shutdown(const Current& current)
     current.adapter->getCommunicator()->shutdown();
 }
 
-ControllerI::ControllerI(const ObjectAdapterPtr& adapter) : _adapter(adapter) {}
+ControllerI::ControllerI(ObjectAdapterPtr adapter) : _adapter(std::move(adapter)) {}
 
 void
 ControllerI::hold(const Current&)
diff --git a/cpp/test/Ice/metrics/TestI.h b/cpp/test/Ice/metrics/TestI.h
index 0777f0ab044..0a11ff11d32 100644
--- a/cpp/test/Ice/metrics/TestI.h
+++ b/cpp/test/Ice/metrics/TestI.h
@@ -31,7 +31,7 @@ class MetricsI final : public Test::Metrics
 class ControllerI final : public Test::Controller
 {
 public:
-    ControllerI(const Ice::ObjectAdapterPtr&);
+    ControllerI(Ice::ObjectAdapterPtr);
 
     void hold(const Ice::Current&) final;
 
diff --git a/cpp/test/Ice/objects/TestI.cpp b/cpp/test/Ice/objects/TestI.cpp
index e480db297f1..d0d9d1511a3 100644
--- a/cpp/test/Ice/objects/TestI.cpp
+++ b/cpp/test/Ice/objects/TestI.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "TestI.h"
-#include "Ice/Ice.h"
 
 using namespace Test;
 using namespace std;
@@ -63,8 +62,8 @@ FI::checkValues()
     return e1 && e1 == e2;
 }
 
-InitialI::InitialI(const ObjectAdapterPtr& adapter)
-    : _adapter(adapter),
+InitialI::InitialI(ObjectAdapterPtr adapter)
+    : _adapter(std::move(adapter)),
       _b1(new BI),
       _b2(new BI),
       _c(new CI),
diff --git a/cpp/test/Ice/objects/TestI.h b/cpp/test/Ice/objects/TestI.h
index 07fe4a0bc77..d95b2ab1687 100644
--- a/cpp/test/Ice/objects/TestI.h
+++ b/cpp/test/Ice/objects/TestI.h
@@ -51,7 +51,7 @@ using FIPtr = std::shared_ptr<FI>;
 class InitialI final : public Test::Initial
 {
 public:
-    InitialI(const Ice::ObjectAdapterPtr&);
+    InitialI(Ice::ObjectAdapterPtr);
     ~InitialI() override;
 
     void shutdown(const Ice::Current&) final;
diff --git a/cpp/test/Ice/operations/Twoways.cpp b/cpp/test/Ice/operations/Twoways.cpp
index 62844f60907..227a4364e74 100644
--- a/cpp/test/Ice/operations/Twoways.cpp
+++ b/cpp/test/Ice/operations/Twoways.cpp
@@ -6,6 +6,7 @@
 #include "Test.h"
 #include "TestHelper.h"
 #include <limits>
+#include <utility>
 
 //
 // Visual C++ defines min and max as macros
@@ -32,7 +33,7 @@ namespace
     class PerThreadContextInvokeThread final
     {
     public:
-        PerThreadContextInvokeThread(const Test::MyClassPrx& proxy) : _proxy(proxy) {}
+        PerThreadContextInvokeThread(Test::MyClassPrx proxy) : _proxy(std::move(proxy)) {}
 
         void run()
         {
diff --git a/cpp/test/Ice/operations/TwowaysAMI.cpp b/cpp/test/Ice/operations/TwowaysAMI.cpp
index e3f0e3ea569..61a93877fef 100644
--- a/cpp/test/Ice/operations/TwowaysAMI.cpp
+++ b/cpp/test/Ice/operations/TwowaysAMI.cpp
@@ -4,7 +4,9 @@
 
 #include "Ice/Ice.h"
 #include "Test.h"
+
 #include "TestHelper.h"
+#include <utility>
 
 //
 // Work-around for GCC warning bug
@@ -61,7 +63,7 @@ namespace
     public:
         Callback() {}
 
-        Callback(const CommunicatorPtr& communicator) : _communicator(communicator) {}
+        Callback(CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
         void ping() { called(); }
 
diff --git a/cpp/test/Ice/plugin/Plugin.cpp b/cpp/test/Ice/plugin/Plugin.cpp
index 99d2842ce95..2850dbb2873 100644
--- a/cpp/test/Ice/plugin/Plugin.cpp
+++ b/cpp/test/Ice/plugin/Plugin.cpp
@@ -12,8 +12,8 @@ namespace
     class Plugin : public Ice::Plugin
     {
     public:
-        Plugin(const Ice::CommunicatorPtr& communicator)
-            : _communicator(communicator),
+        Plugin(Ice::CommunicatorPtr communicator)
+            : _communicator(std::move(communicator)),
               _initialized(false),
               _destroyed(false)
         {
@@ -46,7 +46,7 @@ namespace
     class PluginInitializeFail : public Ice::Plugin
     {
     public:
-        PluginInitializeFail(const Ice::CommunicatorPtr& communicator) : _communicator(communicator) {}
+        PluginInitializeFail(Ice::CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
         void initialize() override { throw CustomPluginException(); }
 
@@ -62,8 +62,8 @@ namespace
     class BasePlugin : public Ice::Plugin
     {
     public:
-        BasePlugin(const Ice::CommunicatorPtr& communicator)
-            : _communicator(communicator),
+        BasePlugin(Ice::CommunicatorPtr communicator)
+            : _communicator(std::move(communicator)),
               _initialized(false),
               _destroyed(false)
         {
@@ -146,8 +146,8 @@ namespace
     class BasePluginFail : public Ice::Plugin
     {
     public:
-        BasePluginFail(const Ice::CommunicatorPtr& communicator)
-            : _communicator(communicator),
+        BasePluginFail(Ice::CommunicatorPtr communicator)
+            : _communicator(std::move(communicator)),
               _initialized(false),
               _destroyed(false)
         {
diff --git a/cpp/test/Ice/retry/TestI.cpp b/cpp/test/Ice/retry/TestI.cpp
index be3524b4618..cdfde9c33e0 100644
--- a/cpp/test/Ice/retry/TestI.cpp
+++ b/cpp/test/Ice/retry/TestI.cpp
@@ -2,9 +2,8 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
-#include "Ice/Ice.h"
-
 #include "TestI.h"
+#include "Ice/Ice.h"
 
 #include <thread>
 using namespace std;
diff --git a/cpp/test/Ice/servantLocator/ServantLocatorI.cpp b/cpp/test/Ice/servantLocator/ServantLocatorI.cpp
index 3380fde7bf0..4f9158138eb 100644
--- a/cpp/test/Ice/servantLocator/ServantLocatorI.cpp
+++ b/cpp/test/Ice/servantLocator/ServantLocatorI.cpp
@@ -16,7 +16,9 @@ using namespace std;
 using namespace Ice;
 using namespace Test;
 
-ServantLocatorI::ServantLocatorI(const string& category) : _category(category), _deactivated(false), _requestId(-1) {}
+ServantLocatorI::ServantLocatorI(string category) : _category(std::move(category)), _deactivated(false), _requestId(-1)
+{
+}
 
 ServantLocatorI::~ServantLocatorI() { test(_deactivated); }
 
diff --git a/cpp/test/Ice/servantLocator/ServantLocatorI.h b/cpp/test/Ice/servantLocator/ServantLocatorI.h
index 79cf6801f93..c4322ff17d6 100644
--- a/cpp/test/Ice/servantLocator/ServantLocatorI.h
+++ b/cpp/test/Ice/servantLocator/ServantLocatorI.h
@@ -12,7 +12,7 @@ namespace Test
     class ServantLocatorI : public Ice::ServantLocator
     {
     public:
-        ServantLocatorI(const std::string&);
+        ServantLocatorI(std::string);
         ~ServantLocatorI() override;
         Ice::ObjectPtr locate(const Ice::Current&, std::shared_ptr<void>&) override;
         void finished(const Ice::Current&, const Ice::ObjectPtr&, const std::shared_ptr<void>&) override;
diff --git a/cpp/test/Ice/stringConverter/Client.cpp b/cpp/test/Ice/stringConverter/Client.cpp
index c33fc571ad4..620961d5391 100644
--- a/cpp/test/Ice/stringConverter/Client.cpp
+++ b/cpp/test/Ice/stringConverter/Client.cpp
@@ -2,12 +2,12 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
+#include "../../../src/Ice/Endian.h"
 #include "Ice/Ice.h"
 #include "Ice/IconvStringConverter.h"
 #include "Test.h"
 #include "TestHelper.h"
 
-#include "../../../src/Ice/Endian.h"
 #include <iostream>
 #include <locale.h>
 
diff --git a/cpp/test/Ice/timeout/TestI.cpp b/cpp/test/Ice/timeout/TestI.cpp
index 046aaad0030..9d1f9c00613 100644
--- a/cpp/test/Ice/timeout/TestI.cpp
+++ b/cpp/test/Ice/timeout/TestI.cpp
@@ -27,7 +27,7 @@ TimeoutI::sleep(int32_t to, const Ice::Current&)
     this_thread::sleep_for(chrono::milliseconds(to));
 }
 
-ControllerI::ControllerI(const Ice::ObjectAdapterPtr& adapter) : _adapter(adapter) {}
+ControllerI::ControllerI(Ice::ObjectAdapterPtr adapter) : _adapter(std::move(adapter)) {}
 
 void
 ControllerI::holdAdapter(int32_t to, const Ice::Current&)
diff --git a/cpp/test/Ice/timeout/TestI.h b/cpp/test/Ice/timeout/TestI.h
index b6393652869..978e6f94ecd 100644
--- a/cpp/test/Ice/timeout/TestI.h
+++ b/cpp/test/Ice/timeout/TestI.h
@@ -18,7 +18,7 @@ class TimeoutI final : public Test::Timeout
 class ControllerI final : public Test::Controller
 {
 public:
-    ControllerI(const Ice::ObjectAdapterPtr&);
+    ControllerI(Ice::ObjectAdapterPtr);
 
     void holdAdapter(std::int32_t, const Ice::Current&) final;
     void resumeAdapter(const Ice::Current&) final;
diff --git a/cpp/test/IceBox/configuration/TestI.cpp b/cpp/test/IceBox/configuration/TestI.cpp
index 05cf01aff5c..81c33183189 100644
--- a/cpp/test/IceBox/configuration/TestI.cpp
+++ b/cpp/test/IceBox/configuration/TestI.cpp
@@ -3,11 +3,10 @@
 //
 
 #include "TestI.h"
-#include "Ice/Ice.h"
 
 using namespace Test;
 
-TestI::TestI(const Ice::StringSeq& args) : _args(args) {}
+TestI::TestI(Ice::StringSeq args) : _args(std::move(args)) {}
 
 std::string
 TestI::getProperty(std::string name, const Ice::Current& current)
diff --git a/cpp/test/IceBox/configuration/TestI.h b/cpp/test/IceBox/configuration/TestI.h
index d69c9373326..abb16537e68 100644
--- a/cpp/test/IceBox/configuration/TestI.h
+++ b/cpp/test/IceBox/configuration/TestI.h
@@ -10,7 +10,7 @@
 class TestI : public ::Test::TestIntf
 {
 public:
-    TestI(const Ice::StringSeq&);
+    TestI(Ice::StringSeq);
 
     std::string getProperty(std::string, const Ice::Current&) override;
     Ice::StringSeq getArgs(const Ice::Current&) override;
diff --git a/cpp/test/IceGrid/deployer/Server.cpp b/cpp/test/IceGrid/deployer/Server.cpp
index 037e19d0a92..ce7f3a41617 100644
--- a/cpp/test/IceGrid/deployer/Server.cpp
+++ b/cpp/test/IceGrid/deployer/Server.cpp
@@ -2,12 +2,13 @@
 // Copyright (c) ZeroC, Inc. All rights reserved.
 //
 
-#include "../../src/Ice/DisableWarnings.h"
 #include "Ice/Ice.h"
 #include "TestHelper.h"
 #include "TestI.h"
 #include <fstream>
 
+#include "../../src/Ice/DisableWarnings.h"
+
 using namespace std;
 
 class Server : public Test::TestHelper
diff --git a/cpp/test/IceGrid/deployer/TestI.cpp b/cpp/test/IceGrid/deployer/TestI.cpp
index 2b893ba9889..5d4ceeecac8 100644
--- a/cpp/test/IceGrid/deployer/TestI.cpp
+++ b/cpp/test/IceGrid/deployer/TestI.cpp
@@ -4,8 +4,9 @@
 
 #include "TestI.h"
 #include "Ice/Ice.h"
+#include <utility>
 
-TestI::TestI(const Ice::PropertiesPtr& properties) : _properties(properties) {}
+TestI::TestI(Ice::PropertiesPtr properties) : _properties(std::move(properties)) {}
 
 void
 TestI::shutdown(const Ice::Current& current)
diff --git a/cpp/test/IceGrid/deployer/TestI.h b/cpp/test/IceGrid/deployer/TestI.h
index 696032d5f1d..9507b416706 100644
--- a/cpp/test/IceGrid/deployer/TestI.h
+++ b/cpp/test/IceGrid/deployer/TestI.h
@@ -10,7 +10,7 @@
 class TestI : public ::Test::TestIntf
 {
 public:
-    TestI(const Ice::PropertiesPtr&);
+    TestI(Ice::PropertiesPtr);
 
     void shutdown(const Ice::Current&) override;
     std::string getProperty(std::string, const Ice::Current&) override;
diff --git a/cpp/test/IceGrid/replicaGroup/RegistryPlugin.cpp b/cpp/test/IceGrid/replicaGroup/RegistryPlugin.cpp
index 6ef2a7a1c39..0a1acddbc5f 100644
--- a/cpp/test/IceGrid/replicaGroup/RegistryPlugin.cpp
+++ b/cpp/test/IceGrid/replicaGroup/RegistryPlugin.cpp
@@ -4,7 +4,6 @@
 
 #include "Ice/Ice.h"
 #include "IceGrid/IceGrid.h"
-
 #include "TestHelper.h"
 
 using namespace std;
@@ -120,9 +119,9 @@ namespace
     class ExcludeReplicaGroupFilterI final : public IceGrid::ReplicaGroupFilter
     {
     public:
-        ExcludeReplicaGroupFilterI(const shared_ptr<RegistryPluginFacade>& facade, const string& exclude)
+        ExcludeReplicaGroupFilterI(const shared_ptr<RegistryPluginFacade>& facade, string exclude)
             : _facade(facade),
-              _exclude(exclude)
+              _exclude(std::move(exclude))
         {
         }
 
diff --git a/cpp/test/IceGrid/replicaGroup/TestI.cpp b/cpp/test/IceGrid/replicaGroup/TestI.cpp
index 39fca510dff..0aac11891fd 100644
--- a/cpp/test/IceGrid/replicaGroup/TestI.cpp
+++ b/cpp/test/IceGrid/replicaGroup/TestI.cpp
@@ -4,8 +4,9 @@
 
 #include "TestI.h"
 #include "Ice/Ice.h"
+#include <utility>
 
-TestI::TestI(const Ice::PropertiesPtr& properties) : _properties(properties) {}
+TestI::TestI(Ice::PropertiesPtr properties) : _properties(std::move(properties)) {}
 
 std::string
 TestI::getReplicaId(const Ice::Current& current)
diff --git a/cpp/test/IceGrid/replicaGroup/TestI.h b/cpp/test/IceGrid/replicaGroup/TestI.h
index f2b29101afa..46104322571 100644
--- a/cpp/test/IceGrid/replicaGroup/TestI.h
+++ b/cpp/test/IceGrid/replicaGroup/TestI.h
@@ -10,7 +10,7 @@
 class TestI : public ::Test::TestIntf
 {
 public:
-    TestI(const Ice::PropertiesPtr&);
+    TestI(Ice::PropertiesPtr);
 
     std::string getReplicaId(const Ice::Current&) override;
     std::string getReplicaIdAndShutdown(const Ice::Current&) override;
diff --git a/cpp/test/IceGrid/update/TestI.cpp b/cpp/test/IceGrid/update/TestI.cpp
index 2b893ba9889..c6f95852019 100644
--- a/cpp/test/IceGrid/update/TestI.cpp
+++ b/cpp/test/IceGrid/update/TestI.cpp
@@ -3,9 +3,8 @@
 //
 
 #include "TestI.h"
-#include "Ice/Ice.h"
 
-TestI::TestI(const Ice::PropertiesPtr& properties) : _properties(properties) {}
+TestI::TestI(Ice::PropertiesPtr properties) : _properties(std::move(properties)) {}
 
 void
 TestI::shutdown(const Ice::Current& current)
diff --git a/cpp/test/IceGrid/update/TestI.h b/cpp/test/IceGrid/update/TestI.h
index 696032d5f1d..9507b416706 100644
--- a/cpp/test/IceGrid/update/TestI.h
+++ b/cpp/test/IceGrid/update/TestI.h
@@ -10,7 +10,7 @@
 class TestI : public ::Test::TestIntf
 {
 public:
-    TestI(const Ice::PropertiesPtr&);
+    TestI(Ice::PropertiesPtr);
 
     void shutdown(const Ice::Current&) override;
     std::string getProperty(std::string, const Ice::Current&) override;
diff --git a/cpp/test/IceSSL/configuration/TestI.cpp b/cpp/test/IceSSL/configuration/TestI.cpp
index 1c54bdad3bd..e4969308f6d 100644
--- a/cpp/test/IceSSL/configuration/TestI.cpp
+++ b/cpp/test/IceSSL/configuration/TestI.cpp
@@ -9,7 +9,7 @@
 using namespace std;
 using namespace Ice;
 
-ServerI::ServerI(const CommunicatorPtr& communicator) : _communicator(communicator) {}
+ServerI::ServerI(CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 ServerI::noCert(const Ice::Current& c)
@@ -51,7 +51,7 @@ ServerI::destroy()
     _communicator->destroy();
 }
 
-ServerFactoryI::ServerFactoryI(const string& defaultDir) : _defaultDir(defaultDir) {}
+ServerFactoryI::ServerFactoryI(string defaultDir) : _defaultDir(std::move(defaultDir)) {}
 
 optional<Test::ServerPrx>
 ServerFactoryI::createServer(Test::Properties props, const Current&)
diff --git a/cpp/test/IceSSL/configuration/TestI.h b/cpp/test/IceSSL/configuration/TestI.h
index a8736400c47..d88201113fc 100644
--- a/cpp/test/IceSSL/configuration/TestI.h
+++ b/cpp/test/IceSSL/configuration/TestI.h
@@ -10,7 +10,7 @@
 class ServerI : public Test::Server
 {
 public:
-    ServerI(const Ice::CommunicatorPtr&);
+    ServerI(Ice::CommunicatorPtr);
 
     void noCert(const Ice::Current&) override;
     void checkCert(std::string, std::string, const Ice::Current&) override;
@@ -25,7 +25,7 @@ using ServerIPtr = std::shared_ptr<ServerI>;
 class ServerFactoryI : public Test::ServerFactory
 {
 public:
-    ServerFactoryI(const std::string&);
+    ServerFactoryI(std::string);
 
     std::optional<Test::ServerPrx> createServer(Test::Properties, const Ice::Current&) override;
     void destroyServer(std::optional<Test::ServerPrx>, const Ice::Current&) override;
diff --git a/cpp/test/IceStorm/rep1/Subscriber.cpp b/cpp/test/IceStorm/rep1/Subscriber.cpp
index 59ee9288d78..86e0f69b9d3 100644
--- a/cpp/test/IceStorm/rep1/Subscriber.cpp
+++ b/cpp/test/IceStorm/rep1/Subscriber.cpp
@@ -18,9 +18,9 @@ using namespace Test;
 class SingleI final : public Single
 {
 public:
-    SingleI(const CommunicatorPtr& communicator, const string& name, int max)
-        : _communicator(communicator),
-          _name(name),
+    SingleI(CommunicatorPtr communicator, string name, int max)
+        : _communicator(std::move(communicator)),
+          _name(std::move(name)),
           _max(max),
           _count(0),
           _last(0)
diff --git a/cpp/test/IceStorm/single/Subscriber.cpp b/cpp/test/IceStorm/single/Subscriber.cpp
index ebee5596f6e..2028215b35d 100644
--- a/cpp/test/IceStorm/single/Subscriber.cpp
+++ b/cpp/test/IceStorm/single/Subscriber.cpp
@@ -17,7 +17,7 @@ using namespace Test;
 class SingleI final : public Single
 {
 public:
-    SingleI(const string& name) : _name(name), _count(0), _last(0) {}
+    SingleI(string name) : _name(std::move(name)), _count(0), _last(0) {}
 
     void event(int i, const Current& current) override
     {
diff --git a/cpp/test/IceUtil/timer/Client.cpp b/cpp/test/IceUtil/timer/Client.cpp
index 41de6818d53..d7fbf3b58be 100644
--- a/cpp/test/IceUtil/timer/Client.cpp
+++ b/cpp/test/IceUtil/timer/Client.cpp
@@ -96,7 +96,7 @@ using TestTaskPtr = std::shared_ptr<TestTask>;
 class DestroyTask : public TimerTask
 {
 public:
-    DestroyTask(const IceInternal::TimerPtr& timer) : _timer(timer), _run(false) {}
+    DestroyTask(IceInternal::TimerPtr timer) : _timer(std::move(timer)), _run(false) {}
 
     void runTimerTask() override
     {