字符串的重载程序

最新推荐文章于 2023-12-16 23:19:49 发布
最新推荐文章于 2023-12-16 23:19:49 发布
阅读量378 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mf1crystal/article/details/79058612
本文介绍了一个名为MyString的自定义字符串类的设计与实现细节，包括构造函数、析构函数、赋值运算符、比较运算符等重载，并演示了如何使用该类进行字符串操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

MyString.h

#ifndef __MYSTRING_H__
#define __MYSTRING_H__

#include <iostream>

using namespace std;

class MyString
{
    // 重载 << 操作符
    friend std::ostream& operator<<(std::ostream &out, MyString &str);

    // 重载 >> 操作符
    friend std::istream& operator>>(std::istream& in, MyString &str);
public:
    MyString();                        // 无参构造
    MyString(const char *s);           // 有参构造
    MyString(int len, char data = 0);  // 有参构造
    MyString(const MyString &s);       // 拷贝构造

    ~MyString();                       // 析构函数

// 重载=、[]操作符
public:
    MyString& operator=(const char *s);       // 普通字符串赋值
    MyString& operator=(const MyString &s);   // 类对象之间赋值
    char & operator[](int index);

// 重载 + 运算符
public:
    MyString& operator+(const char *str);
    MyString& operator+(const MyString &s);

    MyString& operator+=(const char *str);
    MyString& operator+=(const MyString &s);

// 重载 == !=
public:
    bool operator==(const char *str) const;
    bool operator==(const MyString &str) const;

    bool operator!=(const char *str) const;
    bool operator!=(const MyString &str) const;

// 重载 < >
public:
    bool operator>(const char *str) const;
    bool operator>(const MyString &str) const;

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

public:
    const char *c_str()
    {
        return m_p;
    }

    char *c_str2()
    {
        return m_p;
    }

    int leng()
    {
        return m_len;
    }
private:
    int m_len;    // 字符串长度
    char *m_p;    // 字符串数据
};




#endif // __MYSTRING_H__

MyString.cpp

#include "MyString.h"
#include <string.h>

std::ostream& operator<<(std::ostream &out, MyString &str)
{
    out << str.m_p << " ";

    return out;
}

std::istream& operator>>(std::istream& in, MyString &str)
{
    in >> str.m_p;
    //fgets (str.m_p, str.m_len, stdin);
    return in;
}

MyString::MyString()
{
    m_len = 0;
    m_p = new char[1];
}

MyString::MyString(const char *s)
{
    if (s == NULL)
    {
        m_len = 0;
        m_p = new char[1];
    }
    else
    {
        m_len = strlen(s);
        m_p = new char[m_len + 1];
        strcpy (m_p, s);
    }
}

MyString::MyString(int len, char data)
{
    m_len = len;
    m_p = new char[m_len+1];
    for (int i = 0; i < m_len; i++)
    {
        m_p[i] = data;
    }
}


MyString::MyString(const MyString &s)
{
    m_len = s.m_len;
    m_p = new char[m_len+1];
    strcpy (m_p, s.m_p);
}


MyString::~MyString()
{
    delete[] m_p;
    m_p = NULL;
    m_len = 0;
}


MyString& MyString::operator=(const char *s)
{
    // 先释放原有空间
    delete [] m_p;
    if (s == NULL)
    {
        m_len = 0;
        m_p = new char[1];
    }
    else
    {
        m_len = strlen(s);
        m_p = new char[m_len+1];
        strcpy(m_p, s);
    }

    return *this;
}

MyString& MyString::operator=(const MyString &s)
{
    // 是本身的情况下，直接返回当前对象
    if (this == &s)
        return *this;

    // 先释放
    delete[] m_p;

    m_len = s.m_len;
    m_p = new char[m_len + 1];
    strcpy (m_p, s.m_p);

    return *this;
}

MyString& MyString::operator+(const char *str)
{
    if (str == NULL)
    {
        return *this;
    }

    m_len += strlen(str);
    char *tmp = m_p;            // 将原有数据保存下来
    m_p = new char[m_len + 1];  // 分配新空间
    strcpy (m_p, tmp);          // 将原来的数据导入到新空间
    strcat (m_p, str);          // 将新数据粘到原有数据后面
    delete [] tmp;              // 释放原来的空间

    return *this;
}

MyString& MyString::operator+(const MyString &s)
{
    m_len += s.m_len;
    char *tmp = m_p;            // 将原有数据保存下来
    m_p = new char[m_len + 1];  // 分配新空间
    strcpy (m_p, tmp);          // 将原来的数据导入到新空间

    if (this == &s)             // 如果是自己，复制原有空间内容
        strcat (m_p, tmp);
    else                        // 复制新字符串的内容
        strcat (m_p, s.m_p);

    delete [] tmp;              // 释放原来的空间

    return *this;
}

MyString& MyString::operator+=(const char *str)
{
    *this = *this + str;

    return *this;
}

MyString& MyString::operator+=(const MyString &s)
{
    *this = *this + s;
    return *this;
}

char & MyString::operator[](int index)
{
    return m_p[index];
}

bool MyString::operator==(const char *str) const
{
    if (str == NULL)
    {
        if (m_len == 0)
            return true;
        else
            return false;
    }
    else
    {
        if (strcmp(m_p, str) == 0)
            return true;
        else
            return false;
    }
}

bool MyString::operator==(const MyString &str) const
{
    return *this == str.m_p;
}

bool MyString::operator!=(const char* str) const
{
    return !(*this == str);
}

bool MyString::operator!=(const MyString &str) const
{
    return !(*this == str.m_p);
}

bool MyString::operator>(const char *str) const
{
    if(str == NULL)
        return true;

    int i = 0;
    int len = (m_len < strlen(str) ? m_len : strlen(str)); // 保存较短的字符串的长度
    while (m_p[i] == str[i] && i<len)
        i++;

    return (m_p[i] > str[i] ? true : false);
}

bool MyString::operator>(const MyString &str) const
{
    return *this > str.m_p;
}

bool MyString::operator<(const char *str) const
{
    if(str == NULL)
        return true;

    int i = 0;
    int len = (m_len < strlen(str) ? m_len : strlen(str)); // 保存较短的字符串的长度
    while (m_p[i] == str[i] && i<len)
        i++;

    return (m_p[i] < str[i] ? true : false);
}

bool MyString::operator<(const MyString &str) const
{
    return *this < str.m_p;
}

main.cpp

#include <iostream>
#include "MyString.h"

int main()
{
    MyString str = "hello";
    char * p = str.c_str2();

    printf ("%s\n", str.c_str());

    return 0;
}


int main7()
{
    MyString str1 = "chelo";
    MyString str2 = "world";

    if (str1 > "bhello")
    {
        printf ("str1 > hello\n");
    }

    if (str1 > str2)
    {
        printf ("str1 > str2\n");
    }
    else
    {
        printf ("str1 < str2\n");
    }

    return 0;
}



int main6()
{
    MyString str1 = "helo";
    MyString str2 = "world";

    if (str1 == "hello")
    {
        printf ("str1 == hello\n");
    }
    else
    {
        printf ("str1 != hello\n");
    }

    if (str1 == str2)
    {
        printf ("str1 == str2\n");
    }
    else
    {
        printf ("str1 != str2\n");
    }

    return 0;
}

int main5()
{
    MyString str1 = "hello";

    std::cout << str1[3] << std::endl;
    str1[3] = 'w';
    std::cout << str1 << std::endl;

    return 0;
}

int main4()
{
    MyString str1 = "hello ";
    MyString str2 = "world";

    str1 = str1 + "borld";  
    // str1 = str1 + str1;
    // str1 += "world";
    //str1 += str2;

    std::cout << str1 << std::endl;

    return 0;
}

int main3()
{
    MyString str1;

    // MyString & operator(MyString &str, const char *s)
    str1 = "hello";   // 重载赋值操作符 = 
    //str1 = NULL;
    std::cout << str1 << std::endl;

    MyString str2;
    str2 = str1;
    std::cout << str2 << std::endl;

    str2 = str2;

    return 0;
}

int main2()
{
    MyString str1 = "hello world";   // 用一个字串去初始化类对象

    // << 
    // ostream & operator<<(ostream &out, MyString &str)
    std::cout << str1 << std::endl;

    MyString str2(4);

    // >> 
    // istream& operator>>(istream& in, MyString &str);
    std::cout << "请输入字符串：" ;
    std::cin >> str2;
    std::cout << str2 << std::endl;

    return 0;
}


int main8()
{
    MyString str;                    // 空字符串
    MyString str1 = "hello world";   // 用一个字串去初始化类对象
    cout << str1 << endl;
    MyString str2 = NULL;            // 空字符串
    MyString str3 = str1;            // 用一个字符串对象初始化当前对象
    MyString str4(10, 'a');           // 长度为10,每一个元素都是'a'
    cout << str4 << endl;
    MyString str5(20); 

    return 0;
}
对字符串进行运算符重载
weixin_62802660的博客
05-04 1139
1、定义一个时间类Time，通过运算符重载实现时间的比较(关系运算)、时间增加/减少若干秒(+=和-=)、时间增加/减少1秒(++和--)、计算两个时间相差的秒数(-)以及输出时间对象的值(时—分—秒)。 class Time { friend int operator-(const Time &t1, const Time &t2); friend ostream &operator<<(ostream &os, const Time &amp...
数据结构之-字符串重载函数的实现
数据结构学习心得
03-03 1289
1、AString.h文件 #pragma once #include&lt;iostream&gt; const int defaultSize = 128; class AString { //对象-一个或者多个字符的一个有限序列 public: //构造函数，构造一个最大长度为sz的字符串 AString(int sz = defaultSize); //构造函数，由一个已有的字...
字符串、运算符重载
10-16
赋值、相加、比大小、前++、后++ #include #include class String { private: int length; char *ptr; public: String(char *s); ~String(); String(String &s); void display(); String operator =(String &s); String operator +(String &s); int operator >(String &s); int operator <(String &s); int operator =(String &s); String operator++(); String operator++(int); };
操作符重载案例之字符串重载
Linux_bin的博客
09-05 544
本次案例自定义一个字符串类（Mystring），然后重载该字符串类以后，就可以向使用string类一样使用Mystring类了； Mystring.h文件： #ifndef __MYSTRING_H #define __MYSTRING_H class Mystring{ friend void print(Mystring & oop); public: /*空串 “”*/ Myst
字符串类运算符重载
$慕雪$的博客
04-17 1697
C++字符串类运算符重载 //重点 #define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; //定义MyString类 字符串数组 class MyString { public: //构造和析构函数 MyString() { m_len = 0; m_p = NULL; } /...
！实例研究：字符串类String.rar_字符串类_类String重载
09-23
在`fig4_3.exe`中，可能包含了一个运行这些操作的可执行程序，它使用了重载的`+=`操作符来演示字符串连接。`string2.h`和`fig4_3.h`可能是头文件，定义了类`MyString`以及相关接口，而`.bak`文件则是这些源文件的...
C#获取字符串后几位数的方法
09-03
在C#编程语言中，处理字符串是常见的任务之一，特别是在数据处理、文本分析或用户界面交互等场景。本文将深入探讨如何使用C#获取字符串的后几位数，并提供一个具体的实例来展示其实现方法。 首先，我们要理解字符串...
Java编程实现统计一个字符串中各个字符出现次数的方法
08-28
Java编程实现统计一个字符串中各个字符出现次数的方法 本文主要介绍了Java编程实现统计一个字符串中各个字符出现次数的方法，涉及java针对字符串的遍历、判断、运算等相关操作技巧。本文将通过一个实例，讲述如何...
C++ 整型与字符串的互转方式
12-23
本文主要探讨的是如何在整型（integer）与字符串（string）之间进行转换，这对于理解和编写涉及用户界面或文件读写的应用程序至关重要。 首先，让我们看下如何将字符串转换为整型。在C++中，有两个主要的函数可以...
c++ 字符串分割util
02-08
通过分析和使用`split.cpp`和`split.h`，我们可以学习如何在C++中高效地处理字符串，这对于编写涉及大量字符串操作的程序非常有帮助。这个实用工具可能包含了多种字符串处理策略，能够适应各种复杂的分割需求，使得...
函数重载 程序
09-10
函数重载 编写程序 c++、c语言函数重载 程序java基础
C++ 重载运算符+==-用于字符串的比较
07-08
C++ ,VS2010平台编辑，下载后可以直接使用，模拟打分及求平均分的过程
J2SE：字符串的+重载与StringBuilder
少年啦飞啦的博客
10-26 136
字符串对+和+=这两个操作符进行了重载，使我们可以更方便地进行字符串的拼接。有时我们会面临一个问题：是直接使用+拼接字符串，还是使用StringBuilder类的append()来拼接呢？ 我们知道，String是一个不可变的类，如果直接用+拼接，势必会产生大量需要垃圾回收的中间对象。 我们可以先通过反编译工具来看看字符串的+拼接是如何工作的。 public class Concatena...
标准库中的重载/字符串类
weixin_46258483的博客
08-21 133
有趣的重载： #include <stdio.h> const char endl = '\n'; class Console { public: Console& operator << (int i) { printf("%d", i); return *this; } Console& operator << (char c) { prin
c++中关于字符重载
beyond-mrzou的专栏
12-27 1143
什么是运算符的重载?          运算符与类结合，产生新的含义。对象直接可以进行加减。  为什么要引入运算符重载？          作用：为了实现类的多态性(多态是指一个函数名有多种含义)，                 在程序中有时候需要来做一些对象之间的运算，比如复数的计算，还有字符串的运算，这时候就要使用重载运算符。平常的运算都是内置类型(int,float
【C++】STL 容器 - string 字符串操作 ④ ( string 字符串连接 | 字符串重载函数 - operator+= 函数 | append 函数 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-16 578
一、string 字符串连接 1、字符串重载函数 - operator+= 函数 2、字符串重载函数 - operator+ 函数 3、append 函数 4、代码示例 - string 字符串连接
C++高级特性——重载
坚持理想 面对现实
12-27 2575
C++作为一个面向对象的语言（虽然不是完全的面向对象，和C#与Java这样的完全面向对象语言比较可得，说这个不表达语言之争，勿喷）。C++的高级特性具备了OO的三个（封装，继承，多态），当然OO的这三个并不仅仅是C++拥有的特性，而是具备面向对象的思想的语言都具备的，这里请注意是面向对象的语言，这一点很重要。因为只有支持继承与多态的才算是面向对象，而C语言的结构体所体现出来的封装特性仅仅算上是基于
【C++】字符串中运算符的重载问题
weixin_45732589的博客
11-01 2237
字符串中运算符的重载问题 运算符的重载： 运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。 定义运算符重载函数的一般格式： 返回值类型 类名::operator重载的运算符(参数表){……} 在字符串中，运算符的重载问题在于字符串和字符串之间进行计算。 首先我们定义一个字符串的类，并为其写出构造函数、拷贝构造函数，析构函数、打印字符串函数。 class String { private: char
字符串类中重载运算符
谢绝(无视)留言与私信
12-24 2207
测试程序 /// @file exam_1_1.cpp /** 1.完善MyString, 引用计数RefMyString operator= operator+ operator[](int nIndex) operator== operator!= operator> */ #include "common.h" #include "MyString.h" void fnTestStri
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值