Refactor: Use std::make_unique where applicable (#1854)

tigercosmos · google-labs-jules[bot] · web-flow · commit 8f27144cc679 · 2025-07-02T18:07:47.000+08:00
* Refactor: Use std::make_unique where applicable

Replaced direct usage of new with std::unique_ptr with std::make_unique
for improved memory safety and conciseness in C++14 and later.

Introduced static factory methods for PcapLiveDevice and WinPcapLiveDevice
to allow std::unique_ptr creation while keeping their constructors protected.

* fix

* format code.

* revert

---------

Co-authored-by: google-labs-jules[bot] &lt;161369871+google-labs-jules[bot]@users.noreply.github.com&gt;
diff --git a/Common++/header/IpAddress.h b/Common++/header/IpAddress.h
@@ -625,11 +625,11 @@ namespace pcpp
 		{
 			if (address.isIPv4())
 			{
-				m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(address.getIPv4(), prefixLen));
+				m_IPv4Network = std::make_unique<IPv4Network>(address.getIPv4(), prefixLen);
 			}
 			else
 			{
-				m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(address.getIPv6(), prefixLen));
+				m_IPv6Network = std::make_unique<IPv6Network>(address.getIPv6(), prefixLen);
 			}
 		}
 
@@ -646,11 +646,11 @@ namespace pcpp
 		{
 			if (address.isIPv4())
 			{
-				m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(address.getIPv4(), netmask));
+				m_IPv4Network = std::make_unique<IPv4Network>(address.getIPv4(), netmask);
 			}
 			else
 			{
-				m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(address.getIPv6(), netmask));
+				m_IPv6Network = std::make_unique<IPv6Network>(address.getIPv6(), netmask);
 			}
 		}
 
@@ -666,11 +666,11 @@ namespace pcpp
 		{
 			try
 			{
-				m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(addressAndNetmask));
+				m_IPv4Network = std::make_unique<IPv4Network>(addressAndNetmask);
 			}
 			catch (const std::invalid_argument&)
 			{
-				m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(addressAndNetmask));
+				m_IPv6Network = std::make_unique<IPv6Network>(addressAndNetmask);
 			}
 		}
 
@@ -680,12 +680,12 @@ namespace pcpp
 		{
 			if (other.m_IPv4Network)
 			{
-				m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(*other.m_IPv4Network));
+				m_IPv4Network = std::make_unique<IPv4Network>(*other.m_IPv4Network);
 			}
 
 			if (other.m_IPv6Network)
 			{
-				m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(*other.m_IPv6Network));
+				m_IPv6Network = std::make_unique<IPv6Network>(*other.m_IPv6Network);
 			}
 		}
 
@@ -710,7 +710,7 @@ namespace pcpp
 		IPNetwork& operator=(const IPv4Network& other)
 		{
 			// Create the new instance first to maintain strong exception guarantee.
-			m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(other));
+			m_IPv4Network = std::make_unique<IPv4Network>(other);
 			m_IPv6Network = nullptr;
 			return *this;
 		}
@@ -721,7 +721,7 @@ namespace pcpp
 		IPNetwork& operator=(const IPv6Network& other)
 		{
 			// Create the new instance first to maintain strong exception guarantee.
-			m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(other));
+			m_IPv6Network = std::make_unique<IPv6Network>(other);
 			m_IPv4Network = nullptr;
 			return *this;
 		}
diff --git a/Common++/header/PointerVector.h b/Common++/header/PointerVector.h
@@ -25,7 +25,7 @@ namespace pcpp
 		{
 			std::unique_ptr<T> operator()(const T& obj) const
 			{
-				return std::unique_ptr<T>(new T(obj));
+				return std::make_unique<T>(obj);
 			}
 		};
 
diff --git a/Common++/src/Logger.cpp b/Common++/src/Logger.cpp
@@ -67,7 +67,7 @@ namespace pcpp
 			ctx->init(level, source);
 			return ctx;
 		}
-		return std::unique_ptr<internal::LogContext>(new internal::LogContext(level, source));
+		return std::make_unique<internal::LogContext>(level, source);
 	}
 
 	void Logger::emit(std::unique_ptr<internal::LogContext> message)
diff --git a/Packet++/src/LdapLayer.cpp b/Packet++/src/LdapLayer.cpp
@@ -205,13 +205,13 @@ namespace pcpp
 		std::unique_ptr<Asn1Record> messageRootRecord;
 		if (!messageRecords.empty())
 		{
-			messageRootRecord = std::unique_ptr<Asn1Record>(
-			    new Asn1ConstructedRecord(Asn1TagClass::Application, operationType, messageRecords));
+			messageRootRecord =
+			    std::make_unique<Asn1ConstructedRecord>(Asn1TagClass::Application, operationType, messageRecords);
 		}
 		else
 		{
 			messageRootRecord =
-			    std::unique_ptr<Asn1Record>(new Asn1GenericRecord(Asn1TagClass::Application, false, operationType, ""));
+			    std::make_unique<Asn1GenericRecord>(Asn1TagClass::Application, false, operationType, "");
 		}
 
 		std::vector<Asn1Record*> rootSubRecords = { &messageIdRecord, messageRootRecord.get() };
@@ -230,14 +230,14 @@ namespace pcpp
 				else
 				{
 					auto controlValueSize = static_cast<size_t>(control.controlValue.size() / 2);
-					std::unique_ptr<uint8_t[]> controlValue(new uint8_t[controlValueSize]);
+					std::unique_ptr<uint8_t[]> controlValue = std::make_unique<uint8_t[]>(controlValueSize);
 					controlValueSize = hexStringToByteArray(control.controlValue, controlValue.get(), controlValueSize);
 					Asn1OctetStringRecord controlValueRecord(controlValue.get(), controlValueSize);
 					controlsSubRecords.pushBack(new Asn1SequenceRecord({ &controlTypeRecord, &controlValueRecord }));
 				}
 			}
-			controlsRecord = std::unique_ptr<Asn1ConstructedRecord>(
-			    new Asn1ConstructedRecord(Asn1TagClass::ContextSpecific, 0, controlsSubRecords));
+			controlsRecord =
+			    std::make_unique<Asn1ConstructedRecord>(Asn1TagClass::ContextSpecific, 0, controlsSubRecords);
 			rootSubRecords.push_back(controlsRecord.get());
 		}
 
@@ -404,8 +404,8 @@ namespace pcpp
 			{
 				referralSubRecords.pushBack(new Asn1OctetStringRecord(uri));
 			}
-			referralRecord = std::unique_ptr<Asn1ConstructedRecord>(
-			    new Asn1ConstructedRecord(Asn1TagClass::ContextSpecific, referralTagType, referralSubRecords));
+			referralRecord = std::make_unique<Asn1ConstructedRecord>(Asn1TagClass::ContextSpecific, referralTagType,
+			                                                         referralSubRecords);
 			messageRecords.push_back(referralRecord.get());
 		}
 
@@ -489,10 +489,10 @@ namespace pcpp
 		if (!simpleAuthentication.empty())
 		{
 			auto data = reinterpret_cast<const uint8_t*>(simpleAuthentication.data());
-			simpleAuthenticationRecord = std::unique_ptr<Asn1GenericRecord>(
-			    new Asn1GenericRecord(Asn1TagClass::ContextSpecific, false,
-			                          static_cast<uint8_t>(LdapBindRequestLayer::AuthenticationType::Simple), data,
-			                          simpleAuthentication.size()));
+			simpleAuthenticationRecord = std::make_unique<Asn1GenericRecord>(
+			    Asn1TagClass::ContextSpecific, false,
+			    static_cast<uint8_t>(LdapBindRequestLayer::AuthenticationType::Simple), data,
+			    simpleAuthentication.size());
 			messageRecords.push_back(simpleAuthenticationRecord.get());
 		}
 
@@ -518,9 +518,9 @@ namespace pcpp
 				saslAuthenticationRecords.pushBack(credentialsRecord);
 			}
 
-			saslAuthenticationRecord = std::unique_ptr<Asn1ConstructedRecord>(new Asn1ConstructedRecord(
+			saslAuthenticationRecord = std::make_unique<Asn1ConstructedRecord>(
 			    Asn1TagClass::ContextSpecific, static_cast<uint8_t>(LdapBindRequestLayer::AuthenticationType::Sasl),
-			    saslAuthenticationRecords));
+			    saslAuthenticationRecords);
 			messageRecords.push_back(saslAuthenticationRecord.get());
 		}
 
@@ -625,9 +625,9 @@ namespace pcpp
 		std::unique_ptr<Asn1Record> serverSaslCredentialsRecord;
 		if (!serverSaslCredentials.empty())
 		{
-			serverSaslCredentialsRecord = std::unique_ptr<Asn1Record>(
-			    new Asn1GenericRecord(Asn1TagClass::ContextSpecific, false, serverSaslCredentialsTagType,
-			                          serverSaslCredentials.data(), serverSaslCredentials.size()));
+			serverSaslCredentialsRecord =
+			    std::make_unique<Asn1GenericRecord>(Asn1TagClass::ContextSpecific, false, serverSaslCredentialsTagType,
+			                                        serverSaslCredentials.data(), serverSaslCredentials.size());
 			additionalRecords.push_back(serverSaslCredentialsRecord.get());
 		}
 
diff --git a/Pcap++/src/DpdkDeviceList.cpp b/Pcap++/src/DpdkDeviceList.cpp
@@ -198,6 +198,7 @@ namespace pcpp
 		// Initialize a DpdkDevice per port
 		for (int i = 0; i < numOfPorts; i++)
 		{
+			// Not using std::make_unique because ctor of DpdkDevice is private
 			auto newDevice = std::unique_ptr<DpdkDevice>(new DpdkDevice(i, mBufPoolSizePerDevice, mBufDataSize));
 			PCPP_LOG_DEBUG("DpdkDevice #" << i << ": Name='" << newDevice->getDeviceName() << "', PCI-slot='"
 			                              << newDevice->getPciAddress() << "', PMD='" << newDevice->getPMDName()
diff --git a/Pcap++/src/PcapFileDevice.cpp b/Pcap++/src/PcapFileDevice.cpp
@@ -338,7 +338,7 @@ namespace pcpp
 		{
 			return false;
 		}
-		std::unique_ptr<char[]> packetData(new char[packetSize]);
+		std::unique_ptr<char[]> packetData = std::make_unique<char[]>(packetSize);
 		m_snoopFile.read(packetData.get(), packetSize);
 		if (!m_snoopFile)
 		{
diff --git a/Pcap++/src/PcapFilter.cpp b/Pcap++/src/PcapFilter.cpp
@@ -68,7 +68,7 @@ namespace pcpp
 				return false;
 			}
 
-			std::unique_ptr<bpf_program> newProg = std::unique_ptr<bpf_program>(new bpf_program);
+			auto newProg = std::make_unique<bpf_program>();
 			int ret = pcap_compile(pcap.get(), newProg.get(), filter.c_str(), 1, 0);
 			if (ret < 0)
 			{
diff --git a/Pcap++/src/PcapLiveDevice.cpp b/Pcap++/src/PcapLiveDevice.cpp
@@ -688,8 +688,8 @@ namespace pcpp
 		{
 			// Due to passing a 'this' pointer, the current device object shouldn't be relocated, while the worker is
 			// active.
-			m_StatisticsUpdateWorker = std::unique_ptr<StatisticsUpdateWorker>(new StatisticsUpdateWorker(
-			    *this, std::move(onStatsUpdate), onStatsUpdateUserCookie, intervalInSecondsToUpdateStats * 1000));
+			m_StatisticsUpdateWorker = std::make_unique<StatisticsUpdateWorker>(
+			    *this, std::move(onStatsUpdate), onStatsUpdateUserCookie, intervalInSecondsToUpdateStats * 1000);
 
 			PCPP_LOG_DEBUG("Successfully created stats thread for device '" << m_InterfaceDetails.name << "'.");
 		}
diff --git a/Pcap++/src/PfRingDeviceList.cpp b/Pcap++/src/PfRingDeviceList.cpp
@@ -92,6 +92,7 @@ namespace pcpp
 						PCPP_LOG_DEBUG("PF_RING version is: " << m_PfRingVersion);
 					}
 
+					// Not using std::make_unique because ctor of PfRingDevice is private
 					auto newDev = std::unique_ptr<PfRingDevice>(new PfRingDevice(currInterface->name));
 					m_DeviceList.pushBack(std::move(newDev));
 					PCPP_LOG_DEBUG("Found interface: " << currInterface->name);
diff --git a/Tests/Packet++Test/Tests/PacketTests.cpp b/Tests/Packet++Test/Tests/PacketTests.cpp
@@ -818,7 +818,7 @@ PTF_TEST_CASE(PacketTrailerTest)
 
 	// add layer after trailer (result with an error)
 	uint8_t payload[4] = { 0x1, 0x2, 0x3, 0x4 };
-	std::unique_ptr<pcpp::PayloadLayer> newPayloadLayer(new pcpp::PayloadLayer(payload, 4));
+	std::unique_ptr<pcpp::PayloadLayer> newPayloadLayer = std::make_unique<pcpp::PayloadLayer>(payload, 4);
 	pcpp::Logger::getInstance().suppressLogs();
 	PTF_ASSERT_FALSE(trailerIPv4Packet.addLayer(newPayloadLayer.get(), true));
 	pcpp::Logger::getInstance().enableLogs();

Original file line number	Diff line number	Diff line change
`@@ -625,11 +625,11 @@ namespace pcpp`
`625`	`625`	`{`
`626`	`626`	`if (address.isIPv4())`
`627`	`627`	`{`
`628`		`- m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(address.getIPv4(), prefixLen));`
	`628`	`+ m_IPv4Network = std::make_unique<IPv4Network>(address.getIPv4(), prefixLen);`
`629`	`629`	`}`
`630`	`630`	`else`
`631`	`631`	`{`
`632`		`- m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(address.getIPv6(), prefixLen));`
	`632`	`+ m_IPv6Network = std::make_unique<IPv6Network>(address.getIPv6(), prefixLen);`
`633`	`633`	`}`
`634`	`634`	`}`
`635`	`635`
`@@ -646,11 +646,11 @@ namespace pcpp`
`646`	`646`	`{`
`647`	`647`	`if (address.isIPv4())`
`648`	`648`	`{`
`649`		`- m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(address.getIPv4(), netmask));`
	`649`	`+ m_IPv4Network = std::make_unique<IPv4Network>(address.getIPv4(), netmask);`
`650`	`650`	`}`
`651`	`651`	`else`
`652`	`652`	`{`
`653`		`- m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(address.getIPv6(), netmask));`
	`653`	`+ m_IPv6Network = std::make_unique<IPv6Network>(address.getIPv6(), netmask);`
`654`	`654`	`}`
`655`	`655`	`}`
`656`	`656`
`@@ -666,11 +666,11 @@ namespace pcpp`
`666`	`666`	`{`
`667`	`667`	`try`
`668`	`668`	`{`
`669`		`- m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(addressAndNetmask));`
	`669`	`+ m_IPv4Network = std::make_unique<IPv4Network>(addressAndNetmask);`
`670`	`670`	`}`
`671`	`671`	`catch (const std::invalid_argument&)`
`672`	`672`	`{`
`673`		`- m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(addressAndNetmask));`
	`673`	`+ m_IPv6Network = std::make_unique<IPv6Network>(addressAndNetmask);`
`674`	`674`	`}`
`675`	`675`	`}`
`676`	`676`
`@@ -680,12 +680,12 @@ namespace pcpp`
`680`	`680`	`{`
`681`	`681`	`if (other.m_IPv4Network)`
`682`	`682`	`{`
`683`		`- m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(*other.m_IPv4Network));`
	`683`	`+ m_IPv4Network = std::make_unique<IPv4Network>(*other.m_IPv4Network);`
`684`	`684`	`}`
`685`	`685`
`686`	`686`	`if (other.m_IPv6Network)`
`687`	`687`	`{`
`688`		`- m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(*other.m_IPv6Network));`
	`688`	`+ m_IPv6Network = std::make_unique<IPv6Network>(*other.m_IPv6Network);`
`689`	`689`	`}`
`690`	`690`	`}`
`691`	`691`
`@@ -710,7 +710,7 @@ namespace pcpp`
`710`	`710`	`IPNetwork& operator=(const IPv4Network& other)`
`711`	`711`	`{`
`712`	`712`	`// Create the new instance first to maintain strong exception guarantee.`
`713`		`- m_IPv4Network = std::unique_ptr<IPv4Network>(new IPv4Network(other));`
	`713`	`+ m_IPv4Network = std::make_unique<IPv4Network>(other);`
`714`	`714`	`m_IPv6Network = nullptr;`
`715`	`715`	`return *this;`
`716`	`716`	`}`
`@@ -721,7 +721,7 @@ namespace pcpp`
`721`	`721`	`IPNetwork& operator=(const IPv6Network& other)`
`722`	`722`	`{`
`723`	`723`	`// Create the new instance first to maintain strong exception guarantee.`
`724`		`- m_IPv6Network = std::unique_ptr<IPv6Network>(new IPv6Network(other));`
	`724`	`+ m_IPv6Network = std::make_unique<IPv6Network>(other);`
`725`	`725`	`m_IPv4Network = nullptr;`
`726`	`726`	`return *this;`
`727`	`727`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ namespace pcpp`
`25`	`25`	`{`
`26`	`26`	`std::unique_ptr<T> operator()(const T& obj) const`
`27`	`27`	`{`
`28`		`- return std::unique_ptr<T>(new T(obj));`
	`28`	`+ return std::make_unique<T>(obj);`
`29`	`29`	`}`
`30`	`30`	`};`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ namespace pcpp`
`67`	`67`	`ctx->init(level, source);`
`68`	`68`	`return ctx;`
`69`	`69`	`}`
`70`		`- return std::unique_ptr<internal::LogContext>(new internal::LogContext(level, source));`
	`70`	`+ return std::make_unique<internal::LogContext>(level, source);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`void Logger::emit(std::unique_ptr<internal::LogContext> message)`
Original file line number	Diff line number	Diff line change
`@@ -205,13 +205,13 @@ namespace pcpp`
`205`	`205`	`std::unique_ptr<Asn1Record> messageRootRecord;`
`206`	`206`	`if (!messageRecords.empty())`
`207`	`207`	`{`
`208`		`- messageRootRecord = std::unique_ptr<Asn1Record>(`
`209`		`- new Asn1ConstructedRecord(Asn1TagClass::Application, operationType, messageRecords));`
	`208`	`+ messageRootRecord =`
	`209`	`+ std::make_unique<Asn1ConstructedRecord>(Asn1TagClass::Application, operationType, messageRecords);`
`210`	`210`	`}`
`211`	`211`	`else`
`212`	`212`	`{`
`213`	`213`	`messageRootRecord =`
`214`		`- std::unique_ptr<Asn1Record>(new Asn1GenericRecord(Asn1TagClass::Application, false, operationType, ""));`
	`214`	`+ std::make_unique<Asn1GenericRecord>(Asn1TagClass::Application, false, operationType, "");`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`std::vector<Asn1Record*> rootSubRecords = { &messageIdRecord, messageRootRecord.get() };`
`@@ -230,14 +230,14 @@ namespace pcpp`
`230`	`230`	`else`
`231`	`231`	`{`
`232`	`232`	`auto controlValueSize = static_cast<size_t>(control.controlValue.size() / 2);`
`233`		`- std::unique_ptr<uint8_t[]> controlValue(new uint8_t[controlValueSize]);`
	`233`	`+ std::unique_ptr<uint8_t[]> controlValue = std::make_unique<uint8_t[]>(controlValueSize);`
`234`	`234`	`controlValueSize = hexStringToByteArray(control.controlValue, controlValue.get(), controlValueSize);`
`235`	`235`	`Asn1OctetStringRecord controlValueRecord(controlValue.get(), controlValueSize);`
`236`	`236`	`controlsSubRecords.pushBack(new Asn1SequenceRecord({ &controlTypeRecord, &controlValueRecord }));`
`237`	`237`	`}`
`238`	`238`	`}`
`239`		`- controlsRecord = std::unique_ptr<Asn1ConstructedRecord>(`
`240`		`- new Asn1ConstructedRecord(Asn1TagClass::ContextSpecific, 0, controlsSubRecords));`
	`239`	`+ controlsRecord =`
	`240`	`+ std::make_unique<Asn1ConstructedRecord>(Asn1TagClass::ContextSpecific, 0, controlsSubRecords);`
`241`	`241`	`rootSubRecords.push_back(controlsRecord.get());`
`242`	`242`	`}`
`243`	`243`
`@@ -404,8 +404,8 @@ namespace pcpp`
`404`	`404`	`{`
`405`	`405`	`referralSubRecords.pushBack(new Asn1OctetStringRecord(uri));`
`406`	`406`	`}`
`407`		`- referralRecord = std::unique_ptr<Asn1ConstructedRecord>(`
`408`		`- new Asn1ConstructedRecord(Asn1TagClass::ContextSpecific, referralTagType, referralSubRecords));`
	`407`	`+ referralRecord = std::make_unique<Asn1ConstructedRecord>(Asn1TagClass::ContextSpecific, referralTagType,`
	`408`	`+ referralSubRecords);`
`409`	`409`	`messageRecords.push_back(referralRecord.get());`
`410`	`410`	`}`
`411`	`411`
`@@ -489,10 +489,10 @@ namespace pcpp`
`489`	`489`	`if (!simpleAuthentication.empty())`
`490`	`490`	`{`
`491`	`491`	`auto data = reinterpret_cast<const uint8_t*>(simpleAuthentication.data());`
`492`		`- simpleAuthenticationRecord = std::unique_ptr<Asn1GenericRecord>(`
`493`		`- new Asn1GenericRecord(Asn1TagClass::ContextSpecific, false,`
`494`		`- static_cast<uint8_t>(LdapBindRequestLayer::AuthenticationType::Simple), data,`
`495`		`- simpleAuthentication.size()));`
	`492`	`+ simpleAuthenticationRecord = std::make_unique<Asn1GenericRecord>(`
	`493`	`+ Asn1TagClass::ContextSpecific, false,`
	`494`	`+ static_cast<uint8_t>(LdapBindRequestLayer::AuthenticationType::Simple), data,`
	`495`	`+ simpleAuthentication.size());`
`496`	`496`	`messageRecords.push_back(simpleAuthenticationRecord.get());`
`497`	`497`	`}`
`498`	`498`
`@@ -518,9 +518,9 @@ namespace pcpp`
`518`	`518`	`saslAuthenticationRecords.pushBack(credentialsRecord);`
`519`	`519`	`}`
`520`	`520`
`521`		`- saslAuthenticationRecord = std::unique_ptr<Asn1ConstructedRecord>(new Asn1ConstructedRecord(`
	`521`	`+ saslAuthenticationRecord = std::make_unique<Asn1ConstructedRecord>(`
`522`	`522`	`Asn1TagClass::ContextSpecific, static_cast<uint8_t>(LdapBindRequestLayer::AuthenticationType::Sasl),`
`523`		`- saslAuthenticationRecords));`
	`523`	`+ saslAuthenticationRecords);`
`524`	`524`	`messageRecords.push_back(saslAuthenticationRecord.get());`
`525`	`525`	`}`
`526`	`526`
`@@ -625,9 +625,9 @@ namespace pcpp`
`625`	`625`	`std::unique_ptr<Asn1Record> serverSaslCredentialsRecord;`
`626`	`626`	`if (!serverSaslCredentials.empty())`
`627`	`627`	`{`
`628`		`- serverSaslCredentialsRecord = std::unique_ptr<Asn1Record>(`
`629`		`- new Asn1GenericRecord(Asn1TagClass::ContextSpecific, false, serverSaslCredentialsTagType,`
`630`		`- serverSaslCredentials.data(), serverSaslCredentials.size()));`
	`628`	`+ serverSaslCredentialsRecord =`
	`629`	`+ std::make_unique<Asn1GenericRecord>(Asn1TagClass::ContextSpecific, false, serverSaslCredentialsTagType,`
	`630`	`+ serverSaslCredentials.data(), serverSaslCredentials.size());`
`631`	`631`	`additionalRecords.push_back(serverSaslCredentialsRecord.get());`
`632`	`632`	`}`
`633`	`633`
Original file line number	Diff line number	Diff line change
`@@ -198,6 +198,7 @@ namespace pcpp`
`198`	`198`	`// Initialize a DpdkDevice per port`
`199`	`199`	`for (int i = 0; i < numOfPorts; i++)`
`200`	`200`	`{`
	`201`	`+ // Not using std::make_unique because ctor of DpdkDevice is private`
`201`	`202`	`auto newDevice = std::unique_ptr<DpdkDevice>(new DpdkDevice(i, mBufPoolSizePerDevice, mBufDataSize));`
`202`	`203`	`PCPP_LOG_DEBUG("DpdkDevice #" << i << ": Name='" << newDevice->getDeviceName() << "', PCI-slot='"`
`203`	`204`	`<< newDevice->getPciAddress() << "', PMD='" << newDevice->getPMDName()`
Original file line number	Diff line number	Diff line change
`@@ -338,7 +338,7 @@ namespace pcpp`
`338`	`338`	`{`
`339`	`339`	`return false;`
`340`	`340`	`}`
`341`		`- std::unique_ptr<char[]> packetData(new char[packetSize]);`
	`341`	`+ std::unique_ptr<char[]> packetData = std::make_unique<char[]>(packetSize);`
`342`	`342`	`m_snoopFile.read(packetData.get(), packetSize);`
`343`	`343`	`if (!m_snoopFile)`
`344`	`344`	`{`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ namespace pcpp`
`68`	`68`	`return false;`
`69`	`69`	`}`
`70`	`70`
`71`		`- std::unique_ptr<bpf_program> newProg = std::unique_ptr<bpf_program>(new bpf_program);`
	`71`	`+ auto newProg = std::make_unique<bpf_program>();`
`72`	`72`	`int ret = pcap_compile(pcap.get(), newProg.get(), filter.c_str(), 1, 0);`
`73`	`73`	`if (ret < 0)`
`74`	`74`	`{`
Original file line number	Diff line number	Diff line change
`@@ -688,8 +688,8 @@ namespace pcpp`
`688`	`688`	`{`
`689`	`689`	`// Due to passing a 'this' pointer, the current device object shouldn't be relocated, while the worker is`
`690`	`690`	`// active.`
`691`		`- m_StatisticsUpdateWorker = std::unique_ptr<StatisticsUpdateWorker>(new StatisticsUpdateWorker(`
`692`		`- this, std::move(onStatsUpdate), onStatsUpdateUserCookie, intervalInSecondsToUpdateStats 1000));`
	`691`	`+ m_StatisticsUpdateWorker = std::make_unique<StatisticsUpdateWorker>(`
	`692`	`+ this, std::move(onStatsUpdate), onStatsUpdateUserCookie, intervalInSecondsToUpdateStats 1000);`
`693`	`693`
`694`	`694`	`PCPP_LOG_DEBUG("Successfully created stats thread for device '" << m_InterfaceDetails.name << "'.");`
`695`	`695`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,6 +92,7 @@ namespace pcpp`
`92`	`92`	`PCPP_LOG_DEBUG("PF_RING version is: " << m_PfRingVersion);`
`93`	`93`	`}`
`94`	`94`
	`95`	`+ // Not using std::make_unique because ctor of PfRingDevice is private`
`95`	`96`	`auto newDev = std::unique_ptr<PfRingDevice>(new PfRingDevice(currInterface->name));`
`96`	`97`	`m_DeviceList.pushBack(std::move(newDev));`
`97`	`98`	`PCPP_LOG_DEBUG("Found interface: " << currInterface->name);`