string 类操作的重载实现及其提供的其他常用成员函数

目录

  • 1,string 类操作的重载实现
  • 2,String类提供的其他常用成员函数

@

1,string 类操作的重载实现

/*
string 类操作的重载实现
*/

class CMyString
{
public:
    CMyString(char *ptr = NULL)
    {
        if (ptr == NULL)
        {
            mpStr = new char[1];
            *mpStr = ‘\0‘;
        }
        else
        {
            mpStr = new char[strlen(ptr) + 1];
            strcpy(mpStr, ptr);
        }
    }
    ~CMyString()
    {
        delete[]mpStr;
        mpStr = NULL;
    }
    CMyString(const CMyString &src)
    {
        mpStr = new char[src.length() + 1];
        strcpy(mpStr, src.mpStr);
    }
    CMyString& operator=(const CMyString &src)
    {
        if (this == &src)
        {
            return*this;
        }
        delete[]mpStr;
        mpStr = NULL;
        mpStr = new char[src.length() + 1];
        strcpy(mpStr, src.mpStr);
        return *this;
    }
    bool operator>(const CMyString&src){ return strcmp(mpStr, src.mpStr) > 0; }
    bool operator<(const CMyString&src){ return strcmp(mpStr, src.mpStr) < 0; }
    bool operator==(const CMyString&src){ return strcmp(mpStr, src.mpStr) == 0; }
    bool operator!=(const CMyString&src){ return strcmp(mpStr, src.mpStr) != 0; }
    char operator[](int index)
    {
        return  mpStr[index];
    }
    int length()const{ return strlen(mpStr); }
    const char* c_str()const{ return mpStr; }

    // 定义当前CMyString类型的迭代器
    class iterator
    {
    public:
        iterator(char *ptr = NULL) :_ptr(ptr){}

        /*iterator(char *ptr = NULL, int pos = 0)
        {
            _ptr = _ptr + pos;
        }*/

        // 构造函数  operator!=   operator++   operator*
        bool operator!=(const iterator &it)
        {
            return _ptr != it._ptr;
        }
        void operator++()
        {
            _ptr++;
        }
        char& operator*()
        {
            return *_ptr;
        }
    private:
        // 迭代器的成员变量
        char *_ptr;
    };
    iterator begin(){ return iterator(mpStr); }  // return第0号位元素的迭代器表示
    iterator end(){ return iterator(mpStr + length()); } // return最后一位元素的迭代器表示

private:
    char *mpStr;

    friend CMyString operator+(const CMyString &lhs,const CMyString &rhs);
    friend ostream& operator<<(ostream&out, const CMyString&src);
    friend istream& operator>>(istream&in, CMyString&src);

};

CMyString operator+(const CMyString &lhs, const CMyString &rhs)
{
    char*ptmp = new char[lhs.length() + rhs.length() + 1];
    strcpy(ptmp, lhs.mpStr);
    strcat(ptmp, rhs.mpStr);
    CMyString tmp(ptmp);
    delete ptmp;
    return tmp;
}
ostream& operator<<(ostream&out, const CMyString&src)
{
    out << src.mpStr << endl;
    return out;
}
istream& operator>>(istream&in, CMyString&src)
{
    char buff[1024] = {0};
    in >> buff;
    delete[]src.mpStr;
    src.mpStr = new char[strlen(buff) + 1];
    strcpy(src.mpStr, buff);
    return in;
}
// operator<<   operator>>
int main()
{
    CMyString str1;
    CMyString str2 = "aaa";
    CMyString str3 = "bbb";
    CMyString str4 = str2 + str3;
    cout << str4 << endl;
    str4 = str2 + "ccc";
    cout << str4 << endl;
    str4 = "ddd" + str2;
    cout << str4 << endl;
    cout << "请输入一段字符串:";
    cin >> str4;
    cout << "你输入的字符串是:" << str4 << endl;

    if (str2 > str3)
    {
        cout << "str2 > str3" << endl;
    }
    else
    {
        cout << "str2 <= str3" << endl;
    }

    int size = str4.length();
    for (int i = 0; i < size; ++i)
    {
        cout << str4[i];
    }
    cout << endl;

    char buffer[1024] = { 0 };
    strcpy(buffer, str4.c_str());
    cout << "buffer:" << buffer << endl;

    CMyString testStr = "hello world";
    CMyString::iterator it = testStr.begin(); // begin()返回第0个元素的迭代器
    for (; it != testStr.end(); ++it)// testStr.end()返回最后一个元素的后继位置
    {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

运行结果如下:

2,String类提供的其他常用成员函数

string s1="ABCDEFG";

string s2="0123456123";

(1)substr(n1,n):取子串函数,从当前字符串的n1下标开始,取出n个字符。

如:“s=s1.substr(2,3)”的结果为 :s="CDE";

(2)swap(s):将当前字符串与s交换。

如:”s1.swap(s2) “ 的结果为:s1="0123456123"

? s2="ABCDEFG"

(3)size()/length():计算当前字符串中目前存放的字符个数。

如:“s1.length()”的结果为:“ 7”

(4)find(s):在当前字符串中查找子串s,若找到,就返回s在当前字符串中的起始位置;若没找到,返回常数:string::npos。

如:“s1.find("EF")”的结果为:“4”

(5)rfind(s):同find,但从后向前进行查找。

如:”s1.rfind("BCD")“的结果为:”1“

(6)find_first_of(s):在当前串中查找子串s第一次出现的位置。

如:“s2.find_first_of("123")”的结果为:“1”

(7)find_last_of(s):在当前串中查找子串s最后一次出现的位置。

如:“s2.find_last_of("123")”的结果为:“9”

(8)replace(n1,n,s):替换当前字符串中的字符,n1是替换的起始下标,n是要替换的字符个数,s是用来替换的字符串。

如:“ s1.replace(0,3,abc)”的结果为:“ abcDEFG”

(9)replace(n1,n,s,n2,m):替换当前字符串中的字符,n1是替换的起始下标,n是要替换的个数,s是用来替换的字符串,n2是s中用来替换的起始下标,m是s中用于替换的字符个数。

如“s1.replace(2,3,s2,2,3) ”的结果为:“ s1=AB234FG”

(10)insert(n,s):在当前串的下标位置n之前,插入s串(此时应考虑当前串的内存大小,,若插入后的内存大小小于当前串的内存大小,则插入失败)。

如:“ s2.insert(3,"abc")"” 的结果为:“ s2=012abc3456123”

(11)insert(n1,s,n2,m):在当前串的n1下标之后插入s串,n2是s串中要插入的起始下标,m是s串中要插入的字符个数(此时应考虑当前串的内存大小,若插入后的内存大小小于当前串的内存大小,则插入失败)。

如:“s2.insert(2,"abcdef",1,3) ”的结果为:“s2=01bcd23456123”

原文地址:https://www.cnblogs.com/earthmolin/p/9918027.html

时间: 2024-10-19 14:56:04

string 类操作的重载实现及其提供的其他常用成员函数的相关文章

实现string类的操作符重载 + = &gt; &lt; == != &gt;&gt; &lt;&lt;

//MyString.h #pragma once #include <iostream> using namespace std; class MyString { private: char *m_ptr;//内存空间 public: MyString(const char *str=NULL);//构造函数 MyString(const MyString& obj); //拷贝构造函数 ~MyString(); //析构函数 public: // + = > < ==

Qt中利用QTime类来控制时间,这里简单介绍一下QTime的成员函数的用法:

---------------------------------------------------------------------------------------------------------------------------------------- QTime::QTime() 默认构造函数,构造一个时,分,秒都为0的时间,如00:00:00.000(午夜) QTime::QTime(int h, int m, int s=0, int ms = 0) 构造一个用户指定时

Java 中StringBuffer与StringBuilder区别(转)及String类的一些基本操作代码

String 字符串常量StringBuffer 字符串变量(线程安全)  多个线程访问时,不会产生问题(Synchronized)StringBuilder 字符串变量(非线程安全) 多个线程访问时可能会产生问题 简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不

第十天 Object类(部分)和String类

Java的API Java的API(API:Application(应用)Programming(程序)Interface(接口)) JavaAP就是JD中提供给我们使用的类,这些类将底层代码实现封装起来了.我们不需要关系这些类是如何实现的,只需要虚心如何使用这些类. JKD安装目录下有个src.zip文件,这个文件解压后里面的内容就是所有java的类.可以参看对应的源码. 其次我们可以通过查找帮助文档的方式,来了解Java提供的API如何使用哪些类 Object类的概述 构造方法public

拷贝构造,深度拷贝,关于delete和default相关的操作,explicit,类赋初值,构造函数和析构函数,成员函数和内联函数,关于内存存储,默认参数,静态函数和普通函数,const函数,友元

 1.拷贝构造 //拷贝构造的规则,有两种方式实现初始化. //1.一个是通过在后面:a(x),b(y)的方式实现初始化. //2.第二种初始化的方式是直接在构造方法里面实现初始化. 案例如下: #include<iostream> //如果声明已经定义,边不会生成 class classA { private: int a; int b; public: //拷贝构造的规则,有两种方式实现初始化 //1.一个是通过在后面:a(x),b(y)的方式实现初始化 //2.第二种初始化的方式是直

C++中String类的实现

原文:http://noalgo.info/382.html String是C++中的重要类型,程序员在C++面试中经常会遇到关于String的细节问题,甚至要求当场实现这个类.只是由于时间关系,可能只要求实现构造函数.析构函数.拷贝构造函数等关键部分.String的实现涉及很多C++的基础知识.内存控制及异常处理等问题,仔细研究起来非常复杂,本文主要做一个简单的总结和归纳. 一 整体框架 面试时由于时间关系,面试官一般不会要求很详尽的String的功能,一般是要求实现构造函数.拷贝构造函数.赋

黑马程序员-java基础-String类

1.概述 String 类适用于描述字符串事务.提供了多种对字符串进行操作的方法. > 字符串的最大的特点:一旦被初始化就不能被改变. 2.常见的操作方法: 2.1 获取: 1 public class StringText1 { 2 public static void main(String srgs[]) 3 { 4 // str 是一个类类型变量,"abc"是一个对象. 5 String str = "hello java!" ; 6 // str 和

JAVA 12 (String类)

class Test { public static void main(String[] args) { String s1 = "abc";  //s1是一个类类型的变量,abc是一个对象,字符串的最大特点,一单被初始化就不能改变.s1是字符串的引用. String s2 = new String("abc"); System.out.println(s1==s2); System.out.println(s1.equals(s2));//String类复写了O

C++string类整理

string类 string类 头文件:#include<string> 名称空间:using namespace std; 初始化: string Str; String类的构造函数和析构函数如下: string s(str) //拷贝构造函数 生成str的复制品 string s(str,stridx) //将字符串str内"始于位置stridx"的部分当作字符串的初值 string s(str,stridx,strlen) //将字符串str内"始于stri