- 在容器中保存指针需要复制指针而不是它所指向的对象。复制指针通常比复制对象快。
- 在容器中保存指针可以得到多态性。存放元素基类指针的容器也可以保存其派生类型的指针。当要处理有共同基类的任意对象序列时，这种功能是非常有用的。应用这一特性的一个常见示例是展示一个含有直线、曲线和几何形状的对象序列。
- 对指针容器的内容进行排序的速度要比对对象排序快；因为只需要移动指针，不需要移动对象。
- 保存智能指针要比保存原生指针安全，因为在对象不再被引用时，自由存储区的对象会被自动删除。这样就不会产生内存泄漏。不指向任何对象的指针默认为 nullptr。
如你所知，主要有两种类型的智能指针：unique_ptr<T> 和 shared_ptr<T>，其中 unique_ptr<T> 独占它所指向对象的所有权，而 shared_ptr<T> 允许多个指针指向同一个对象。还有weak_ptr<T> 类型，它是一类从 shared_ptr<T> 生成的智能指针，可以避免使用 shared_ptrs<T> 带来的循环引用问题。unique_ptr<T> 类型的指针可以通过移动的方式保存到容器中。例如，下面的代码可以通过编译：
std::vector<std::unique_ptr<std::string>> words;
words.push_back(std::make_unique<std::string>("one"));
words.push_back(std::make_unique<std::string>("two"));
vector 保存了 unique_ptr<string> 类型的智能指针。make_unique<T>() 函数可以生成对象和智能指针，并且返回后者。因为返回结果是一个临时 unique_ptr<string> 对象，这里调用一个有右值引用参数的 push_back() 函数，因此不需要拷贝对象。另一种添加 unique_ptr 对象的方法是，先创建一个局部变量 unique_ptr ，然后使用 std::move() 将它移到容器中。然而，后面任何关于拷贝容器元素的操作都会失败，因为只能有一个 unique_ptr 对象。如果想能够复制元素，需要使用 shared_ptr 对象；否则就使用 unique_ptr 对象。
在序列容器中保存指针
下面首先解释一些在容器中使用原生指针会碰到的问题，然后再使用智能指针（这是推荐的使用方式）。下面是一段代码，用来从标准输入流读取单词，然后将指向自由存储区的字符串对象的指针保存到 vector 容器中：
std::vector<std::string*> words;
std::string word;
std::cout << "Enter words separated by spaces, enter Ctrl+Z on a separate line to end: /n";
while (true)
{
if ((std::cin >> word).eof())
{
std::cin. clear();
break;
}
words.push_back(new std::string {word});// Create object and store its address
}
push_back() 的参数表达式在自由存储区生成了一个字符串对象，因此 push_back() 的参数是一个对象的地址。可以按如下方式输出 words 中的内容：
for (auto& w : words)
std: : cout << w <<" ";
std::cout << std::endl;
如果想使用迭代器来访问容器中的元素，输出字符串的代码可以这样写：
for (auto iter = std::begin(words);iter != std::end(words); ++iter)
std::cout << **iter <<" ";
std::cout << std::endl;
iter 是一个迭代器，必须通过解引用来访问它所指向的元素。这里，容器的元素也是指针，因此必须解引用来获取 string 对象。因此表达式为：**iter。注意，在删除元素时，需要先释放它所指向的内存。如果不这样做，在删除指针后，就无法释放它所指向的内存，除非保存了指针的副本。这是容器中的原生指针常见的内存泄漏来源。下面演示它如何在 words 中发生：
for (auto iter = std::begin(words);iter != std::end(words);)
{
if (**iter == "one")
words.erase (iter); // Memory leak!
else
++iter;
}
这里删除了一个指针，但它所指向的内存仍然存在。无论什么时候删除一个是原生指针的元素，都需要首先释放它所指向的内存：
for (auto iter = std::begin(words); iter != std::end(words);)
{
if (**iter == "one")
{
delete *iter;//Release the memory...
words.erase (iter); //... then delete the pointer
}
else
++iter;
}
在离开 vector 的使用范围之前，记住要删除自由存储区的 string 对象。可以按如下方式来实现：
for (auto& w : words)
delete w; // Delete the string pointed to
words.clear(); // Delete all the elements from the vector
用索引来访问指针，这样就可以使用 delete 运算符删除 string 对象。当循环结束时，vector 中的所有指针元素都会失效，因此不要让 vector 处于这种状态。调用 dear() 移除所有元素，这样 size() 会返回 0。当然，也可以像下面这样使用迭代器：
for (auto iter = std::begin(words);iter != std::end(words); ++iter)
delete *iter;
如果保存了智能指针，就不用担心要去释放自由存储区的内存。智能指针会做这些事情。下面是一个读入字符串，然后把 shared_ptr<string> 保存到 vector 中的代码片段：
std::vector<std::shared_ptr<std::string>> words; std::string word;
std::cout << "Enter words separated by spaces, enter Ctrl+Z on a separate line to end:/n";
while (true)
{
if ((std::cin >> word).eof())
{
std::cin. clear ();
break;
}
words.push_back(std::make_shared<string>(word)); // Create smart pointer to string & store it
}
这和使用原生指针的版本没有什么不同。vector 模板现在的类型参数是 std::shared_ptr<std::string>，push_back() 的参数会调用 make_shared()，在自由存储区生成 string 对象和一个指向它的智能指针。因为智能指针由参数表达式生成，这里会调用一个右值引用参数版的 push_back() 来将指针移到容器中。
模板类型参数可能有些冗长，但是可以使用 using 来简化代码。例如：
using PString = std::shared_ptr<std::string>;
使用 using 后，可以这样定义：
std::vector<PString> words;
可以通过智能指针元素来访问字符串，这和使用原生指针相同。前面那些输出 words 内容的代码片段都可以使用智能指针。当然，不需要删除自由存储区的 string 对象；因为智能指针会做这些事情。执行 words.clear() 会移除全部的元素，因此会调用智能指针的析构函数；这也会导致智能指针释放它们所指向对象的内存。
为了阻止 vector 太频繁地分配额外内存，可以先创建 vector，然后调用 reserve() 来分配一定数量的初始内存。例如：
std::vector<std::shared_ptr<std::>>words; words.reserve(100); // Space for 100 smart pointers
这样生成 vector 比指定元素个数来生成要好，因为每一个元素都是通过调用 shared_ptr<string> 构造函数生成的。不这样做也不是什么大问题，但会产生一些不必要的额外开销，即使开销很小。通常，每个智能指针所需要的空间远小于它们所指向对象需要的空间，因此可以大方地使用 reserve() 来分配空间。
可以在外面使用保存的 shared_ptr<T> 对象的副本。如果不需要这种功能，应该使用 unique_ptr<T> 对象。下面展示如何在 words 中这样使用：
std::vector<std::unique_ptr<std::string>>words;
std::string word;
std::cout << "Enter words separated by spaces, enter Ctrl+Z on a separate line to end:/n";
while (true)
{
if ((std::cin >> word).eof())
{
std::cin.clear();
break;
}
words.push_back(std::make_unique<string>(word));
//Create smart pointer to string & store it
}
在上面的代码中，用 unique 代替 shared 是没有差别的。
我们看一下，如何使用智能指针来实现前面章节中的超市结账模拟程序。 Customer 类的定义和之前的版本相同，但是 Checkout 类的定义中使用了智能指针，因而产生了一些变化，我们也可以在 main() 中使用智能指针。在整个程序中，我们都不需要使用智能指针的副本，因此我们选择使用 unique_ptr<T>。下面是 Checkout.h 头文件中的新内容：
// Supermarket checkout - using smart pointers to customers in a queue
#ifndef CHECKOUT_H
#define CHECKOUT_H
#include <queue> // For queue container
#include <memory> // For smart pointers
#include "Customer.h"
using PCustomer = std::unique_ptr<Customer>;
class Checkout
{
private:
std::queue<PCustomer> customers; // The queue waiting to checkout
public:
void add(PCustomer&& customer) { customers.push(std::move(customer)); }
size_t qlength() const { return customers.size(); }
// Increment the time by one minute
void time_increment()
{
if (customers.front()->time_decrement().done()) // If the customer is done...
customers.pop(); // ...remove from the queue
};
bool operator<(const Checkout& other) const { return qlength() < other.qlength(); }
bool operator>(const Checkout& other) const { return qlength() < other.qlength(); }
};
#endif
我们需要直接包含 memory 头文件，这样就可以使用智能指针类型的模板。queue 容器保存 PCustomer 元素，用来记录排队结账的顾客。使用 using 为 std::unique_ptr<Customer> 定义了一个别名 PCustomer，这可以节省大量的输入。PCustomer 对象不能被复制，因而当调用 add() 函数时，它的参数是右值引用，参数会被移到容器中。以 unique 指针作为元素时，也会以同样的方式被移到容器中；当然，参数不能是 const。做了这些修改后，就可以使用 unique_ptr 了，不再需要修改其他的内容。
// Using smart pointer to simulate supermarket checkouts #include <iostream> // For standard streams #include <iomanip> // For stream manipulators #include <vector> // For vector container #include <string> // For string class #include <numeric> // For accumulate() #include <algorithm> // For min_element & max_element #include <random> // For random number generation #include <memory> // For smart pointers #include "Checkout.h" #include "Customer.h" using std::string; using distribution = std::uniform_int_distribution<>; using PCheckout = std::unique_ptr<Checkout>; // Output histogram of service times void histogram(const std::vector<int>& v, int min) { string bar (60, '*'); // Row of asterisks for bar for (size_t i {}; i < v.size(); ++i) { std::cout << std::setw(3) << i+min << " " // Service time is index + min << std::setw(4) << v[i] << " " // Output no. of occurrences << bar.substr(0, v[i]) // ...and that no. of asterisks << (v[i] > static_cast<int>(bar.size()) ? "...": "") << std::endl; } } int main() { std::random_device random_n; // Setup minimum & maximum checkout periods - times in minutes int service_t_min {2}, service_t_max {15}; std::uniform_int_distribution<> service_t_d {service_t_min, service_t_max}; // Setup minimum & maximum number of customers at store opening int min_customers {15}, max_customers {20}; distribution n_1st_customers_d {min_customers, max_customers}; // Setup minimum & maximum intervals between customer arrivals int min_arr_interval {1}, max_arr_interval {5}; distribution arrival_interval_d {min_arr_interval, max_arr_interval}; size_t n_checkouts {}; std::cout << "Enter the number of checkouts in the supermarket: "; std::cin >> n_checkouts; if(!n_checkouts) { std::cout << "Number of checkouts must be greater than 0. Setting to 1." << std::endl; n_checkouts = 1; } std::vector<PCheckout> checkouts; checkouts.reserve(n_checkouts); // Reserve memory for pointers // Create the checkouts for (size_t i {}; i < n_checkouts; ++i) checkouts.push_back(std::make_unique<Checkout>()); std::vector<int> service_times(service_t_max-service_t_min+1); // Add customers waiting when store opens int count {n_1st_customers_d(random_n)}; std::cout << "Customers waiting at store opening: " << count << std::endl; int added {}; int service_t {}; // Define comparison lambda for pointers to checkouts auto comp = [](const PCheckout& pc1, const PCheckout& pc2){ return *pc1 < *pc2; }; while (added++ < count) { service_t = service_t_d(random_n); auto iter = std::min_element(std::begin(checkouts), std::end(checkouts), comp); (*iter)->add(std::make_unique<Customer>(service_t)); ++service_times[service_t - service_t_min]; } size_t time {}; // Stores time elapsed const size_t total_time {600}; // Duration of simulation - minutes size_t longest_q {}; // Stores longest checkout queue length // Period until next customer arrives int new_cust_interval {arrival_interval_d(random_n)}; // Run store simulation for period of total_time minutes while (time < total_time) // Simulation loops over time { ++time; // Increment by 1 minute // New customer arrives when arrival interval is zero if (--new_cust_interval == 0) { service_t = service_t_d(random_n); // Random customer service time (*std::min_element(std::begin(checkouts), std::end(checkouts), comp))->add(std::make_unique<Customer>(service_t)); ++service_times[service_t - service_t_min]; // Record service time // Update record of the longest queue length for (auto& pcheckout : checkouts) longest_q = std::max(longest_q, pcheckout->qlength()); new_cust_interval = arrival_interval_d(random_n); } // Update the time in the checkouts - serving the 1st customer in each queue for (auto& pcheckout : checkouts) pcheckout->time_increment(); } std::cout << "Maximum queue length = " << longest_q << std::endl; std::cout << "/nHistogram of service times:/n"; histogram(service_times, service_t_min); std::cout << "/nTotal number of customers today: " << std::accumulate(std::begin(service_times), std::end(service_times), 0) << std::endl; }
vector 容器现在保存的是指向 Checkout 对象的 unique 指针。vector 的迭代器指向 Checkout 对象，即 unique_ptr<Checkout> 对象的指针，因而可以通过迭代器来调用 Checkout 的成员函数。首先必须解引用迭代器，然后用间接成员选择运算符来调用函数。可以看到，我们已经修改了 main() 中的相关代码。min_element() 默认使用 < 运算符来从迭代器指向的元素中获取结果。默认会比较智能指针，但是并不能得到正确的结果。我们需要为 min_element() 提供第 3 个参数作为它所使用的比较函数。这个函数是由名为 comp 的 lambda 表达式定义的。因为我们想在后面继续使用这个表达式，所以对它做命名。
为了访问 Checkout 对象，这个 lambda 表达式解引用了智能指针参数，然后使用 Checkout 类的成员函数 operator<() 来比较它们。所有的 Checkout 和 Customer 对象都是在自由储存区生成的。智能指针会维护它们所使用的内存。这个版本的模拟程序的输出和之前版本的相同。在这个示例中也可以使用 shared_ptr<T>，但是它们会执行得慢一些。就执行时间和内存使用而言， unique_ptr<T> 对象相对于原生指针的开销最小。
原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/21707.html