day44——面向对象特征

初夏怡情

已于 2024-08-29 22:50:28 修改

阅读量977

点赞数 28

文章标签： c++

于 2024-08-29 19:44:58 首次发布

本文链接：https://blog.csdn.net/m0_69277585/article/details/141686599

版权

一、封装

1.1 面向对象的三大特质

封装、继承、多态，如果问有四大特征，可以外加一个抽象

封装：将实现同一事物的所有的属性（成员变量）和行为（成员函数）封装到一个整体，我们称之为类（class）。类对外部信息有一个屏障作用。

1.2 C++中的类（class）

C++中的类，是由C++中的结构体演化而来的，只需要将struct改成关键字class，就定义了一个类

C++中类和结构体的区别：默认的权限不同，结构体中默认权限为public，类中默认权限为private

默认的继承方式不同，结构体的默认继承方式为public，类的默认继承方式为private

1.3 定义格式

class 类名
{
    public:
        功能的成员属性、函数
    protected：
        受保护的成员属性、函数
    private:
        私有的成员属性、函数
}；

1> 类中的成员属性和成员函数分为不同的权限

public：该权限下的成员，可以在类内、子类中、类外被访问

protected:该权限下的成员，可以在类内、子类中直接被访问，类外不允许被访问

private：该权限下的成员，只能在类内被访问，子类、类外不允许被访问

2> 如果没有指定权限，则默认为私有权限

3> 一个类中，访问权限可以出现多次，也可以出现在任意地方，一般情况下，我们将同一权限下的成员写到一个关键字下面

4> 一个访问权限的范围，是从当前关键字开始到下一个关键字或者整个类的定义结束为止

5> 一般情况下，成员属性定义成私有的，成员函数定义成公有的

6> 类的访问权限是针对于类体而言的，不是针对于类对象的

#include <iostream>
 
 
using namespace std;
 
 
//将实现人的所有属性和行为都封装到一个整体，
//后期如果需要一个人，只需要使用该类实例化对象后，通过对象为整个程序服务
class Person
{
    string skill = "C++";          //技能
 
 
public:
    string name = "zhangsan";        //姓名    功能的属性
 
 
protected:
    int pwd = 123456;           //银行卡密码
 
 
private:
    int money = 1000000;         //私房钱
 
 
public:
    void show()
    {
        cout<<"  name = "<<name<<endl;        //公共权限下的成员，类内可以直接访问
        cout<<"  pwd = "<<pwd<<endl;          //受保护权限下的成员，类内可以直接访问
        cout<<"  money = "<<money<<endl;      //私有成员，类内可以直接访问
        cout<<"  skill = "<<skill<<endl;      //默认为私有成员，类内可以直接访问
    }
 
 
};
 
 
/******************************************主程序***************************/
int main()
{
    Person p1;          //使用类定义变量的过程，称为实例化对象，p1就是Person类的一个对象
 
 
    //通过p1使用成员
    cout<<"name = "<<p1.name<<endl;          //公共权限下的成员，类外可以直接访问
    //cout<<"pwd = "<<p1.pwd<<endl;            //收保护成员，类外无法直接访问
    //cout<<"money = "<<p1.money<<endl;      //私有成员，类内可以直接访问,类外无法访问
    //cout<<"skill = "<<p1.skill<<endl;      //默认为私有成员，类内可以直接访问，类外无法访问
    p1.show();                                 //类中公共权限下的成员，类外可以直接访问
 
 
    return 0;
}

练习：

自定义一个矩形类，包含私有成员属性高（height）和宽（width），

公共成员函数：初始化宽、高函数

设置宽度函数

设置高度函数

获取宽度函数

获取高度函数

求矩形的周长（Perimeter）函数

求矩形的面积(Area)函数

#include <iostream>
 
 
using namespace std;
class rectangle
{
public:
    void init(int w, int h);       //初始化一个矩形
    bool set_width(int w);       //设置宽度
    bool set_height(int h);      //设置高度
    int get_width();          //获取宽度
    int get_height();          //获取高度
    int perimeter();           //获取周长
    int area();                 //获取面积
private:
    int width=0;             //矩形宽度
    int height=0;             //矩形高度
};
bool rectangle::set_width(int w)
{
    if(w<=0)
    {
        cout<<"提供的宽度不合法"<<endl;
        return 0;
    }
    width=w;
    return 1;
}
 
 
bool rectangle::set_height(int h)
{
    if(h<=0)
    {
        cout<<"提供的高度不合法"<<endl;
        return 0;
    }
    height=h;
    return 1;
}
 
 
int rectangle::get_width()
{
    return width;
}
 
 
int rectangle::get_height()
{
    return height;
}
 
 
int rectangle::perimeter()
{
    return 2*(height+width);
}
 
 
int rectangle::area()
{
    return height*width;
}
 
 
void rectangle::init(int w, int h)
{
    if(w<=0 || h<=0)
    {
        cout<<"初始化失败"<<endl;
    }
    width = w;
    height = h;
}
 
 
int main()
{
    //使用矩形类实例化一个矩形
    rectangle r1;            //实例化一个对象
    r1.init(3,5);          //初始化一个矩形
    cout<<r1.perimeter()<<endl;
    cout<<r1.area()<<endl;
 
 
 
 
    return 0;
}

练习：

在上面练习的基础上，写一个函数，可以比较两个矩形框是否相等

相等条件：宽==宽高==高

#include <iostream>
 
 
using namespace std;
class rectangle
{
public:
    void init(int w, int h);       //初始化一个矩形
    bool set_width(int w);       //设置宽度
    bool set_height(int h);      //设置高度
    int get_width();          //获取宽度
    int get_height();          //获取高度
    int perimeter();           //获取周长
    int area();                 //获取面积
    bool judge_rect(rectangle &r);        //定义判断两个矩形框是否相对
private:
    int width=0;             //矩形宽度
    int height=0;             //矩形高度
};
bool rectangle::set_width(int w)
{
    if(w<=0)
    {
        cout<<"提供的宽度不合法"<<endl;
        return 0;
    }
    width=w;
    return 1;
}
 
 
bool rectangle::set_height(int h)
{
    if(h<=0)
    {
        cout<<"提供的高度不合法"<<endl;
        return 0;
    }
    height=h;
    return 1;
}
 
 
int rectangle::get_width()
{
    return width;
}
 
 
int rectangle::get_height()
{
    return height;
}
 
 
int rectangle::perimeter()
{
    return 2*(height+width);
}
 
 
int rectangle::area()
{
    return height*width;
}
 
 
//判断两个矩形框是否相等，成员函数版
bool rectangle::judge_rect(rectangle &r)
{
    if(r.width==width && r.height==height)
    {
        return true;
    }
 
 
    return false;
}
 
 
void rectangle::init(int w, int h)
{
    if(w<=0 || h<=0)
    {
        cout<<"初始化失败"<<endl;
    }
    width = w;
    height = h;
}
 
 
//定义全局函数版本
bool judge_rect(rectangle &r1, rectangle &r2)
{
    //判断两个矩形是否相等
    if(r1.get_width()==r2.get_width() && r1.get_height()==r2.get_height())
    {
        return true;
    }
 
 
    return false;      //不相等
}
 
 
 
 
 
 
int main()
{
    //使用矩形类实例化一个矩形
    rectangle r1;            //实例化一个对象
    r1.init(3,5);          //初始化一个矩形
    cout<<r1.perimeter()<<endl;
    cout<<r1.area()<<endl;
 
 
    //定义第二个矩形
    rectangle r2;
    r2.init(3,6);
 
 
    //if(judge_rect(r1, r2))
    if(r1.judge_rect(r2))            //r2.judge_rect(r1)
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }
 
 
 
 
    return 0;
}

1.4 分文件编译

1> 头文件

#ifndef RECTANGLE_H
#define RECTANGLE_H
#include <iostream>
 
 
using namespace std;
 
 
 
 
//头文件中主要放：类的声明、全局函数的声明、全局变量的定义、类型重命名、宏定义
class rectangle
{
public:
    void init(int w, int h);       //初始化一个矩形
    bool set_width(int w);       //设置宽度
    bool set_height(int h);      //设置高度
    int get_width();          //获取宽度
    int get_height();          //获取高度
    int perimeter();           //获取周长
    int area();                 //获取面积
    bool judge_rect(rectangle &r);        //定义判断两个矩形框是否相对
private:
    int width=0;             //矩形宽度
    int height=0;             //矩形高度
};
 
 
 
 
bool judge_rect(rectangle &r1, rectangle &r2);        //全局函数的声明
 
 
#endif // RECTANGLE_H

2>源文件

#include"rectangle.h"
 
 
bool rectangle::set_width(int w)
{
    if(w<=0)
    {
        cout<<"提供的宽度不合法"<<endl;
        return 0;
    }
    width=w;
    return 1;
}
 
 
bool rectangle::set_height(int h)
{
    if(h<=0)
    {
        cout<<"提供的高度不合法"<<endl;
        return 0;
    }
    height=h;
    return 1;
}
 
 
int rectangle::get_width()
{
    return width;
}
 
 
int rectangle::get_height()
{
    return height;
}
 
 
int rectangle::perimeter()
{
    return 2*(height+width);
}
 
 
int rectangle::area()
{
    return height*width;
}
 
 
//判断两个矩形框是否相等，成员函数版
bool rectangle::judge_rect(rectangle &r)
{
    if(r.width==width && r.height==height)
    {
        return true;
    }
 
 
    return false;
}
 
 
void rectangle::init(int w, int h)
{
    if(w<=0 || h<=0)
    {
        cout<<"初始化失败"<<endl;
    }
    width = w;
    height = h;
}
 
 
//定义全局函数版本
bool judge_rect(rectangle &r1, rectangle &r2)
{
    //判断两个矩形是否相等
    if(r1.get_width()==r2.get_width() && r1.get_height()==r2.get_height())
    {
        return true;
    }
 
 
    return false;      //不相等
}

3> 主程序

#include"rectangle.h"
 
 
int main()
{
    //使用矩形类实例化一个矩形
    rectangle r1;            //实例化一个对象
    r1.init(3,5);          //初始化一个矩形
    cout<<r1.perimeter()<<endl;
    cout<<r1.area()<<endl;
 
 
    //定义第二个矩形
    rectangle r2;
    r2.init(3,6);
 
 
    //if(judge_rect(r1, r2))
    if(r1.judge_rect(r2))            //r2.judge_rect(r1)
    {
        cout<<"两个矩形框相等"<<endl;
    }else
    {
        cout<<"两个矩形框不相等"<<endl;
    }
 
 
 
 
    return 0;
}

1.5 this指针

1> this的内含：是类的非静态成员函数所拥有的一个隐藏的形参指针，指代该对象本身起始地址，哪个对象使用我，我就表示哪个对象

2> this指针的格式：类名 * const this;

3> 对于this指针而言，如果没有显性使用该指针，仅仅只是使用成员，那也是默认使用了this指针

3> this指针的使用场景

场景1：当成员函数的形参名和成员变量同名时，可以使用this指针进行区分

场景2：在拷贝复制函数中，需要返回自身引用时，也必须使用this指针（后面讲）

#include <iostream>
 
 
using namespace std;
class rectangle
{
public:
    void init(int width, int height);       //初始化一个矩形
 
    void show()
    {
        cout<<"width = "<<width<<"  height = "<<height<<endl;
    }
private:
    int width=0;             //矩形宽度
    int height=0;             //矩形高度
};
 
 
void rectangle::init(int width, int height)
{
    if(width<=0 || height<=0)
    {
        cout<<"初始化失败"<<endl;
    }
    this->width = width;             //可以通过this指针改变this所指向内存中的值
    this->height = height;
 
 
    cout<<"this = "<<this<<endl;
 
 
    //this = NULL;          //不能更改指针的指向
 
 
}
 
 
int main()
{
    //使用矩形类实例化一个矩形
    rectangle r1;            //实例化一个对象
    r1.init(3,5);          //初始化一个矩形
    cout<<"&r1 = "<<&r1<<endl;         //r1的地址
    r1.show();
 
    //在实例化一个对象
    rectangle r2;
    r2.init(2,2);
    cout<<"&r2 = "<<&r2<<endl;         //r2的地址
 
    return 0;
}

1.6 类的大小

1> 一个空的类的大小为1字节，用于占位使用，如果后期有成员变量的加入，则会将这一字节的空间分配出去

2> 类中的成员函数不占类的空间大小，但是成员属性会占用类的大小

3> 成员属性分配空间的大小遵循字节对齐原则

4> 如果类中有虚函数（后期讲），那么类中就会多一个虚指针的大小

5> 如果该类是虚继承（后期讲）自父类，那么该类中也会增加一个虚指针的大小

#include <iostream>
 
 
using namespace std;
 
 
class Temp
{
public:
    int num;      //整型成员变量
 
 
    void show()
    {
        cout<<"num = "<<num<<endl;
    }
 
 
    //类中有虚函数时，就会多分配一个虚指针的空间
    virtual void display()
    {
        cout<<"我是虚函数"<<endl;
    }
 
 
    virtual void display(int )
    {
        cout<<"我是虚函数"<<endl;
    }
 
 
};
 
 
int main()
{
    cout<<"sizeof(Temp) = "<<sizeof(Temp)<<endl;
 
    return 0;
}

二、类中特殊的成员函数（非常重要）

2.1 类中提供的特殊成员函数

1> 特殊的原因：如果用户不显性定义这些函数，系统也会自动提供这些函数，如果用户显性定义了这些函数，那么系统就不提供了。

无论这些特殊的成员函数，是系统提供的还是用户字节定义的，都无需用户手动调用，特殊的时机，系统会自动调用

2> 构造函数、析构函数、拷贝构造函数、拷贝复制函数、移动构造函数、移动复值函数、取地址运算符重载

2.2 构造函数

1> 功能：

使用类去实例化对象时，为对象进行资源的申请以及初始化使用的

2> 定义格式

1、构造函数没有返回值
2、函数名与类同名
3、访问权限，一般为public
4、类名(形参列表){函数体内容}

3> 调用时机：

当使用类实例化对象时，系统自动调用，无需手动调用

1、栈区空间：使用类实例化对象时，系统自动调用

类名变量名(实参)； //此时就调用的构造函数

2、堆区空间：只有在使用new申请空间时，自动调用构造函数

类名 *指针名； //此时仅仅只是定义一个指针变量，并没有为对象分配空间

指针名 = new 类名(实参); //此时调用的构造函数

#include <iostream>
 
 
using namespace std;
 
 
class Stu
{
public:
    Stu()
    {
        cout<<"Stu的构造函数"<<endl;
    }
};
 
 
 
 
int main()
{
    //在栈区申请对象空间
    Stu s1;
 
 
    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数
 
 
    return 0;
}

4> 构造函数分为有参构造和无参构造函数，有参构造函数可以为成员属性进行初始化，这些构造函数之间构成重载关系

5> 一个类中可以有多个构造函数，每个对象仅仅只会调用一个构造函数

6> 如果类中没有定义构造函数，那么，系统会自动提供一个无参构造函数，用于对对象空间的申请，如果程序员自己定义了构造函数，系统就不再提供那个无参构造了，如果还想使用无参构造，需要自己定义一个无参构造

#include <iostream>
 
 
using namespace std;
 
 
class Stu
{
private:
    string name;
    int age;
    double score;
 
 
public:
    //无参构造
    Stu()
    {
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;
        this->age = a;
        cout<<"Stu::有参构造"<<endl;
    }
 
 
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};
 
 
 
 
int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;
 
 
    //申请一个对象，调用有参构造
    Stu s2("zhangsan", 18);          //此时调用了有参构造
    s2.show();
    cout<<"**************************************"<<endl;
 
 
    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数
 
 
    return 0;
}

7> 构造函数初始化对象可以使用初始化列表完成

使用方式：类名（形参1，形参2，。。。形参n）:成员1（形参1），成员2（形参2），。。。成员n(形参n)

{函数体内容}

说明：在构造函数的小括号后，由冒号引出初始化列表，括号外时成员变量，括号内是形参

#include <iostream>
 
 
using namespace std;
 
 
class Stu
{
private:
    string name;
    int age;
    double score;
 
 
public:
    //无参构造
    Stu()
    {
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }
 
 
    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string n, int a, double s):name(n),age(a),score(s)
    {
        cout<<"Stu::有参构造2"<<endl;
    }
 
 
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};
 
 
 
 
int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;
 
 
    //申请一个对象，调用有参构造
    Stu s2("zhangsan", 18);          //此时调用了有参构造
    s2.show();
    cout<<"**************************************"<<endl;
 
 
 
 
    //申请一个对象，调用有参构造
    Stu s3("lisi", 20, 99.8);
    s3.show();
    cout<<"**************************************"<<endl;
 
 
 
 
    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数
 
 
    return 0;
}

8> 必须使用初始化列表的情况

1、当构造函数的形参名和成员变量名同名时，可以使用初始化列表来解决

2、当类中有const修饰的成员变量时，对该变量也必须进行初始化，使用初始化列表解决

3、当类中有引用成员时，对该成员的操作也必须使用初始化列表完成

4、当类中有其他类的成员子对象时，对该成员的操作也必须使用初始化列表完成，如果没有使用初始化列表调用有参构造，则系统会自动调用成员子对象的无参构造

#include <iostream>
 
 
using namespace std;
 
 
class Toy
{
public:
    Toy() {cout<<"Toy::无参构造"<<endl;}
    Toy(string n):name(n) {cout<<"Toy::有参构造"<<endl;}
 
 
private:
    string name;
 
 
};
 
 
 
 
 
 
class Stu
{
private:
    string name;
    int age;
    double score;
    const int value;        //类中有const类型的成员
    int &key;             //类中有引用成员
    Toy t;               //类中有其他类的成员子对象
 
 
public:
    //无参构造
    Stu():value(1314), key(*(new int(520))), t("hello kity")
    {
 
 
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a, int &k):value(1314), key(k)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }
 
 
    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string name, int age, double score, int &k):name(name),age(age),score(score),value(1314),key(k)
    {
        cout<<"Stu::有参构造2"<<endl;
    }
 
 
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};
 
 
int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;
 
    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数
 
    return 0;
}

2.3 析构函数

1> 功能：在对象消亡时，用于给对象回收空间使用的

2> 定义格式

1、没有返回值
2、函数名：类名前加个波浪线 ~类名
3、权限：一般为public
4、没有参数，所以，一个类中只有一个析构函数，不能进行重载
5、格式： ~类名（）

3> 调用时机：当对象的生命周期结束后，用于回收内存空间

栈区：当栈空间释放后，系统会自动调用该类的析构函数

堆区：当使用delete关键字释放对象空间时，系统自动调用

4> 如果没有手动定义析构函数，系统会提供一个析构函数，用于回收类对象的空间，如果手动定义了析构函数，那么，系统就不再提供默认的析构函数了。

#include <iostream>
 
 
using namespace std;
 
 
class Toy
{
public:
    Toy() {cout<<"Toy::无参构造"<<endl;}
    Toy(string n):name(n) {cout<<"Toy::有参构造"<<endl;}
 
 
private:
    string name;
 
 
};
 
 
 
 
 
 
class Stu
{
private:
    string name;
    int age;
    double score;
    const int value;        //类中有const类型的成员
    int &key;             //类中有引用成员
    Toy t;               //类中有其他类的成员子对象
    int *ptr;         //指针成员
 
 
public:
    //无参构造
    Stu():value(1314), key(*(new int(520))), t("hello kity"), ptr(new int(666))
    {
 
 
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a, int &k):value(1314), key(k)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }
 
 
    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string name, int age, double score, int &k):name(name),age(age),score(score),value(1314),key(k)
    {
        cout<<"Stu::有参构造2"<<endl;
    }
 
 
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
 
 
    //定义析构函数
    ~Stu()
    {
        delete ptr;          //释放指针的空间
        cout<<"STU::析构函数"<<endl;
    }
};
 
 
 
 
int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;
 
 
 
 
    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数
 
 
    //释放ptr的空间
    delete ptr;       //此时会调用析构函数
 
 
    return 0;
}

作业

仿照string类，实现myString

#include <iostream>
#include <cstring>

class myString
{
private:
    char *str;          //记录c风格的字符串
    int size;            //记录字符串的实际长度

public:
    //无参构造
    myString():size(10)
    {
        str = new char[size];         //构造出一个长度为10的字符串
        str[0] = '\0';                // 初始化为空字符串
    }

    //有参构造
    myString(const char *s)
    {
        size = strlen(s);             // 计算传入字符串的长度
        str = new char[size + 1];     // 分配足够的内存空间，加1是为了存储结束符'\0'
        strcpy(str, s);               // 复制传入的字符串到新分配的内存空间
    }

    //判空函数
    bool empty() const
    {
        return str[0] == '\0';
    }

    //size函数
    int length() const
    {
        return size;
    }

    //c_str函数
    const char* c_str() const
    {
        return str;
    }

    //at函数
    char at(int index) const
    {
        if (index >= 0 && index < size)
        {
            return str[index];
        }
        else
        {
            throw std::out_of_range("Index out of range");
        }
    }

    //二倍扩容
    void doubleCapacity()
    {
        int newSize = size * 2;
        char *newStr = new char[newSize + 1]; // 分配新的内存空间，加1是为了存储结束符'\0'
        strcpy(newStr, str);                  // 复制原字符串到新内存空间
        delete[] str;                          // 释放原内存空间
        str = newStr;                          // 更新指针指向新的内存空间
        size = newSize;                        // 更新字符串长度
    }
};

int main()
{
    myString s1;
    myString s2("Hello, world!");

    std::cout << "s1是" << (s1.empty() ? "空" : "非空") << std::endl;
    std::cout << "s2是" << (s2.empty() ? "空" : "非空") << std::endl;

    std::cout << "s1的长度：" << s1.length() << std::endl;
    std::cout << "s2的长度：" << s2.length() << std::endl;

    std::cout << "s2的内容：" << s2.c_str() << std::endl;

    std::cout << s2.at(7) << std::endl;

    return 0;
}