使用C++，仿照string类，实现myString

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

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

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

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

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

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

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

this指针

this的内涵：是类的非静态成员函数所拥有的一个隐藏的形参指针，指代该函数本身的起始地址

哪个对象使用就表示哪个对象。

this指针的形式：类名*const this；

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

this指针的使用场景：

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

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

类的大小

若类内没有内容，则默认占位符占一个字节。

类中的成员函数不占空间大小，但成员属性占用类的大小。

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

如果类中有虚函数，和虚继承自父类，则会增加一个虚指针的大小。

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

类中提供的特殊成员函数

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

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

特殊成员函数：构造函数、析构函数、拷贝构造函数、拷贝复制函数、移动构造函数、移动复值函数、取地址运算符重载

构造函数：

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

1、构造函数没有返回值

2、函数名与类同名

3、访问权限public

4、 取名方式：类名(形参列表)        {函数体内容}

 //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;
        this->age = a;
        cout<<"Stu::有参构造"<<endl;
    }


 Stu s2("zhangsan", 18);          //此时调用了有参构造

析构函数

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

1、没有返回值

2、函数名：~类名

3、权限：一般为public

4、没有参数，所以一个类中只有一个析构函数，不能进行重载

4、命名格式： ~类名（）

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

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

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

//定义析构函数
    ~Stu()
    {
        delete ptr;          //释放指针的空间
        cout<<"STU::析构函数"<<endl;
    }
 //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数

    delete ptr;       //此时会调用析构函数

仿照string类，实现myString

程序函数：

#include <iostream>
#include "myString.h"
using namespace std;

// 无参构造
myString::myString() : size(10)
{
    str = new char[size + 1]; // 确保有空字符终止
    str[0] = '\0'; // 初始化为空字符串
}

// 有参构造
myString::myString(const char *s)
{
    size = strlen(s); // 获取字符串长度
    str = new char[size + 1]; // 确保有空字符终止
    strcpy(str, s); // 将s复制给str
}

// 析构函数
myString::~myString()
{
    delete[] str;
}

// 判空函数
bool myString::my_Empty()
{
    return size == 0;
}

// size函数
int myString::My_Size()
{
    return size;
}

// c_str函数
char *myString::My_c_str()
{
    return str;
}

// at函数
char myString::at(int index)
{
    if (index >= 0 && index < size)
    {
        return str[index];
    }
    else
    {
        cout << "超出范围" << endl;
        exit(1); // 终止程序
    }
}

// 二倍扩容
void myString::doubleCapacity()
{
    char *newStr = new char[size * 2 + 1];
    strcpy(newStr, str);
    delete[] str;
    str = newStr;
    size *= 2;
}

头文件：
 

#ifndef MYSTRING_H
#define MYSTRING_H

#include <cstring>

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

public:
    // 无参构造
    myString();

    // 有参构造
    myString(const char *s);

    // 析构函数
    ~myString();

    // 判空函数
    bool my_Empty();

    // size函数
    int My_Size();

    // c_str函数
    char *My_c_str();

    // at函数
    char at(int index);

    // 二倍扩容
    void doubleCapacity();
};

#endif // MYSTRING_H

主函数：

#include <iostream>
using namespace std;
#include "myString.h"

int main()
{
    myString s1("hello world");
    cout << s1.My_Size() <<endl; // 输出: 11
    cout << s1.My_c_str() << endl; // 输出: hello world
    cout << s1.at(6) << endl; // 输出: w
    s1.~myString();//调用析构函数
    return 0;
}

完