C++_十六章_智能指针_关于string对象、string指针和空指针的总结_关于智能指针相互赋值会导致出现空字符的问题_标准模板库

目录

1、智能指针

2、关于string对象、string指针和空指针的总结

3、关于智能指针相互赋值会导致出现空字符的问题

4、标准模板库

1、智能指针

01)在使用new为指针分配内存空间的时候，有可能会出现忘记添加delete或者是没有忘记但不执行delelte的情况 ,此时就会导致内存泄露，例如如下情况：

void remodel(std::string & str)
{
   std::string * ps = new std::string(str);
   double * pd1 = new double[8];  //new返回一个可以存储8个double行数据的地址,pd1是一个指针
   ...
   if(weird_thing())
       throw exception();  //如果执行此句,那么就有可能不执行下面的delete
   str = *ps;
   delete ps;
   return;
}

02)使用智能指针
(1)这三个智能指针模板(auto_ptr、unique_ptr和shared_ptr)都定义了类似指针的对象，可以将new获得的地址赋给这些对象。当智能指针过期时,其析构函数将使用delete
　来释放内存。下图说明了常规指针和auto_ptr之间的差别.(unique_ptr和shared_ptr的行为和auto_ptr类似)
(2)智能指针使用语法(需要包含头文件memory)：

auto_ptr<double> pd(new double); //类似于double* pd = new doouble; 只不过auto_ptr不用使用delete释放内存
auto_ptr<string> ps(new string); //类似于string* ps = new string; ps后面的new string是new返回的指针,指向新分配的内存块,作为构造函数auto_ptr<double>的参数

　其他两种智能指针也是同样的语法：

unique_ptr<double> pd(new double);
shared_ptr<string> ps(new string);

　使用智能指针修改remodel()函数后的结果：

#include <memory>
void remodel(std::string & str)
{
    std::auto_ptr<std::string> ps(new std::string(str));  //将string对象str的地址赋给pd
    ...
    if(weird_thing())
       throw exception();  //如果执行此句,那么就有可能不执行下面的delete
   str = *ps;
   return;
}

03)使用智能指针完整的一个例子：

    使用智能指针指向一个类对象，其中类对象的参数为初始化该对象时候传入类构造函数的参数(

    指针都是要指向一个对象的吧，那么对象在创建的时候肯定是包含参数的了啊，所以指针指向的内存区域也是有参数的)。

#include <iostream>
#include <string>
#include <memory>

class Report
{
private:
    std::string str;
public:
    Report(const std::string s) : str(s)
    {
        std::cout << "Object created!\n";
    }
    ~Report()
    {
        std::cout << "Object deleted!\n";
    }
    void show() const
    {
        std::cout << str << "\n";  //打印创建Report对象时设置的私有数据
    }
};

int main()
{
    /*使用代码块,这样在执行完代码块之后,在代码块中创建的所有变量都将被销毁*/
    {
        std::auto_ptr<Report> ps(new Report("using auto_ptr")); //等价于Report* ps = new Report("using auto_ptr");
        ps->show();  //Report指针Report类中的方法
    }//执行到这里后ps将会自动调用auto_ptr类的析构函数,将ps销毁并释放内存
    /*同理使用代码块*/
    {
        std::shared_ptr<Report> pd(new Report("using shared_ptr")); //ps指向数据为"using shared_ptr"的Report对象
        pd->show();
    }//执行到这里后pd将会自动调用auto_ptr类的析构函数,将ps销毁并释放内存
    /*同理使用代码块*/
    {
        std::unique_ptr<Report> pa(new Report("using unique_ptr"));  //ps指向数据为"using unique_ptr"的Report对象
        pa->show();
    }
    system("pause");
    return 0;
}

执行结果：

 注意：

std::shared_ptr<double> pd;  //创建智能指针,但不分配内存
double* p_reg = new double;  //创建普通指针p_reg，并分配内存
//pd = p_reg;  //将普通指针赋给智能指针不合法！！
pd = std::shared_ptr<double>(p_reg);  //允许,使用了显式转换
//std::shared_ptr<double> pshared = p_reg;  //不允许，因为进行了隐式转换,而shared_ptr含一个参数的构造函数使用了关键字explicit
std::shared_ptr<double> pshared(p_reg);  //允许

 04)需要注意的问题

对于三种智能指针都应该避免的是：

std::string vacation("I wandered longly as a cloud.");  //由于不是使用new创建的字符变量vacation,所以vacation是非堆变量
std::shared_ptr<string> pvac(&vacation);  //当pvac过期时,就会调用delete删除pvac指向的非堆内存,这是不允许的!!!

 2、关于string对象、string指针和string空指针的总结

std::string str00 = "可以了---陈奕迅";
std::cout << str00 << std::endl;  //这样是可以正常打印的,打印字符串可以了---陈奕迅

std::string* str0 = new std::string("可以了---陈奕迅");
std::cout << str0 << std::endl;  //这样是可以正常打印的,打印str0的地址(因为str0本身就是一个指针)
    
std::string* str1 = new std::string("可以了---陈奕迅");
std::cout << *str1 << std::endl;  //这样是可以正常打印的,打印字符串可以了---陈奕迅

std::string* str2;  //空指针
std::cout << *str2 << std::endl;  //打印空指针就会报错了,相当于下面的films[2]放弃原来对指针的控制权

3、关于智能指针相互赋值会导致出现空字符的问题

01)auto_ptr创建的智能指针拥有所有权的概念,赋值后将丢失该所有权。编译器会认为下面的第三句是错误的（书上写的是不会标红，但实际上标红了，估计是没有将下面三句放入主函数中的事情）

auto_ptr<string> ps(new string("YiYA");  //创建智能指针ps,并使ps指向字符串YiYA
auto_ptr<string> pd;  //创建智能指针,有内存但是没有指向字符串
pd = ps;  //对于auto_ptr来说，该句会导致ps成为空指针;即auto_ptr创建的智能指针拥有所有权的概念,赋值后将丢失该所有权

02)unique_ptr创建的智能指针也拥有所有权的概念，只不过unique_prt策略更严格（书上写的是：假如将上面的auto_ptr替换为unique_ptr，那么第三句是错误的,将会被标红）

03)对于shared_ptr

shared_ptr创建智能更高的指针，跟踪引用特定对象的智能指针数.这成为引用计数。例如智能指针赋值时，计数将加1，
而指向同一字符串的指针过期时，计数将减1.仅当最后一个指向同一字符串的指针过期时，才调用delete

04)对于使用auto_ptr,第三句会标红，既有好处也有坏处：

    好处：pd将接管ps的对"YiYA"的所有权，ps对该string对象的所有权将被剥夺，这是件好事，可防止ps和pd的析构函数同时删除同一个对象；

    坏处：如果随后程序将使用ps，这将是一件坏事，因为ps不再指向有效的数据。

05)对于02unique_ptr智能指针不能相互赋值的反例：unique_ptr智能指针作为函数返回值，赋值给一个unique_ptr智能指针是允许的，如下：

#include <iostream>
#include <string>
#include <memory>

using namespace std;

//假设有子函数
unique_ptr<string> demo(const char* s)  //返回值为指向string的智能指针
{
    unique_ptr<string> temp(new string(s));
    return temp;  //在demo()被执行完后,返回的temp很快被销毁,没有机会用它来访问无效数据
}

//调用程序为
int main()
{
    unique_ptr<string> ps;
    ps = demo("Uniquely special");  //这样使用两个unique_ptr指针之间相互赋值时允许的;
                                    //在demo()被执行完后,返回的temp很快被销毁,没有机会用它来访问无效数据
    cout << *ps << endl;  //打印Uniquely special

    cin.get();
    return 0;
}

总之，程序试图将一个unique_ptr赋给另一个时，如果源unique_ptr是一个临时右值，编译器允许这样做；如果源unique_ptr将存在很长一段时间，编译器将禁止这样做。编译器将允许这样做：

unique_ptr<string> pu1(new string("Hi ho!"));
unique_ptr<string> pu2;
pu2 = pu1;  //不允许，因为pu1将存在很长一段时间
unique_ptr<string> pu3;
pu3 = unique_ptr<string>(new string("Yo!"));  //允许！string("Yo!")将返回一个临时string对象,之后将很快被销毁

但是如果确实想使用上面代码中的第三句，可以使用std::move()，即将上面的第三句改为：

ps2 = std::move(ps1);

下面程序中第十八行出现了智能指针相互赋值从而导致films[2]成为空指针，打印空指针进而会报错

#include <iostream>
#include <string>
#include <memory>

int main()
{
    using namespace std;
    /*创建一个数组films,数组内包含五个指针*/
    auto_ptr<string> films[5] =
    {
        auto_ptr<string> (new string("Fowl Balls")),  //可以没有变量的名字;注意最后一个是逗号而不是分号
        auto_ptr<string> (new string("Duck Walks")),
        auto_ptr<string> (new string("Chicken Runs")),
        auto_ptr<string> (new string("Turkey Errors")),
        auto_ptr<string> (new string("Goose Eggs"))
    };
    auto_ptr<string> pwin;  //创建一个指向string对象的智能指针对象
    //pwin = films[2];  //这一句将导致films[2]不再引用该字符串,从而fimls[2]变成了一个空指针，在打印*films[2]的是时候程序会出现意外
    cout << "The nominess for best avin baseball film are:\n";
    for (int i = 0; i < 5; i++)
        cout << *films[i] << endl;
    //cout << "The winner is " << *pwin << "!\n";
    cin.get();//输入任意字符后终止程序
    return 0;
}

 但是将以上的所有auto_ptr替换为shared_ptr，上述程序将不会报错，正常执行。

06)智能指针的选择

（1）如果程序要使用多个指向同一对象的之恩，应选择shared_ptr。这样的情况包括：有一个指针数组，并使用一些辅助指针来标记特定的元素；两个对象包含都指向第三个对象的指针；STL容器包含指针。

（2）如果程序不需要多个指向同一个对象的指针，则课使用unique_ptr。可将unique_ptr存储到StL容器中，只要不调用将一个unique_ptr复制或赋给另一个的方法或算法

#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <algorithm>  //for for_each()

using namespace std;

/*创建返回值为unique_ptr智能指针的子函数make_int()*/
unique_ptr<int> make_int(int n)
{
    return unique_ptr<int>(new int(n));  
}

/*显示unique_ptr指针指向的内容的子函数*/
void show(unique_ptr<int> & pi)
{
    cout << *pi << endl;
}

int main()
{
    //vector<typeName> vt(n_elem);//创建一个vector对象vt,可以存储n_elem个类型为typeName的元素
    vector<unique_ptr<int>> vp(8); //创建可以存储8个指向int型数据智能指针的vector对象vp
    for (int i = 0; i < vp.size(); i++)
        vp[i] = make_int(rand() % 1000); //使用子函数make_int()对vector对象vp填充数据
    vp.push_back(make_int(rand() % 1000)); //将make_int()子函数返回的unique_ptr智能指针填充到vector对象vp的尾部
    for_each(vp.begin(), vp.end(), show);
}

对于for_each()函数：

for_each(_InputIterator __first, _InputIterator __last, _Function __f)
/**
*  @brief Apply a function to every element of a sequence.
*  @ingroup non_mutating_algorithms
*  @param  __first  An input iterator. 循环开始迭代器
*  @param  __last   An input iterator. 循环结尾迭代器
*  @param  __f      A unary function object. 处理函数
*  @return   @p __f (std::move(@p __f) in C++0x).
*
*  Applies the function object @p __f to each element in the range
*  @p [first,last).  @p __f must not modify the order of the sequence.
*  If @p __f has a return value it is ignored.
*/

 for_each()参考博客：https://blog.csdn.net/raozhufa/article/details/99741195

 执行结果：

 07)可以将unique_ptr指针赋值给shared_ptr，但是反过来是不可以的，如：

unique_ptr<int> pup(make_int(rand() % 1000)); //make_int()返回的unique_int指针作为参数
shared_ptr<int> spp(pup);  //不允许，虽然也是将unique_ptr指针赋值给shared_ptr
shared_ptr<int> spr(make_int(rand() % 1000));  //允许

 4、标准模板库

01)STL提供了一组表示容器、迭代器、函数对象和算法的模板。容器时一个与数组类似的单元，可以存储若干个类型相同的值；
     迭代器能够用来遍历容器，与能够遍历数组的指针类似，是广义指针；函数对象时类似于函数的对象，可以是类对象或函数指针,
     其中函数指针包括函数名，因为函数名被用作指针。
02)以下代码为创建vector容器对象：

#include <vector>
using std::vector;
vector<int> ratings(5);  //创建一个包含5个int型数据的vector对象ratings,注意这里使用的是小括号！！而vector<int> ratings[5]是创建五个vector数组(或创建5个vector对象ratings[1]表示第一个vector对象)
for(int i=0;i<5;i++)
{
    std::cout << ratings[i] << std::endl; //运算符[]被重载,可以使用通常的数组表示方法来访问各个元素
}

01)迭代器：它是一个广义指针。事实上，它可以是指针，也可以是一个可对其执行类似指针的操作(如接触引用和递增)的对象。
     要为vector的double类型声明一个迭代器，可以这样做：

vector<double>::iterator pd;  //pd是一个迭代器,pd指向类型为double的vector容器

     假设scores是一个vector<double>对象:

vector<double> scores;

     则可以使用迭代器pd执行如下操作：

pd = scores.begin();  //使pd指向scores中的第一个元素
*pd = 23.3;  //对pd解除引用，并对scores中的第一个元素赋值;
++pd;  //使pd指向scores中的下一个元素

02)auto替代vector<double>::iterator
     可以这样做：

vector<double>::iterator pd = scores.begin();

     也可以这样做：

auto pd = scores.begin();

03)end()函数
该函数返回一个超越结尾的迭代器。超越结尾的迭代器，是指向容器最后一个元素后面那个元素的迭代器。与c风格字符串最后一个字符后面的
类似，只是空字符是一个值，而“超越结尾的迭代器”是一个指向元素的指针(迭代器)。因此遍历scores容器中的元素可以使用如下方法：

vector<double>::iterator pd;
vector<double> scores;

for(pd = scores.begin(); pd != scores.end(); pd++)
     cout << *pd << endl;

04)push_back()函数
该函数将元素添加到矢量(容器)末尾。无需了解元素的数目，只要能够取得足够的内存，程序就可以根据需要增加容器的长度，如：

vector<double> scores;
double temp;
while(cin>>temp && temp >= 0)
    scores.push_back(temp);  //将temp添加到scores容器尾
cout << "You entered " << scores.size() << " scores.\n";

05)erase()
该函数删除矢量(容器)指定区间的元素。它接受两个迭代器参数，这些参数定义了要删除的区间。例如:

scores.erase(scores.begin(), scores.begin()+2);  //删除scores中第一个和第二个元素

06)inser()
该方法接受三个迭代器参数，第一个参数指定了新元素的插入位置，第二个和第三个定义了被插入的区间，该区间通常是另一个容器对象的一部分

vector<double> old_v;  //创建一个指向double的vector对象old_v
vector<double> new_v;  //创建一个指向double的vector对象new_v
old_v.inset(old_v.begin(), new_v.begin()+1, new_v.end());  //将new_v中除第一个元素外的所有元素插入到old_v中，插入第一个位置为old_v第一个位置

07)for_each()
该函数接受三个参数。前两个是定义容器中(要显示或者是其他操作的)区间的迭代器,最后是一个指向函数的指针，
该函数指出了要对这个区间的数据做的操作，如下示例：
可以将代码：

truct Review{
    std::string title;
    int rating;
};  //定义一个结构体
vector<Review> books;  //创建一个指向Review的vector对象books
vector<Review>::iterator pr;  //pr是一个迭代器,pr指向类型为double的vector容器
for(pr = books.begin(); pr != books.end(); pr++)
    ShowReview(*pr);  //显式books容器中的内容

替换为：

struct Review{
    std::string title;
    int rating;
};  //定义一个结构体
vector<Review> books;  //创建一个指向Review的vector对象books
vector<Review>::iterator pr;  //pr是一个迭代器,pr指向类型为double的vector容器
for_each(books.begin(),books.end(),ShowReview);

 08)基于范围的for循环

(01)第五章的示例：

double prices[5] = {4.99,2.32,5.65,4.56,9.68};
      cout << x <<endl;

(02)第十六章的示例：

for_each(books.begin(), books.end(), ShowReivew); //其中books为vector对象,ShowReview为一个子函数
//可替换为：
for(auto x : books)  //根据books的类型(vector<Review>),编译器会判断出x的类型为Review
    ShowReview(x);

但是基于范围的for循环可以修改容器中的内容，诀窍是使用一个引用参数，如下所示：

void InflatReview(Review & r)  //其中Review为一个结构，包括int型数据rating
{
    r.rating++;
}
for(auto & x : books) 
    InflatReview(x);

 09)关于vector对象

vector<int> ratings(5);  //创建一个包含5个int型数据的vector对象ratings,注意这里使用的是小括号！！
vector<int> ratings[5]  //是创建五个vector数组(或创建5个vector对象ratings[1]表示第一个vector对象)
vector<int> a[10];  //a是一个向量数组
vector<int> b(10);  //b是一个向量
vector<vector<int>> c;  //c是一个响亮
vector<vector<int>,10> d;  //d是一个向量数组