How do you compare and test smart pointers in STL?

由人工智能和领英社区提供技术支持

Smart pointers are a powerful feature of the Standard Template Library (STL) in C++ that help you manage memory allocation and deallocation for dynamic objects. They are objects that wrap around raw pointers and provide automatic deletion when they go out of scope or are no longer referenced. However, smart pointers are not always interchangeable, and you need to know how to compare and test them in different scenarios. In this article, you will learn how to use the main types of smart pointers in STL, how to compare them using operators and functions, and how to test them using assertions and exceptions.

此文章中的业界达人

由社区从 2 条内容中精选。了解更多

Aleksander Malinowski

Embedded Linux, RTOS and microcontroller expert, Full Professor at Bradley University, Treasurer of the IEEE Industrial…

1 Types of smart pointers

STL provides three main types of smart pointers: unique_ptr, shared_ptr, and weak_ptr. Each of them has a different ownership and lifetime semantics. A unique_ptr owns the object it points to exclusively and cannot be copied or assigned to another pointer. A shared_ptr can share ownership of the object with other shared_ptrs and uses reference counting to keep track of how many pointers are pointing to the same object. A weak_ptr does not own the object, but can observe it through a shared_ptr. It does not affect the reference count and can be used to break cycles of shared_ptrs.

添加您的观点

2 Comparison operators

You can compare smart pointers using the standard relational operators, such as ==, !=, <, >, <=, and >=. These operators compare the underlying raw pointers, not the objects they point to. For example, if you have two unique_ptrs p1 and p2 that point to different objects, p1 == p2 will return false, even if the objects have the same value. Similarly, if you have two shared_ptrs s1 and s2 that point to the same object, s1 < s2 will return false, because they have the same address. You can also compare smart pointers with null pointers using the nullptr keyword, which represents a null pointer constant. For example, if you have a weak_ptr w that is expired, w == nullptr will return true.

添加您的观点

Aleksander Malinowski

Embedded Linux, RTOS and microcontroller expert, Full Professor at Bradley University, Treasurer of the IEEE Industrial Electronics Society
举报内容
From the utilitarian perspective, it does make sense to compare using operators == and !=. While pointers are in fact unsigned integers and thus can be tested which of the numbers is higher, such operations are considered bad and unsafe programming practice by many coding standards (e.g. MISRA)

已翻译

赞

3 Comparison functions

If you want to compare the objects pointed by smart pointers, not the pointers themselves, you can use the std::equal_to, std::not_equal_to, std::less, std::greater, std::less_equal, and std::greater_equal functions from the <functional> header. These functions take two arguments and return a boolean value based on the result of applying the corresponding operator to the dereferenced arguments. For example, if you have two shared_ptrs s1 and s2 that point to different objects with the same value, std::equal_to<>()(s1, s2) will return true, because it compares *s1 and *s2. You can also use these functions with null pointers, but you need to explicitly specify the template argument as std::nullptr_t. For example, if you have a weak_ptr w that is expired, std::equal_to<std::nullptr_t>()(w, nullptr) will return true.

添加您的观点

4 Testing assertions

One way to test smart pointers is to use assertions, which are statements that check whether a condition is true or false at runtime. If the condition is false, the program terminates with an error message. You can use the assert macro from the <cassert> header to write assertions for smart pointers. For example, if you want to test whether a unique_ptr u is not null before dereferencing it, you can write assert(u != nullptr) before *u. You can also use the static_assert keyword to write assertions that are checked at compile time. For example, if you want to test whether a type T is compatible with a smart pointer type P, you can write static_assert(std::is_convertible<T*, P>::value, "T is not convertible to P").

添加您的观点

Aleksander Malinowski

Embedded Linux, RTOS and microcontroller expert, Full Professor at Bradley University, Treasurer of the IEEE Industrial Electronics Society
举报内容
assert shall be used only during the initial development and debugging. The code compiled in production (release or not debug) mode does not contain assertion statements.

已翻译

赞

5 Testing exceptions

Another way to test smart pointers is to use exceptions, which are events that indicate an abnormal or erroneous situation in the program. You can use the try-catch blocks to handle exceptions thrown by smart pointers or by the objects they point to. For example, if you want to test whether a shared_ptr s can be converted to a weak_ptr w, you can write try { w = s; } catch (std::bad_alloc& e) { std::cerr << "Allocation failed: " << e.what() << std::endl; }. You can also use the throw keyword to raise your own exceptions if a smart pointer does not meet your expectations. For example, if you want to test whether a weak_ptr w is not expired before locking it, you can write if (w.expired()) throw std::runtime_error("Weak pointer is expired");

添加您的观点