怎么利用C++实现Mystring类

作者：beitianmolang | 来源：互联网 | 2023-09-15 13:04

这篇文章主要介绍“怎么利用C++实现Mystring类”，在日常操作中，相信很多人在怎么利用C++实现Mystring类问题上存在疑惑，小编查阅了各式资料，整

这篇文章主要介绍“怎么利用C++实现Mystring类”，在日常操作中，相信很多人在怎么利用C++实现Mystring类问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”怎么利用C++实现Mystring类”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

功能实现

<基本功能>

1> 实现头文件的封装：MyString.h

2> 缺省构造函数对字符串的初始化（ MyString() ）

3> 使用构造函数初始化字符串的另外两种方式 * 2（动态指针+拷贝构造函数）

4> 析构函数（释放动态申请的字符串空间）

5> 重载输出运算符（ <<）

6> 重载赋值运算符 * 2（ = ）

7> 重载下标运算符（ []，索引输出）

<拓展功能>

1> 字符串长度的比较

2> 字符串的排序功能

3> 字符串的倒置

4> 字符串中指定两个字符的交换

5> 查找某字符串是否位于指定的字符串中(采用暴力查找)

<细节修改>

1> 使用自定义函数来替换strlen()和strcpy()

一：基本功能 (实现源码)

1) MyString.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
 
#include 
#include     //会借用strlen与strcpy函数实现相应的功能
using namespace std;
 
class MyString {
public:
    MyString();
    MyString(const char *const);
    MyString(const MyString &);
    ~MyString();
    int length()const;    //const函数不能修改其数据成员,仅仅起到输出数据的作用
    int size() const;    //和length功能一致
    const char * getString() const;    //直接调用字符串首指针返回
    friend ostream & operator << (ostream &, const MyString &);    //重载输出运算符
    MyString & operator = (const MyString &);
    MyString & operator = (const char *    );
    char & operator [] (const int index);
 
private:
    char * str;    //指向数组首地址(此时为野指针)
    int len;
 
};

2）MyString.cpp

#include "MyString.h"
using namespace std;
 
MyString::MyString()    //构造空字符串
{
    str = new char[1];
    str[0] = &＃39;\0&＃39;;
    len = 0;
}
 
MyString::MyString(const char * const P)    //按照动态指针来构造相应的字符串
{
    if (P)
    {
        len = strlen(P);    //取长度
        str = new char[len + 1];    //开空间
        strcpy(str, P);    //复制值
    }
    else
    {
        MyString();    //如果传入的字符串为空，直接调用缺省值构造函数
    }
}
 
MyString::MyString(const MyString & AnotherMyString)  //拷贝构造函数，这里的形参使用了const，该形参类中的所有函数都要使用const来修饰
{
    len = AnotherMyString.length();
    str = new char[len + 1];
    strcpy(str, AnotherMyString.str);
}
 
int MyString::length() const   //求长度成员函数
{
    return len;
}
 
int MyString::size() const
{
    return len;
}
 
const char * MyString::getString()const
{
    return str;
}
 
MyString & MyString::operator=(const MyString &AnotherMyString)
{
    if (&AnotherMyString == this)
    {
        return *this;
    }
    delete[] str;
    len = AnotherMyString.length();
    str = new char[len + 1];
    strcpy(str, AnotherMyString.str);
    return *this;
    // TODO: 在此处插入 return 语句
}
 
MyString & MyString::operator=(const char * P)
{
    delete[] str;
    len = strlen(P);
    str = new char[len + 1];
    strcpy(str, P);
    return *this;
    // TODO: 在此处插入 return 语句
}
 
char & MyString::operator[](const int index)
{
    if (index > len)    //如果索引越界，输出最后一个字符
    {
        cout << "Warning!!!" << endl;
        cout << "Out of boundary! The last char is: ";
        return str[len - 1];
    }
    else
    {
        return str[index-1];
    }
    // TODO: 在此处插入 return 语句
}
 
MyString::~MyString()    //释放数组空间
{
    delete[] str;
    len = 0;
}
 
ostream & operator << (ostream & output, const MyString & str)    //重载输出运算符
{
    output << str.getString();
    return output;
    // TODO: 在此处插入 return 语句
}

这里需要提到的一点是析构函数中的delete[] str;

怎么利用C++实现Mystring类

使用new得来的空间使用delete释放；使用new[]得来的空间使用delete[]释放；这是永远不会错的。

但是更加深入一点去理解：

使用new[]得到的空间如果动态申请的数据类型时基本数据类型也可以使用delete直接释放，但是如果使用new[]申请的数据的类型时自定义类型（例如类名），这就必须使用delete[]来进行释放，只有这样才能够调用自定义类型的析构函数进行对自定义类型进行释放。

除此之外，再提一点关于delete[]的注意事项：

当使用new[]动态生成内存的时候，删除的时候必须将删除的指针指向new[]出来的内存的首地址：

#include 
using namespace std;
 
int main()
{
    int *p = new int[3];
    *p = 1;
    p++;
    *p = 2;
    delete[]p;
    cout << "*" << endl;
    return 0;
}

这一段小程序中：

因为p指针不是指向了首地址，所以程序虽然没报错，但是无法正常运行！我们可以将申请的首地址保存起来，供删除的时候使用。

3）test_main.cpp

#include "MyString.h"
using namespace std;
 
int main()
{
    MyString a;
    cout << "【调用缺省构造函数实现初始化】" << endl;
    cout << "string a = " << a << endl;
    cout << "Length = " << a.length() << endl << endl;
 
    MyString b("123456");
    cout << "【调用普通构造函数实现初始化】" << endl;
    cout << "string b = " << b << endl;
    cout << "Length = " << b.length() << endl << endl;
 
    MyString c(b);
    cout << "【调用拷贝构造函数实现初始化】" << endl;
    cout << "string c = " << c << endl;
    cout << "Length = " << c.length() << endl << endl;
 
    MyString d = b;    //这里不会再次调用缺省构造函数进行初始化
    cout << "【调用 =(对象) 实现赋值】" << endl;
    cout << "string d = " << d << endl;
    cout << "Length = " << d.length() << endl << endl;
 
    MyString e = "00000000";
    cout << "【调用 =(动态指针) 实现赋值】" << endl;
    cout << "string d = " << e << endl;
    cout << "Length = " << e.length() << endl << endl;
 
    MyString f = "abcdefghijklmn";
    char str = f[5];
    cout << "【调用 []  实现索引定位输出】" << endl;
    cout << "f[5] = " << str << endl << endl;
 
    return 0;
}

二：拓展功能

字符串长度的比较

使用/>=/<=等符号进行比较，返回bool值

bool operator >(const MyString &str);
bool operator >(const char * c_str);
bool operator <(const MyString &str);
bool operator <(const char * c_str);
bool operator >=(const MyString &str);
bool operator >=(const char * c_str);
bool operator <=(const MyString &str);
bool operator <=(const char * c_str);

字符串的排序功能

使用类中的成员函数对类中的私有字符串进行从小到大的排序：

A.Sort_String_LB();
A.Sort_String_BL();

字符串的倒置

使用类中的成员函数对类中的私有字符串进行倒置：

A.Reverse();

字符串中指定两个字符的交换

A.ChangeTwoCharPosition(int firstposition,int second position);

查找某字符串是否位于指定的字符串中(采用暴力查找)

A.Find(char *search_string);

完整版源码

MyString.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
 
#include 
#include     //会借用strlen与strcpy函数实现相应的功能
using namespace std;
 
class MyString {
public:
    //构造函数+析构函数
    MyString();
    MyString(const char *const);
    MyString(const MyString &);
    ~MyString();
 
    //直接调用字符串首指针返回，返回的指针可以直接使用cout<<输出
    const char * getString() const;    
 
    //求字符串的长度(直接返回类中的私有成员len的值)
    //const函数不能修改其数据成员,仅仅起到输出数据的作用
    int length()const;    
    int size() const;   
 
    //重载赋值运算符，使得可以使用对象与"xxxxxx"来赋值
    MyString & operator = (const MyString &);
    MyString & operator = (const char *    );
 
    //重载下标运算符
    char & operator [] (const int index);
 
    //重载输出运算符
    friend ostream & operator << (ostream &, const MyString &);    
 
    //字符串长度比较
    bool operator >(const MyString &str);
    bool operator >(const char * c_str);
    bool operator <(const MyString &str);
    bool operator <(const char * c_str);
    bool operator >=(const MyString &str);
    bool operator >=(const char * c_str);
    bool operator <=(const MyString &str);
    bool operator <=(const char * c_str);
 
    //字符串内部内容的冒泡排序(ASCII码),Little->Big
    void Sort_String_LB();
    void Sort_String_BL();
 
    //对字符串进行倒置
    void Reverse();
 
    //交换字符串中两个字符的位置
    void ChangeTwoCharPosition(int firstposition, int secondposition);
 
    //查询某字符串是否是指定字符串的子串(暴力模式)
    bool Find(char *search_string);
 
private:
    char * str;    //指向数组首地址(此时为野指针)
    int len;    //字符串的长度
 
};

MyString.cpp

#include "MyString.h"
using namespace std;
 
MyString::MyString()    //构造空字符串
{
    str = new char[1];
    str[0] = &＃39;\0&＃39;;
    len = 0;
}
 
MyString::MyString(const char * const P)    //按照动态指针来构造相应的字符串
{
    if (P)
    {
        len = strlen(P);    //取长度
        str = new char[len + 1];    //开空间
        strcpy(str, P);    //复制值
    }
    else
    {
        MyString();    //如果传入的字符串为空，直接调用缺省值构造函数
    }
}
 
MyString::MyString(const MyString & AnotherMyString)  //拷贝构造函数，这里的形参使用了const，该形参类中的所有函数都要使用const来修饰
{
    len = AnotherMyString.length();
    str = new char[len + 1];
    strcpy(str, AnotherMyString.str);
}
 
int MyString::length() const   //求长度成员函数
{
    return len;
}
 
int MyString::size() const
{
    return len;
}
 
const char * MyString::getString()const
{
    return str;
}
 
MyString & MyString::operator=(const MyString &AnotherMyString)
{
    if (&AnotherMyString == this)
    {
        return *this;
    }
    //delete[] str;
    len = AnotherMyString.length();
    str = new char[len + 1];
    strcpy(str, AnotherMyString.str);
    return *this;
    // TODO: 在此处插入 return 语句
}
 
MyString & MyString::operator=(const char * P)
{
    //delete[] str;
    len = strlen(P);
    str = new char[len + 1];
    strcpy(str, P);
    return *this;
    // TODO: 在此处插入 return 语句
}
 
char & MyString::operator[](const int index)
{
    if (index > len)    //如果索引越界，输出最后一个字符
    {
        cout << "Warning!!!" << endl;
        cout << "Out of boundary! The last char is: ";
        return str[len - 1];
    }
    else
    {
        return str[index-1];
    }
    // TODO: 在此处插入 return 语句
}
 
bool MyString::operator>(const MyString & str)
{
    if (this->len > str.len)
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator>(const char * c_str)
{
    if (this->len > int (strlen(c_str)))
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator<(const MyString & str)
{
    if (this->len < str.len)
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator<(const char * c_str)
{
    if (this->len < int(strlen(c_str)))
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator>=(const MyString & str)
{
    if (this->len > str.len)
    {
        return true;
    }
    else if (this->len = str.len)
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator>=(const char * c_str)
{
    if (this->len > int(strlen(c_str)))
    {
        return true;
    }
    else if (this->len = strlen(c_str))
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator<=(const MyString & str)
{
    if (this->len < str.len)
    {
        return true;
    }
    else if (this->len = str.len)
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
bool MyString::operator<=(const char * c_str)
{
    if (this->len > int (strlen(c_str)))
    {
        return true;
    }
    else if (this->len = strlen(c_str))
    {
        return true;
    }
    else
    {
        return false;
    }
    return false;
}
 
void MyString::Sort_String_LB()
{
    int length = this->len;
    char temp_data;
    char *c_str = this->str;
    bool ischanged = false;
    for (int i = length-1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (c_str[j] > c_str[j + 1])
            {
                temp_data = c_str[j];
                c_str[j] = c_str[j + 1];
                c_str[j + 1] = temp_data;
                ischanged = true;
            }
        }
        if (!ischanged)
        {
            return;
        }
    }
}
 
void MyString::Sort_String_BL()
{
    int length = this->len;
    char temp_data;
    char *c_str = this->str;
    bool ischanged = false;
    for (int i = length - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (c_str[j] < c_str[j + 1])
            {
                temp_data = c_str[j];
                c_str[j] = c_str[j + 1];
                c_str[j + 1] = temp_data;
                ischanged = true;
            }
        }
        if (!ischanged)
        {
            return;
        }
    }
}
 
void MyString::Reverse()
{
    int length = this->len;
    char *c_str = this->str;
    char temp_data;
    for (int i = 0; i < length/2; i++)
    {
        temp_data = c_str[i];
        c_str[i] = c_str[length-1-i];
        c_str[length-1-i] = temp_data;
    }
}
 
void MyString::ChangeTwoCharPosition(int firstposition, int secondposition)
{
    int length = this->len;
    char *c_str = this->str;
    char temp_data;
    if (firstposition > len || secondposition > len)
    {
        cout << "输入下标越界，数组实际长度为： " << length << endl;
        return;
    }
    else
    {
        temp_data = c_str[firstposition-1];
        c_str[firstposition-1] = c_str[secondposition-1];
        c_str[secondposition-1] = temp_data;
    }
}
 
bool MyString::Find(char * search_string)   
{
    int length = this->len;
    char *c_str = this->str;
    bool judge = false;
    //确保i每次可以往后移动一位
    int temp_data=0;
 
    for (int i = 0,j=0; j < strlen(search_string)&&iTest_Possess.cpp
#include "MyString.h"
using namespace std;
 
int main()
{
    MyString a;
    cout << "【调用缺省构造函数实现初始化】" << endl;
    cout << "string a = " << a << endl;
    cout << "Length = " << a.length() << endl << endl;
 
    MyString b("123456");
    cout << "【调用普通构造函数实现初始化】" << endl;
    cout << "string b = " << b << endl;
    cout << "Length = " << b.length() << endl << endl;
 
    MyString c(b);
    cout << "【调用拷贝构造函数实现初始化】" << endl;
    cout << "string c = " << c << endl;
    cout << "Length = " << c.length() << endl << endl;
 
    MyString d = b;    //这里不会再次调用缺省构造函数进行初始化
    cout << "【调用 =(对象) 实现赋值】" << endl;
    cout << "string d = " << d << endl;
    cout << "Length = " << d.length() << endl << endl;
 
    MyString e = "00000000";
    cout << "【调用 =(动态指针) 实现赋值】" << endl;
    cout << "string d = " << e << endl;
    cout << "Length = " << e.length() << endl << endl;
 
    MyString f = "abcdefghijklmn";
    char str = f[5];
    cout << "【调用 []  实现索引定位输出】" << endl;
    cout << "f[5] = " << str << endl << endl;
 
    //测试字符串的大小比较功能
    MyString A1 = "123456789";
    MyString B1 = "4321";
    MyString C1 = "456";
    MyString D1 = "456789";
    if (A1 >= B1)
    {
        cout << "A1>=B1" << endl;
    }
    else
    {
        cout << "A1三：细节部分修改
本次更新了 "取消了strlen()与strcpy()的使用，在间接调用该接口的自定义函数中，使用自定义方法实现这两个接口的功能" 
这里仅仅给出了替换部分部分示例，其他部分也可按照相同原理替换：
1.使用指针实例化对象部分
MyString::MyString(char * P)    //按照动态指针来构造相应的字符串
{
    char * temp_P = P;   //使得指针指向的内存重置
    if (P)
    {
        int xx_length = 0;
        while (*P != &＃39;\0&＃39;)
        {
            xx_length++;
            P = P + sizeof(char);
        }
        len = xx_length;
        P = temp_P;
        //len = strlen(P);    //取长度
        str = new char[len + 1];    //开空间
        strcpy(str, P);    //复制值
    }
    else
    {
        MyString();    //如果传入的字符串为空，直接调用缺省值构造函数
    }
}
2.重载 "=" 运算符函数的过程
MyString & MyString::operator=(char * P)
{
    //delete[] str;
    char *temp_P = P;
    int xx_length = 0;
    char temp = &＃39;0&＃39;;
    while (*P != &＃39;\0&＃39;)
    {
        xx_length++;
        P = P + sizeof(char);
    }
    //len = strlen(P);
    len = xx_length;
    P = temp_P;
    str = new char[len + 1];
    for (int i = 0; i < len; i++)
    {
        *str = *P;
        str += sizeof(char);
        P += sizeof(char);
    }
    //strcpy(str, P);
    return *this;
    // TODO: 在此处插入 return 语句
}
（ 附加：对于自定义的类，需要尽量减少对其他头文件的需求。）
到此，关于“怎么利用C++实现Mystring类”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程笔记网站，小编会继续努力为大家带来更多实用的文章！

推荐阅读

char
C++ 从文件中逐行读取结构体数据，并将其存储到向量中，最终输出至控制台和新文件

在C++程序中，文档A的每一行包含一个结构体数据，其中某些字段可能包含不同数量的数字。需要将这些结构体数据逐行读取并存储到向量中，随后不仅在控制台上显示，还要输出到新创建的文档B中。希望得到指导，感谢！ ... [详细]

蜡笔小新 2024-11-09 18:40:33
char
在 QQmlPropertyMap 的派生类中无法调用槽函数或 Q_INVOKABLE 方法？

在尝试对 QQmlPropertyMap 类进行测试驱动开发时，发现其派生类中无法正常调用槽函数或 Q_INVOKABLE 方法。这可能是由于 QQmlPropertyMap 的内部实现机制导致的，需要进一步研究以找到解决方案。 ... [详细]

蜡笔小新 2024-11-11 15:34:22
version
如何将TS文件转换为M3U8直播流：HLS与M3U8格式详解

在视频传输领域，MP4虽然常见，但在直播场景中直接使用MP4格式存在诸多问题。例如，MP4文件的头部信息（如ftyp、moov）较大，导致初始加载时间较长，影响用户体验。相比之下，HLS（HTTP Live Streaming）协议及其M3U8格式更具优势。HLS通过将视频切分成多个小片段，并生成一个M3U8播放列表文件，实现低延迟和高稳定性。本文详细介绍了如何将TS文件转换为M3U8直播流，包括技术原理和具体操作步骤，帮助读者更好地理解和应用这一技术。 ... [详细]

蜡笔小新 2024-11-11 12:12:04
input
面试中如何回答“零拷贝”技术问题？

零拷贝技术是提高I/O性能的重要手段，常用于Java NIO、Netty、Kafka等框架中。本文将详细解析零拷贝技术的原理及其应用。 ... [详细]

蜡笔小新 2024-11-13 02:03:52
char
c/c++常用代码doc,ppt,xls文件格式转PDF格式[转]

[转]doc,ppt,xls文件格式转PDF格式http:blog.csdn.netlee353086articledetails7920355确实好用。需要注意的是#import ... [详细]

蜡笔小新 2024-11-12 16:19:40
version
Python 使用 DOM 和 SAX 解析 XML 的应用实例

本文介绍如何使用 Python 的 DOM 和 SAX 方法解析 XML 文件，并通过示例展示了如何动态创建数据库表和处理大量数据的实时插入。 ... [详细]

蜡笔小新 2024-11-12 16:10:39
char
字节流(InputStream和OutputStream)，字节流读写文件，字节流的缓冲区，字节缓冲流

字节流抽象类InputStream和OutputStream是字节流的顶级父类所有的字节输入流都继承自InputStream，所有的输出流都继承子OutputStreamInput ... [详细]

蜡笔小新 2024-11-12 14:07:25
version
Xcode 多项目联合调试技巧与实践

在软件开发过程中，经常需要将多个项目或模块进行集成和调试，尤其是当项目依赖于第三方开源库（如Cordova、CocoaPods）时。本文介绍了如何在Xcode中高效地进行多项目联合调试，分享了一些实用的技巧和最佳实践，帮助开发者解决常见的调试难题，提高开发效率。 ... [详细]

蜡笔小新 2024-11-11 18:24:27
char
Android 源代码解析系列（一）：init.c 文件详解

本文详细解析了 Android 系统启动过程中的核心文件 `init.c`，探讨了其在系统初始化阶段的关键作用。通过对 `init.c` 的源代码进行深入分析，揭示了其如何管理进程、解析配置文件以及执行系统启动脚本。此外，文章还介绍了 `init` 进程的生命周期及其与内核的交互方式，为开发者提供了深入了解 Android 启动机制的宝贵资料。 ... [详细]

蜡笔小新 2024-11-10 00:35:48
char
AOJ.863 分配书籍问题（深度优先搜索算法）

题目解析给定 n 个人和 n 种书籍，每个人都有一个包含自己喜好的书籍列表。目标是计算出满足以下条件的分配方案数量：1. 每个人都必须获得他们喜欢的书籍；2. 每本书只能分配给一个人。通过使用深度优先搜索算法，可以系统地探索所有可能的分配组合，确保每个分配方案都符合上述条件。该方法能够有效地处理这类组合优化问题，找到所有可行的解。 ... [详细]

蜡笔小新 2024-11-09 20:10:25
char
FFMpeg学习进阶：音频处理基础理论与重采样技术详解

在Android平台中，播放音频的采样率通常固定为44.1kHz，而录音的采样率则固定为8kHz。为了确保音频设备的正常工作，底层驱动必须预先设定这些固定的采样率。当上层应用提供的采样率与这些预设值不匹配时，需要通过重采样（resample）技术来调整采样率，以保证音频数据的正确处理和传输。本文将详细探讨FFMpeg在音频处理中的基础理论及重采样技术的应用。 ... [详细]

蜡笔小新 2024-11-09 13:46:55
char
NOIP2000单词接龙题目解析与学习心得

NOIP2000的单词接龙问题与常见的成语接龙游戏有异曲同工之妙。题目要求在给定的一组单词中，从指定的起始字母开始，构建最长的“单词链”。每个单词在链中最多可出现两次。本文将详细解析该题目的解法，并分享学习过程中的心得体会。 ... [详细]

蜡笔小新 2024-11-08 14:01:31
java
HDFS API

Hadoop的文件操作位于包org.apache.hadoop.fs里面，能够进行新建、删除、修改等操作。比较重要的几个类：(1)Configurati ... [详细]

蜡笔小新 2024-11-13 17:31:50
char
Java反射机制详解及应用场景

本文详细介绍了Java反射机制的基本概念、获取Class对象的方法、反射的主要功能及其在实际开发中的应用。通过具体示例，帮助读者更好地理解和使用Java反射。 ... [详细]

蜡笔小新 2024-11-13 16:08:08
tree
洛谷 P1531 我讨厌它 —— 线段树实现

本文介绍如何使用线段树解决洛谷 P1531 我讨厌它问题，重点在于单点更新和区间查询最大值。 ... [详细]

蜡笔小新 2024-11-12 21:27:38

beitianmolang

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章

怎么利用C++实现Mystring类

功能实现

一： 基本功能 (实现源码)

二：拓展功能

完整版源码

三：细节部分修改

1.使用指针实例化对象部分

2.重载 "=" 运算符函数的过程

一：基本功能 (实现源码)