c++的mystring类

自定义一个字符串类 mystring，成员函数仅在类的内部申明，在类的外部给出具体实现。
★成员数据：
① char s [ N ] ; 用于存放字符串的数组容器，其中 N 为常量
② int size ; 数组中最多可容纳的元素数， size = N
③ int last ; 数组中已用元素的最大下标，空串时 last = 0

头文件：

const int N = 1000;
class mystring {

    friend ostream& operator<<(ostream& os, const mystring& str);//友元函数重载<<
    friend istream& operator>>(istream& is, mystring& str);//友元函数重载>>
private:
    char s[N];        //存放字符串的数组容器
    int size;          //最大可用元素数，可防止数组出界，提高健壮性
    int last;          //已用元素最大下标
public:
    mystring();
    mystring(char* str);
    mystring(mystring& st);
    ~mystring();
    void show();
    int length();
    char& operator[](int i);

    mystring& operator=(const mystring&);
    mystring& operator=(char* st);//这里重载的=是把C风格字符串赋给mystring
    mystring operator+(mystring&);
    mystring operator+=(mystring&);
    bool operator<(mystring&);
    bool operator==(mystring&);

};

ｃｐｐ文件

mystring::mystring()
{
    last = 0;
    size = N; 
    s[last] = '\0'; 
}
mystring::mystring(char* str) 
{
    last = 0;
    size = N; 
    int len = strlen(str);
    if (len > size - 1) {
        len = size - 1;
    }
    strncpy(this->s, str, len);
    s[len] = '\0';
    last = len;
}
mystring::mystring(mystring& st)
{
    last = 0;
    size = N;
    int len = strlen(st.s);
    if (len > size - 1) {
        len = size - 1;
    }
    strncpy(this->s, st.s, len);
    s[len] = '\0';
    last = len;
}
mystring::~mystring()
{
    last = 0;
    size = N;
}

int mystring::length()
{
    return last;
}
void mystring::show() { 
    cout << s << endl;
}
char& mystring::operator[](int i)
{   //返回引用，可读可写
    //if(i>last){cout<<"access violate!";exit(1);}
    return s[i];
}
mystring& mystring::operator=(const mystring& st) {
    if (&st == this)return*this;
    last = st.last;//新的长度 
    last = 0;
    do {
        s[last] = st.s[last];
        last++;
    } while (st.s[last] != '\0' && last < size - 1);
    s[last] = '\0'; //截尾处理时，必须加串结束符
    return *this;//拷贝的临时变量生命期在调用它的表达式中
}
mystring& mystring::operator=(char* s)
{ 
    last = 0;      
    do {
        this->s[last] = s[last];
        last++;
    } while (this->s[last] != '\0' && last < size - 1);
    this->s[last] = '\0'; //截尾处理时，必须加串结束符
    return *this;
}
mystring mystring::operator+(mystring& st) {//注意+和+=的不同
    mystring temp(*this);
    temp.last = temp.last + st.last;//新的长度  
    temp.last = 0;
    do {
        temp.s[temp.last] = this->s[temp.last];
        temp.last++;
    } while (this->s[temp.last] != '\0' && temp.last < temp.size - 1);

    if (temp.last < temp.size - 1)
    {
        int i = 0;
        do {
            temp.s[temp.last] = st.s[i];
            temp.last++;
            i++;
        } while (st.s[i] != '\0' && temp.last < temp.size - 1);
    }
    temp.s[temp.last] = '\0'; //截尾处理时，必须加串结束符
    return temp; 
}
mystring mystring::operator+=(mystring& st) {//+=在对象自身进行
    mystring temp(*this);
    int i;//保存原来的长度
    last = last + st.last;//新的长度
    last = 0;
    do {
        s[last] = temp.s[last];
        last++;
    } while (temp.s[last] != '\0' && last < size - 1);
    if (last < size - 1)
    {
        i = 0;
        do {
            s[last] = st.s[i];
            i++;
            last++;
        } while (st.s[i] != '\0' && last < size - 1);
    }
    s[last] = '\0'; //截尾处理时，必须加串结束符*/
    return *this;//拷贝的临时变量生命期在调用它的表达式中
}
bool mystring::operator<(mystring& st) {   //重载<运算符
    int i = 0, k;
    do {
        k = s[i] - st.s[i];
        i++;
    } while (k == 0 && i < last && i < st.last);
    if (k < 0) return true;
    if (i == last && i != st.last) return true;
    return false;
}
bool mystring::operator==(mystring& st) {
    int i = 0, k;
    if (last != st.last) return false;
    do {
        k = s[i] - st.s[i];
        i++;
    } while (k == 0 && i < last);
    if (k != 0) return false;
    else return true;
} 


ostream& operator<<(ostream& os, const mystring& str) {
    os << str.s;
    return os;
}

istream& operator>>(istream& is, mystring& str) {
    char tem[N];  //简单的申请一块内存
    is >> tem;
    str = tem; 
    return is; 
}
 

参考GPT和自己的思路：以下是一个基本的mystring类的定义及实现：

const int N = 100;  // 容器大小

class mystring {
private:
    char s[N];   // 字符串的数组容器
    int size;    // 数组中最多可容纳的元素数， size = N
    int last;    // 数组中已用元素的最大下标，空串时 last = 0
public:
    // 构造函数
    mystring() {
        size = N;
        last = 0;
        s[last] = '\0';  // 字符串以 '\0' 结尾
    }

    // 成员函数，返回字符串长度
    int length() {
        return last;
    }

    // 成员函数，将字符串赋值为另一个字符串
    void assign(const char* str) {
        int len = strlen(str);
        if (len > size - 1) {
            len = size - 1;
        }
        strncpy(s, str, len);
        s[len] = '\0';
        last = len;
    }

    // 成员函数，返回字符串是否为空
    bool empty() {
        return last == 0;
    }

    // 成员函数，返回字符串中指定位置的字符
    char& operator[](int i) {
        return s[i];
    }

    // 成员函数，将两个字符串连接成一个新的字符串
    mystring operator+(const mystring& other) {
        mystring newstr;
        int i = 0;
        for (; i < last && i < newstr.size - 1; i++) {
            newstr.s[i] = s[i];
        }
        for (int j = 0; j < other.last && i < newstr.size - 1; i++, j++) {
            newstr.s[i] = other.s[j];
        }
        newstr.s[i] = '\0';
        newstr.last = i;
        return newstr;
    }

    // 成员函数，将两个字符串连接起来并赋值给当前字符串
    mystring& operator+=(const mystring& other) {
        *this = *this + other;
        return *this;
    }

    // 成员函数，比较两个字符串是否相等
    bool operator==(const mystring& other) {
        if (last != other.last) {
            return false;
        }
        for (int i = 0; i < last; i++) {
            if (s[i] != other.s[i]) {
                return false;
            }
        }
        return true;
    }
};

可以看到，该类定义了一些基本的字符串操作函数，如长度计算、字符串赋值、判断字符串是否为空、访问字符串中的元素、连接字符串、比较字符串是否相等等。同时，该类使用了 C++ 中的运算符重载机制，方便对字符串进行操作。
上面的代码实现了下面的功能：

字符串的数组容器，即 char s[N]，其中 N 为常量。
数组中最多可容纳的元素数，即 int size，大小为 N。
数组中已用元素的最大下标，即 int last，空串时 last = 0。在该类的构造函数中，将 last 初始化为 0，并在字符串末尾加上了一个 '\0'，即空字符，以表示字符串的结尾。
因此，上述代码完整地实现了 mystring 类中的成员数据。

参考GPT和自己的思路，下面是完整的 C++ 代码实现了字符串类 mystring：

const int N = 1000; // 字符串最大长度

class mystring {
private:
    char s[N];  // 存放字符串的数组容器
    int size;   // 数组中可容纳的元素数，size = N
    int last;   // 数组中已用元素的最大下标，空串时 last = 0
public:
    // 构造函数，创建一个空串
    mystring() {
        size = N;
        last = 0;
        s[last] = '\0'; // 字符串以 '\0' 结尾
    }

    // 构造函数，用 C 风格字符串初始化 mystring
    mystring(const char* cstr) {
        size = N;
        last = strlen(cstr);
        strncpy(s, cstr, size); // 将输入的字符串复制到 s 数组中
        s[last] = '\0';
    }

    // 成员函数，返回字符串长度
    int length() {
        return last;
    }

    // 赋值运算符重载 
    mystring& operator=(const mystring& other) {
        if (this != &other) {
            size = other.size;
            last = other.last;
            strncpy(s, other.s, size);
            s[last] = '\0';
        }
        return *this; // 返回自身引用
    }

    // 用 const 修饰表示此成员函数不改变对象本身的内部状态，称之为常成员函数
    // 成员函数，比较两个字符串是否相等
    bool isEqual(const mystring& other) const {
        if (last != other.last) {
            return false;
        }
        for (int i = 0; i < last; i++) {
            if (s[i] != other.s[i]) {
                return false;
            }
        }
        return true;
    }
};

// 重载 global 函数，将两个字符串拼接成一个新的字符串
mystring operator+(const mystring& str1, const mystring& str2) {
    mystring result;
    if ((str1.length() + str2.length()) >= result.size) {
        cerr << "Error: string too long!" << endl;
        exit(1);
    }
    int i = 0;
    for (; i < str1.length(); i++) {
        result.s[i] = str1.s[i];
    }
    for (int j = 0; j < str2.length(); j++, i++) {
        result.s[i] = str2.s[j];
    }
    result.last = i;
    result.s[i] = '\0'; // 字符串以 '\0' 结尾
    return result;    
}

这个字符串类实现了三个成员函数和一个全局函数：

1.构造函数 mystring() ：创建一个空的 mystring 对象。

2.构造函数 mystring(const char* cstr) ：使用 C 风格字符串初始化 mystring 对象。

3.成员函数 int length() ：返回字符串长度。

4.成员运算符重载 mystring& operator=(const mystring& other) ：重载了赋值运算符，支持对象之间的赋值操作，避免了内存泄漏。

5.全局函数 mystring operator+(const mystring& str1, const mystring& str2) ：重载了加法运算符，并将两个字符串连接成一个新的字符串对象。
回答不易，还请采纳！！！

该回答引用GPTᴼᴾᴱᴺᴬᴵ
以下是一个简单的mystring类的实现示例：

#include <iostream>
#include <cstring>

const int N = 100; // 字符串的最大长度

class mystring {
public:
    // 构造函数
    mystring();

    // 成员函数：获取字符串长度、判断字符串是否为空、获取指定位置的字符
    int length() const;
    bool empty() const;
    char at(int index) const;

    // 成员函数：重载+运算符，连接两个字符串
    mystring operator+(const mystring& other) const;

    // 成员函数：重载=运算符，将一个字符串赋值给另一个字符串
    mystring& operator=(const mystring& other);

    // 成员函数：重载==和!=运算符，判断两个字符串是否相等或不相等
    bool operator==(const mystring& other) const;
    bool operator!=(const mystring& other) const;

    // 成员函数：重载[]运算符，获取指定位置的字符
    char operator[](int index) const;

    // 成员函数：获取字符串数组
    char* c_str() const;

private:
    char s[N]; // 字符串的数组容器
    int size;  // 数组中最多可容纳的元素数
    int last;  // 数组中已用元素的最大下标
};

// 构造函数
mystring::mystring() {
    memset(s, 0, sizeof(s));
    size = N;
    last = 0;
}

// 成员函数：获取字符串长度
int mystring::length() const {
    return last;
}

// 成员函数：判断字符串是否为空
bool mystring::empty() const {
    return last == 0;
}

// 成员函数：获取指定位置的字符
char mystring::at(int index) const {
    if (index >= 0 && index < last) {
        return s[index];
    } else {
        return '\0';
    }
}

// 成员函数：重载+运算符，连接两个字符串
mystring mystring::operator+(const mystring& other) const {
    mystring res;
    int i = 0;
    for (; i < last; i++) {
        res.s[i] = s[i];
    }
    for (int j = 0; j < other.last; j++) {
        res.s[i + j] = other.s[j];
    }
    res.last = i + other.last;
    return res;
}

// 成员函数：重载=运算符，将一个字符串赋值给另一个字符串
mystring& mystring::operator=(const mystring& other) {
    if (this != &other) {
        memcpy(s, other.s, sizeof(s));
        size = other.size;
        last = other.last;
    }
    return *this;
}

// 成员函数：重载==运算符，判断两个字符串是否相等
bool mystring::operator==(const mystring& other) const {
    if (last != other.last) {
        return false;
    }
    for (int i = 0; i < last; i++) {
        if (s[i] != other.s[i]) {
            return false;
        }
    }
    return true;
}

// 成员函数：重载!=运算符，判断两个字符串是否不相等
bool mystring::operator!= (const mystring& other) const {
if (last != other.last) { // 长度不同，一定不相等
return true;
}
// 逐个字符比较
for (int i = 0; i <= last; i++) {
if (s[i] != other.s[i]) {
return true;
}
}
return false; // 长度相等且所有字符相等，认为相等
}

以下是使用 C++ 实现的 mystring 类，其中成员函数仅在类的内部声明，在类的外部给出具体实现

const int N = 1005;

class mystring {
private:
    char s[N];
    int size;
    int last;
public:
    void clear() {
        last = 0;
        s[last] = '\\0';
    }
    bool empty() const {
        return last == 0;
    }
    int length() const {
        return last;
    }
    char& operator[](int i) {
        return s[i];
    }
    const char& operator[](int i) const {
        return s[i];
    }
    mystring& operator=(const mystring& str) {
        last = str.last;
        for (int i = 0; i <= last; i++) {
            s[i] = str.s[i];
        }
        return *this;
    }
    mystring& operator+=(const mystring& str) {
        int len = str.last;
        for (int i = 0; i <= len; i++) {
            s[last + i] = str.s[i];
        }
        last += len;
        s[last] = '\\0';
        return *this;
    }
    friend bool operator==(const mystring& str1, const mystring& str2) {
        if (str1.last != str2.last) {
            return false;
        }
        for (int i = 0; i <= str1.last; i++) {
            if (str1.s[i] != str2.s[i]) {
                return false;
            }
        }
        return true;
    }
    friend bool operator!=(const mystring& str1, const mystring& str2) {
        return !(str1 == str2);
    }
    friend bool operator<(const mystring& str1, const mystring& str2) {
        int len = std::min(str1.last, str2.last);
        for (int i = 0; i <= len; i++) {
            if (str1.s[i] < str2.s[i]) {
                return true;
            } else if (str1.s[i] > str2.s[i]) {
                return false;
            }
        }
        return str1.last < str2.last;
    }
    friend bool operator<=(const mystring& str1, const mystring& str2) {
        return str1 < str2 || str1 == str2;
    }
    friend bool operator>(const mystring& str1, const mystring& str2) {
        return !(str1 <= str2);
    }
    friend bool operator>=(const mystring& str1, const mystring& str2) {
        return !(str1 < str2);
    }
};

其中，mystring 类具有以下成员函数：

• void clear(): 将字符串设为空串。
• bool empty() const: 判断字符串是否为空。
• int length() const: 返回字符串的长度。
• char& operator[](int i): 返回第i个字符的引用。
• const char& operator[](int i) const: 返回第i个字符的常引用。
• mystring& operator=(const mystring& str): 将字符串赋值为str。
• mystring& operator+=(const mystring& str): 将字符串加上str。
• friend bool operator==(const mystring& str1, const mystring& str2): 判断两个字符串是否相等。
• friend bool operator!=(const mystring& str1, const mystring& str2): 判断两个字符串是否不等。
• friend bool operator<(const mystring& str1, const mystring& str2): 判断字符串str1是否小于字符串str2。
• friend bool operator<=(const mystring& str1, const mystring& str2): 判断字符串str1是否小于等于字符串str2。
• friend bool operator>(const mystring& str1, const mystring& str2): 判断字符串str1是否大于字符串str2。
• friend bool operator>=(const mystring& str1, const mystring& str2): 判断字符串str1是否大于等于字符串str2。

希望这个实现能够帮助你理解如何自定义一个字符串类。

• 你可以参考下这篇文章：c++ mystring类的实现

要给出具体实现到什么目标，具备哪些功能。不然string的实现可以做到非常全面，也可以仅有基础功能。要看你的课程目的

当然可以，下面是 C++ 的完整实现：

#include <cstring>
using namespace std;

class mystring {
public:
    // 构造函数
    mystring();
    mystring(const char* s);

    // 拷贝构造函数和赋值运算符重载
    mystring(const mystring& other);
    mystring& operator=(const mystring& other);

    // 成员函数
    int length() const;
    void clear();
    bool empty() const;
    char& operator[](int index);
    const char& operator[](int index) const;
    const char* c_str() const;

private:
    // 成员变量
    static const int N = 100;  // 数组大小
    char chars[N];  // 存放字符串的数组
    int size;  // 数组容量
    int last;  // 最后一个字符的下标
};

// 构造函数
mystring::mystring() : size(N), last(0) {
    chars[0] = '\0';
}

mystring::mystring(const char* s) : size(N) {
    int len = strlen(s);
    last = min(len, N - 1);
    strncpy(chars, s, last);
    chars[last] = '\0';
}

// 拷贝构造函数和赋值运算符重载
mystring::mystring(const mystring& other) {
    strncpy(chars, other.chars, other.last + 1);
    size = other.size;
    last = other.last;
}

mystring& mystring::operator=(const mystring& other) {
    if (this != &other) {
        strncpy(chars, other.chars, other.last + 1);
        size = other.size;
        last = other.last;
    }
    return *this;
}

// 成员函数
int mystring::length() const {
    return last;
}

void mystring::clear() {
    chars[0] = '\0';
    last = 0;
}

bool mystring::empty() const {
    return last == 0;
}

char& mystring::operator[](int index) {
    return chars[index];
}

const char& mystring::operator[](int index) const {
    return chars[index];
}

const char* mystring::c_str() const {
    return chars;
}

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
自定义字符串类 MyString，包含如下成员数据和成员函数：

class MyString {
private:
    static const int N = 100;  // 字符串最大长度
    char s[N];  // 存放字符串的数组容器
    int size;   // 数组中最多可容纳的元素数，size = N
    int last;   // 数组中已用元素的最大下标，空串时 last = 0

public:
    // 构造函数
    MyString() : size(N), last(0) {}

    // 成员函数
    int length();                   // 获取字符串长度
    void clear();                   // 清空字符串
    bool empty();                   // 判断字符串是否为空
    char& operator[](int index);    // 重载下标运算符
    MyString& operator=(const MyString& other); // 重载赋值运算符
    MyString& operator+(const MyString& other); // 重载加法运算符
    void operator+=(const MyString& other);     // 重载加等运算符
    int compare(const MyString& other);         // 比较两个字符串
};

下面给出每个成员函数的具体实现：

// 获取字符串长度
int MyString::length() {
    return last;
}

// 清空字符串
void MyString::clear() {
    s[0] = '\0';    // 将第一个字符设为 '\0'，表示为空串
    last = 0;       // 已用元素的最大下标为 0
}

// 判断字符串是否为空
bool MyString::empty() {
    return last == 0;
}

// 重载下标运算符
char& MyString::operator[](int index) {
    return s[index];
}

// 重载赋值运算符
MyString& MyString::operator=(const MyString& other) {
    memcpy(s, other.s, sizeof(char) * other.last);
    last = other.last;
    return *this;
}

// 重载加法运算符
MyString& MyString::operator+(const MyString& other) {
    int new_last = last + other.last;
    char* new_s = new char[new_last];
    memcpy(new_s, s, sizeof(char) * last);
    memcpy(new_s + last, other.s, sizeof(char) * other.last);

    MyString* result = new MyString();
    result->last = new_last;
    memcpy(result->s, new_s, sizeof(char) * new_last);

    delete[] new_s;
    return *result;
}

// 重载加等运算符
void MyString::operator+=(const MyString& other) {
    int new_last = last + other.last;
    char* new_s = new char[new_last];
    memcpy(new_s, s, sizeof(char) * last);
    memcpy(new_s + last, other.s, sizeof(char) * other.last);

    memcpy(s, new_s, sizeof(char) * new_last);
    last = new_last;

    delete[] new_s;
}

// 比较两个字符串
int MyString::compare(const MyString& other) {
    int len = std::min(last, other.last);
    for (int i = 0; i < len; i++) {
        if (s[i] != other.s[i])
            return s[i] - other.s[i];
    }
    return last - other.last;
}

如果我的回答解决了您的问题，请采纳！