DTLib - 字符串类的创建

最新推荐文章于 2021-11-11 11:23:00 发布
最新推荐文章于 2021-11-11 11:23:00 发布
阅读量494 收藏
点赞数
分类专栏： 数据结构实战开发【笔记】
课程笔记内容整理于狄泰软件
本文链接：https://blog.csdn.net/qq_39654127/article/details/80369774
版权

目录

1、历史遗留问题 

2、字符串类的创建

3、编程实验 

4、字符串类中的常用成员函数实现

5、KMP算法的应用 

6、编程实验 

7、小结 

1、历史遗留问题 

C语言不支持真正意义上的字符串 

C语言用字符数组和—组函数实现字符串操作 

C语言不支持自定义类型，因此无法获得字符串类型 

从C到C++的进化过程引入了自定义类型

在C++中可以通过类完成字符串类型的定义 

C++中的原生类型系统不包含字符串类型

2、字符串类的创建

DTLib中字符串类的设计

 

实现时的注意事项 

                －无缝实现 String 对象与 char* 字符串的互操作 

                －操作符重载函数需要考虑是否支持 const 版本 

                －通过C语言中的字符串函数实现 String 的成员函数 

3、编程实验 

字符串类的实现     DTString.h    DTString.cpp

#ifndef DTSTRING_H
#define DTSTRING_H

#include "Object.h"

namespace DTLib
{

class String : public Object
{
protected:
    char* m_str;
    int m_length;

    void init(const char* s);
public:
    String();
    String(char c);
    String(const char* s);
    String(const String& s);

    int length() const;
    const char* str() const;

    bool operator == (const String& s) const;
    bool operator == (const char* s) const;
    bool operator != (const String& s) const;
    bool operator != (const char* s) const;
    bool operator > (const String& s) const;
    bool operator > (const char* s) const;
    bool operator < (const String& s) const;
    bool operator < (const char* s) const;
    bool operator >= (const String& s) const;
    bool operator >= (const char* s) const;
    bool operator <= (const String& s) const;
    bool operator <= (const char* s) const;

    String operator + (const String& s) const;
    String operator + (const char* s) const;
    String& operator += (const String& s);
    String& operator += (const char* s);

    String& operator = (const String& s);
    String& operator = (const char* s);
    String& operator = (char c);

    ~String();
};
}

#endif // DTSTRING_H

DTString.cpp

#include <cstring>
#include <cstdlib>
#include "DTString.h"
#include "Exception.h"

using namespace std;

namespace DTLib
{

void String::init(const char *s)
{
    m_str = strdup(s); //m_str指向堆空间拷贝字符串

    if( m_str )
    {
        m_length = strlen(m_str);
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create String object ...");
    }
}

String::String()
{
    init("");
}

String::String(const char *s)
{
    init(s ? s : "");   //NULL指针转换为空字符串
}

String::String(const String &s)
{
    init(s.m_str);
}
String::String(char c)
{
    char s[] = {c, '\0'};
    init(s);
}

int String::length() const
{
    return m_length;
}

const char* String::str() const
{
    return m_str;
}

bool String::operator == (const String& s) const
{
    return (strcmp(m_str, s.m_str) == 0);
}
bool String::operator == (const char* s) const
{
    return (strcmp(m_str, s ? s : "") == 0);
}

bool String::operator != (const String& s) const
{
    return !(*this == s);
}
bool String::operator != (const char* s) const
{
    return !(*this == s ? s : "");
}

bool String::operator > (const String& s) const
{
    return (strcmp(m_str, s.m_str) > 0);
}
bool String::operator > (const char* s) const
{
    return (strcmp(m_str, s ? s : "") > 0);
}

bool String::operator < (const String& s) const
{
    return (strcmp(m_str, s.m_str) < 0);
}
bool String::operator < (const char* s) const
{
    return (strcmp(m_str, s ? s : "") < 0);
}

bool String::operator >= (const String& s) const
{
    return (strcmp(m_str, s.m_str) >= 0);
}
bool String::operator >= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") >= 0);
}

bool String::operator <= (const String& s) const
{
    return (strcmp(m_str, s.m_str) <= 0);
}
bool String::operator <= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") <= 0);
}

String String::operator + (const String& s) const
{
    return (*this + s.m_str);
}
String String::operator + (const char* s) const
{
    String ret;

    int len = m_length + strlen(s ? s : "");

    char* str = reinterpret_cast<char*>(malloc(len + 1));

    if( str )
    {
        strcpy(str, m_str);
        strcat(str, s ? s : "");

        free(ret.m_str);

        ret.m_str = str;
        ret.m_length = len;
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to add String values ...");
    }

    return ret;
}

String& String::operator += (const String& s)
{
    return (*this = *this + s.m_str);
}
String& String::operator += (const char* s)
{
    return (*this = *this + s);
}

String& String::operator = (const String& s)
{
    return (*this = s.m_str);
}
String& String::operator = (const char* s)
{
    if(m_str != s )
    {
        char* str = strdup(s ? s : "");

        if( str )
        {
            free(m_str);

            m_str = str;

            m_length = strlen(m_str);
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to assign new String value ...");
        }
    }

    return *this;
}
String& String::operator = (char c)
{
    char s[] = {c, '\0'};

    return (*this = s);
}

String::~String()
{
    free(m_str);
}

}

main.cpp

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

using namespace std;
using namespace DTLib;

void test_1()
{
    cout << "test_1() begin :" << endl;

    String s;

    s = 'N';
 
    cout << s.str() << endl;
    cout << s.length() << endl;
    cout << (s == "N") << endl;
    cout << (s > "CCC") << endl;

    s += "yist";

    cout << s.str() << endl;
    cout << s.length() << endl;
    cout << (s == "Nyist") << endl;

    cout << "test_1() end :" << endl;
}

void test_2()
{
    cout << "test_2() begin :" << endl;

    String a[] = {"D","C","B","A"};

    String min = a[0];

    for(int i = 0; i < 4; i++)
    {
        if(min > a[i])
            min = a[i];
    }

    cout << min.str() << endl;

    cout << "test_2() end :" << endl;
}
int main()
{
    test_1();

    test_2();
    
    return 0;
}

                            


4、字符串类中的常用成员函数实现

字符串类中的常用成员函数 

  

重载数组访问操作符［］

                  - char& operator［］(int i); 

                  - char operator［］(int i) const; 

char& String::operator [] (int i)
{
    if((0 <= i) && (i < m_length))
    {
        return m_str[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsExpception, "Parameter i is invalid ...");
    }
}
char String::operator [] (int i) const
{
    return const_cast<String&>(*this)[i];
}

判断是否以指定字符串开始或结束 

                  - bool startWith(const char* s) const; 

                  - bool startWith(const String& s) const; 

                  - bool endOf(const char* s) const; 

                  - bool endOf(const String& s) const;

  

 

bool String::equal(const char* l, const char* r, int len) const
{
    bool ret = true;

    for(int i = 0; i < len && ret; i++)
    {
        ret  = ret && (l[i] == r[i]);
    }

    return ret;
}

bool String::startWith(const char* s) const
{
    bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);

        ret = (len < m_length) && equal(m_str, s, len);   //equal为const函数
    }

    return ret;
}
bool String::startWith(const String& s) const
{
    return startWith(s.m_str);
}

bool String::endOf(const char* s) const
{
    bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);
        char* str = m_str + (m_length - len);

        ret = (len < m_length) && equal(str, s, len);
    }

    return ret;
}
bool String::endOf(const String& s) const
{
    return endOf(s.m_str);
}

在指定位置处插入字符串 

                - String& insert(int i, const char* s); 

                - String& insert(int i, const String& s);

 

String& String::insert(int i, const char *s)
{
    if((0 <= i) && (i <= m_length))
    {
        if((s != NULL) && (s[0] != '\0'))
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(m_length + len + 1));

            if(str != NULL)
            {
                strncpy(str, m_str, i);
                strncpy(str + i, s, len);
                strncpy(str + i + len, m_str + i, m_length - i);

                str[m_length + len] = '\0';

                free(m_str);

                m_str = str;
                m_length = m_length + len;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert string value ...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsExpception, "Parameter i is invalid ...");
    }

    return *this;//返回引用，支持链式操作
}
String& String::insert(int i, const String& s)
{
    return insert(i, s.m_str);
}

去掉字符串两端的空白字符

                     - String& trim();

 

String& String::trim()
{
    int b = 0;
    int e = m_length - 1;

    while(m_str[b] == ' ') b++;
    while(m_str[e] == ' ') e--;

    if(b == 0)
    {
        m_str[e + 1] = '\0';
        m_length = e + 1;
    }
    else
    {
        for(int i=0,j=b; j<=e; i++,j++)
        {
            m_str[i] = m_str[j];
        }

        m_str[e - b + 1] = '\0';

        m_length = e - b + 1;
    }

    return *this;
}

5、KMP算法的应用 

思考 

                  如何在目标字符串中查找是否存在指定的子串？

字符串类中的新功能 

 

子串查找(KMP算法的直接运用）

 

int* String::make_pmt(const char* p)    //O(n)
{
    int len = strlen(p);
    int* ret = static_cast<int*>(malloc(sizeof(int)*len));

    if(ret != NULL)
    {
        int ll = 0; //前后缀交集元素最大长度

        ret[0] = 0; //长度为1的字符串ll值为0

        for(int i=1;i<len;i++)
        {
            while((ll > 0) && (p[ll] != p[i]))
            {
                ll = ret[ll-1];
            }
            if(p[ll] == p[i])
            {
                ll++;
            }

            ret[i] = ll;    //部分匹配表存放部分匹配值
        }


    }
    return ret;
}
int String::kmp(const char* s,const char* p)    //O(m)+O(n)=O(m+n)
{
    int ret = -1;
    int s1 = strlen(s);
    int p1 = strlen(p);
    int* pmt = make_pmt(p);

    if((pmt != NULL) && (0 < p1) && (p1 <= s1))
    {
        for(int i=0,j=0;i<s1;i++)
        {
            while((j > 0) && (s[i] != p[j]) )
            {
                j = pmt[j-1];
            }

            if(s[i] == p[j])
            {
                j++;
            }

            if(j == p1)
            {
                ret = i + 1 - p1;
                break;
            }

        }
    }
    free(pmt);

    return ret;

}
int String::indexOf(const char* s) const
{
    return kmp(m_str,s ? s : "");
}
int String::indexOf(const String& s) const
{
    return kmp(m_str,s.m_str);
}

在字符串中将指定的子串删除

            

             1. 根据KMP在目标字符串中查找子串的位置

             2. 通过子串位置和子串长度进行删除 

String& String::remove(int i,int len)
{
    if((0 <= i)&&(i < m_length))
    {
        int n = i;
        int m = i + len;

        while((n < m) && (m < m_length))
        {
            m_str[n++] = m_str[m++];
        }

        m_str[n] = '\0';
        m_length = n;
    }
    return *this;
}
String& String::remove(const char* s)
{
    return remove(indexOf(s),s ? strlen(s) : 0);
}

String& String::remove(const String& s)
{
    return remove(indexOf(s.m_str),s.length());
}

字符串的减法操作定义( operator - ) 

               －使用remove实现字符串间的减法操作 

                        字符串自身不被修改 

                        返回产生的新串 

                    

String String::operator - (const String& s) const
{
    return String(*this).remove(s);//调用构造函数产生临时对象
}
String String::operator - (const char* s) const
{
    return String(*this).remove(s);
}
String& String::operator -= (const String& s)
{
    return remove(s);
}

String& String::operator -= (const char* s)
{
    return remove(s);
}

字符串中的子串替换

            

String& String::replace(const char* t,const char* s)
{
    int index = indexOf(t);

    if(index >= 0)
    {
        remove(t);
        insert(index,s);
    }

    return *this;
}

String& String::replace(const String& t,const char* s)
{
    return replace(t.m_str,s);
}

String& String::replace(const char* t,String& s)
{
    return replace(t,s.m_str);
}

String& String::replace(const String& t,const String& s)
{
    return replace(t.m_str,s.m_str);
}

从字符串中创建子串 

                - String sub(int i, int len) const 

                        以i为起点提取长度为len的子串 

                        子串提取不会改变字符串本身的状态 

                        

 

6、编程实验 

常用成员函数的实现     DTString.h     DTString.cpp

DTString.h

#ifndef DTSTRING_H
#define DTSTRING_H

#include "Object.h"

namespace DTLib
{

class String : public Object
{
protected:
    char* m_str;
    int m_length;
    
    void init(const char* s);
    bool equal(const char* l, const char* r, int len) const;
    
    static int* make_pmt(const char* p) ;
    static int kmp(const char* s,const char* p);
    
public:
    String();
    String(char c);
    String(const char* s);
    String(const String& s);
    
    int length() const;
    const char* str() const;
    bool startWith(const char* s) const;
    bool startWith(const String& s) const;
    bool endOf(const char* s) const;
    bool endOf(const String& s) const;
    
    String& insert(int i, const char* s);
    String& insert(int i, const String& s);
    
    String& trim();
    
    int indexOf(const char* s) const;
    int indexOf(const String& s) const;
    
    String& remove(int i, int len);
    String& remove(const char* s);
    String& remove(const String& s);
    
    String& replace(const char* t, const char* s);
    String& replace(const String& t, const char* s);
    String& replace(const char* t, String& s);
    String& replace(const String& t, const String& s);
    
    String sub(int i, int len) const;
    
    
    char& operator [] (int i);
    char operator [] (int i) const;
    
    bool operator == (const String& s) const;
    bool operator == (const char* s) const;
    bool operator != (const String& s) const;
    bool operator != (const char* s) const;
    bool operator > (const String& s) const;
    bool operator > (const char* s) const;
    bool operator < (const String& s) const;
    bool operator < (const char* s) const;
    bool operator >= (const String& s) const;
    bool operator >= (const char* s) const;
    bool operator <= (const String& s) const;
    bool operator <= (const char* s) const;
    
    String operator + (const String& s) const;
    String operator + (const char* s) const;
    String& operator += (const String& s);
    String& operator += (const char* s);
    
    String operator - (const String& s) const;
    String operator - (const char* s) const;
    String& operator -= (const String& s);
    String& operator -= (const char* s);
    
    String& operator = (const String& s);
    String& operator = (const char* s);
    String& operator = (char c);
    
    ~String();
};
}

#endif // DTSTRING_H

DTString.cpp

#include <cstring>
#include <cstdlib>
#include "DTString.h"
#include "Exception.h"

using namespace std;

namespace DTLib
{

int* String::make_pmt(const char* p)    //O(n)
{
    int len = strlen(p);
    int* ret = static_cast<int*>(malloc(sizeof(int) * len));
    
    if(ret != NULL)
    {
        int ll = 0; //前后缀交集元素最大长度
        
        ret[0] = 0; //长度为1的字符串ll值为0
        
        for(int i = 1; i < len; i++)
        {
            while((ll > 0) && (p[ll] != p[i]))
            {
                ll = ret[ll-1];
            }
            if(p[ll] == p[i])
            {
                ll++;
            }
            
            ret[i] = ll;    //部分匹配表存放部分匹配值
        }
        
        
    }
    return ret;
}
int String::kmp(const char* s, const char* p)    //O(m)+O(n)=O(m+n)
{
    int ret = -1;
    int s1 = strlen(s);
    int p1 = strlen(p);
    int* pmt = make_pmt(p);
    
    if((pmt != NULL) && (0 < p1) && (p1 <= s1))
    {
        for(int i = 0, j = 0; i < s1; i++)
        {
            while((j > 0) && (s[i] != p[j]) )
            {
                j = pmt[j-1];
            }
            
            if(s[i] == p[j])
            {
                j++;
            }
            
            if(j == p1)
            {
                ret = i + 1 - p1;
                break;
            }
        }
    }
    
    free(pmt);
    
    return ret;
}

void String::init(const char *s)
{
    m_str = strdup(s);
    
    if(m_str)
    {
        m_length = strlen(m_str);
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create String object ...");
    }
}

String::String()
{
    init("");
}

String::String(const char *s)
{
    init(s ? s : "");   //NULL指针转换为空字符串
}

String::String(const String &s)
{
    init(s.m_str);
}
String::String(char c)
{
    char s[] = {c, '\0'};
    init(s);
}

int String::length() const
{
    return m_length;
}

const char* String::str() const
{
    return m_str;
}

bool String::equal(const char* l, const char* r, int len) const
{
    bool ret = true;
    
    for(int i = 0; i < len && ret; i++)
    {
        ret  = ret && (l[i] == r[i]);
    }
    
    return ret;
}

bool String::startWith(const char* s) const
{
    bool ret = (s != NULL);
    
    if( ret )
    {
        int len = strlen(s);
        
        ret = (len < m_length) && equal(m_str, s, len);   //equal为const函数
    }
    
    return ret;
}
bool String::startWith(const String& s) const
{
    return startWith(s.m_str);
}
bool String::endOf(const char* s) const
{
    bool ret = (s != NULL);
    
    if( ret )
    {
        int len = strlen(s);
        char* str = m_str + (m_length - len);
        
        ret = (len < m_length) && equal(str,s,len);
    }
    
    return ret;
}
bool String::endOf(const String& s) const
{
    return endOf(s.m_str);
}

String& String::insert(int i, const char *s)
{
    if((0 <= i) && (i <= m_length))
    {
        if((s != NULL)&&(s[0] != '\0'))
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(m_length + len + 1));
            
            if(str != NULL)
            {
                strncpy(str,m_str, i);
                strncpy(str + i, s,len);
                strncpy(str + i + len, m_str + i, m_length - i);
                
                str[m_length + len] = '\0';
                
                free(m_str);
                
                m_str = str;
                m_length = m_length + len;
                
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert string value ...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsExpception, "Parameter i is invalid ...");
    }
    
    return *this;
}
String& String::insert(int i, const String& s)
{
    return insert(i, s.m_str);
}

String& String::trim()
{
    int b = 0;
    int e = m_length - 1;
    
    while(m_str[b] == ' ') b++;
    while(m_str[e] == ' ') e--;
    
    if(b == 0)
    {
        m_str[e + 1] = '\0';
        m_length = e + 1;
    }
    else
    {
        for(int i = 0, j = b; j <= e; i++, j++)
        {
            m_str[i] = m_str[j];
        }
        
        m_str[e - b + 1] = '\0';
        
        m_length = e - b + 1;
        
    }
    
    return *this;
}

int String::indexOf(const char* s) const
{
    return kmp(m_str, s ? s : "");
}
int String::indexOf(const String& s) const
{
    return kmp(m_str, s.m_str);
}

String& String::remove(int i, int len)
{
    if((0 <= i) && (i < m_length))
    {
        int n = i;
        int m = i + len;
        
        while((n < m) && (m < m_length))
        {
            m_str[n++] = m_str[m++];
        }
        
        m_str[n] = '\0';
        m_length = n;
    }
    return *this;
}
String& String::remove(const char* s)
{
    return remove(indexOf(s), s ? strlen(s) : 0);
}

String& String::remove(const String& s)
{
    return remove(indexOf(s.m_str), s.length());
}

String& String::replace(const char* t, const char* s)
{
    int index = indexOf(t);
    
    if(index >= 0)
    {
        remove(t);
        insert(index, s);
    }
    
    return *this;
}

String& String::replace(const String& t, const char* s)
{
    return replace(t.m_str, s);
}

String& String::replace(const char* t, String& s)
{
    return replace(t, s.m_str);
}

String& String::replace(const String& t, const String& s)
{
    return replace(t.m_str, s.m_str);
}

String String::sub(int i, int len) const
{
    String ret;
    
    if((0 <= i)&&(i < m_length))
    {
        if(len < 0) len = 0;
        if(len > m_length) len = m_length - i;
        char* str = reinterpret_cast<char*>(malloc(len + 1));
        
        if(str)
        {
            strncpy(str, m_str + i, len);
            
            str[len] = '\0';
        }
        
        ret = str;
        
        return ret;
        
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsExpception, "Parameter i is invalid ...");
    }
}

char& String::operator [] (int i)
{
    if((0 <= i) && (i < m_length))
    {
        return m_str[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsExpception, "Parameter i is invalid ...");
    }
}
char String::operator [] (int i) const
{
    return const_cast<String&>(*this)[i];
}

bool String::operator == (const String& s) const
{
    return (strcmp(m_str, s.m_str) == 0);
}
bool String::operator == (const char* s) const
{
    return (strcmp(m_str, s ? s : "") == 0);
}

bool String::operator != (const String& s) const
{
    return !(*this == s);
}
bool String::operator != (const char* s) const
{
    return !(*this == s ? s : "");
}

bool String::operator > (const String& s) const
{
    return (strcmp(m_str, s.m_str) > 0);
}
bool String::operator > (const char* s) const
{
    return (strcmp(m_str, s ? s : "") > 0);
}

bool String::operator < (const String& s) const
{
    return (strcmp(m_str, s.m_str) < 0);
}
bool String::operator < (const char* s) const
{
    return (strcmp(m_str, s ? s : "") < 0);
}

bool String::operator >= (const String& s) const
{
    return (strcmp(m_str, s.m_str) >= 0);
}
bool String::operator >= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") >= 0);
}

bool String::operator <= (const String& s) const
{
    return (strcmp(m_str, s.m_str) <= 0);
}
bool String::operator <= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") <= 0);
}

String String::operator + (const String& s) const
{
    return (*this + s.m_str);
}
String String::operator + (const char* s) const
{
    String ret;
    
    int len = m_length + strlen(s ? s : "");
    
    char* str = reinterpret_cast<char*>(malloc(len + 1));
    
    if(str)
    {
        strcpy(str, m_str);
        strcat(str, s ? s : "");
        
        free(ret.m_str);
        
        ret.m_str = str;
        ret.m_length = len;
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to add String values ...");
    }
    
    return ret;
}

String& String::operator += (const String& s)
{
    return (*this = *this + s.m_str);
}
String& String::operator += (const char* s)
{
    return (*this = *this + s);
}

String String::operator - (const String& s) const
{
    return String(*this).remove(s);//调用构造函数产生临时对象
}
String String::operator - (const char* s) const
{
    return String(*this).remove(s);
}
String& String::operator -= (const String& s)
{
    return remove(s);
}

String& String::operator -= (const char* s)
{
    return remove(s);
}

String& String::operator = (const String& s)
{
    return (*this = s.m_str);
}
String& String::operator = (const char* s)
{
    if(m_str != s )
    {
        char* str = strdup(s ? s : "");\
        
        if(str)
        {
            free(m_str);
            
            m_str = str;
            
            m_length = strlen(m_str);
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to assign new String value ...");
        }
    }
    
    return *this;
}
String& String::operator = (char c)
{
    char s[] = {c, '\0'};
    
    return (*this = s);
}

String::~String()
{
    free(m_str);
}

}

main1.cpp

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

using namespace std;
using namespace DTLib;


int main()
{
/*
    String s = "nyist.edu.cn";

    for(int i = 0; i < s.length(); i++)
    {
        cout << s[i] << " ";
    }

    cout << endl;

    cout << s.startWith("nyist") << endl;
    cout << s.endOf(".cn") << endl;
 
    s.insert(0, "http://www.");

    cout << s.str() << endl;

*/
    String s = "  nyist.edu.cn   ";


    if(s.trim().insert(0, "http://www.").endOf(".cn") && s.startWith("http://"))
    {
        cout << s.str() << endl;
    }

    return 0;
}

 

main2.cpp

#include <iostream>
#include <cstring>
#include <cstdlib>
#include "DTString.h"

using namespace std;
using namespace DTLib;

int main()
{
    String s = "ababax";

    cout << s.indexOf("ba") << endl;

    cout << s.remove(1, 4).str() << endl;

    cout << s.remove("a").str() << endl;

    s.insert(0, "abcdefg");

    cout << s.str() << endl;

    String s1 = s - "fgx";

    cout << s1.str() << endl;

    s -= "abc";

    cout << s.str() << endl;

    s -= s;

    s.insert(0, "abcabc");

    cout << s.str() << endl;

    s.replace("abc", "cba");

    cout << s.str() << endl;

    s.insert(0, "abcabc");

    cout << s.str() << endl;

    String s2 = s.sub(3, 10);

    cout << s2.str() << endl;

    return 0;
}

  

                           感谢评论区朋友指出的错误，现已修正

7、小结 

            C / C++语言本身不支持字符串类型 

            C语言通过字符数组和一组函数支持字符串操作 

            C++通过自定义字符串类型支持字符串操作 

            字符串类型通过C语言中的字符串函数实现 

 字符串类是工程开发中必不可少的组件 

            字符串中应该包含常用字符串操作函数 

                －增： insert , operator + , … 

                －删： remove , operator - , … 

                －查： indexOf, … 

                －改： replace, … 

 

洋葱汪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
DTLib-LinkQueue
10-23
DTLib命名空间中添加LinkQueue双向循环链表与StaticQueue顺序循环链表
java实验-字符串.docx
12-13
而StringBuffer类是可变的，可以使用`append()`方法添加内容，而不必每次都创建新对象，因此在处理大量字符串拼接时，StringBuffer的效率更高。 总结来说，这个实验旨在帮助我们理解和掌握Java中字符串的基本操作，...
DTLib基础建设（智能指针类、异常类，顶层父类）
qq_39740690的博客
11-11 442
SmartPointer.h #ifndef SMARTPOINTER_H #define SMARTPOINTER_H /*智能指针 * 指针生命周期结束时主动释放堆空间 * 一片堆空间只能由一个指针标识 * 杜绝指针运算和比较 * 最大程度避免内存问题 */ namespace DTLib { template <typename T> class SmartPorter { protected: T* m_pointer; public: Smart...
DTLib - 异常类构建
洋葱汪的博客
04-13 576
1、异常类构建 异常的类型可以是自定义类类型 对于类类型异常的匹配依旧是至上而下严格匹配 赋值兼容原则在异常匹配中依然适用 一般而言 －匹配子类异常的catch放在上部 －匹配父类异常的catch放在下部 现代C++库必然包含充要的异常类族，异常类是数据结构类所依赖的"基础设施" ...
DTLib - List、SeqList、StaticList、DynamicList
洋葱汪的博客
04-15 513
目录 1、线性表的本质和操作 2、编程实验 3、线性表的顺序存储结构和抽象实现 4、编程实验 5、顺序存储线性表的效率分析 6、StaticList 和 DynamicList 7、小结 1、线性表的本质和操作 线性表( List )的表现形式 －零个或多个数据元素组成的集合 －数据元素在位置上是有序排...
DTLib - CircleList、DualLinkList、DualCircleList
洋葱汪的博客
05-10 435
目录 1、循环链表的实现 2、编程实验 3、循环链表的应用 4、双向链表的实现 5、编程实验 6、双向循环链表的实现 7、编程实验 1、循环链表的实现 概念上 －任意数据元素都有—个前驱和—个后继 －所有的数据元素的关系构成—个逻辑上的环 实现上 －循环链表...
C#-字符串操作类
09-20
C#-字符串操作类(替换字符串中危险字符、指定位置替换字符串、指定长度缩减字段并加...、指定字符串分割字符串、指定字符串位置获取字符串、过滤SQL中非法字符、检查SQL语句中是否有非法关键字、随机字符串生成、...
课程设计--字符串的操作..doc
04-10
设计任务包括创建两个字符串，然后实现它们的连接、比较、查找子串、获取子串以及计算长度等功能。 2. 概要设计： - 主界面模块：展示程序的功能和操作选项，使用户能够选择执行不同的字符串操作。 - 功能一操作...
ACM-字符串处理专练
01-13
理解字符串的基本操作，如创建、赋值、长度计算、拷贝和比较，是字符串处理的基础。 2. **字符串搜索**：包括线性搜索和更高效的算法，如KMP（Knuth-Morris-Pratt）算法，Boyer-Moore算法，以及Rabin-Karp rolling ...
php的字符串类.zip
07-11
总的来说，这个"php的字符串类"可能是为了提高开发效率和代码一致性而创建的，它将PHP的一些常用字符串操作进行了封装，提供了更方便的接口。开发者可以无需记住多个原生函数，只需调用类的方法即可完成相应的字符串...
DT数据结构代码 DTlib.rar
12-27
DT数据结构代码 DTlib.
DTLib - 概括
洋葱汪的博客
03-21 472
1、启航，新的目标 专业程序员的培养路线 目标：创建可复用的数据结构软件库 使用的技术 - C++面向对象技术 - C++模板技术 - C++异常处理技术 注：该库的所有语法问题都可以在下面找到 https://blog.csdn.net/qq_39654127/article/category...
DTLib - Array、StaticArray、DynamicArray
洋葱汪的博客
04-16 374
1、数组类的创建 目标：完成Array，StaticArray，DynamicArray类的具体实现     需求分析：创建数组类代替原生数组的使用                 - 数组类包含长度信息，能够主动发现越界访问 Array设计要点                 －抽象类模板，存储空间的位置和大小由子类完成                  －重载数组操作符，判断访问...
DTLib - Queue、StaticQueue、LinkQueue
洋葱汪的博客
05-16 300
目录 1、队列的概念及实现 2、基于顺序存储结构的队列  3、编程实验  4、基于链式存储结构的队列  5、编程实验 6、编程实验  7、小结 1、队列的概念及实现             队列是一种特殊的线性表              队列仅能在线性表的两端进行操作        －队头(Front) : 取出数据元素的一端        －队尾(Rear) : 插入数...
DTLib - LinkList、StaticLinkList
洋葱汪的博客
04-18 539
目录 线性表的链式存储结构 基本概念 单链表的具体实现与优化 单链表的遍历与优化 静态单链表的实现 顺序表和单链表的对比分析 线性表的链式存储结构 基本概念 1、基本概念 链式存储的定义 为了表示每个数据元素与其直接后继元素之间的逻辑关系；数 据元素除了存储本身的信息外，还需要存储其直接后继...
DTLib - Sort
洋葱汪的博客
05-24 374
目录 1、排序的基本概念 2、DTLib中的排序类设计 3、选择排序 4、插入排序 5、冒泡排序 6、希尔排序 7、归并排序 8、快速排序 9、排序的工程应用示例 10、小结 1、排序的基本概念 排序的一般定义 排序是计算机内经常进行的—种操作，其目的是将一组“无序”的数据元素调整为“有序”的数据元素。 排序的数学定义 ...
DTLib - 顶层父类的创建
洋葱汪的博客
04-14 372
1、顶层父类的创建 当代软件架构实践中的经验 －尽量使用单重继承的方式进行系统设计 －尽量保持系统中只存在单一的继承树 －尽量使用组合关系代替继承关系 不幸的事实 －C++语言的灵活性使得代码中可以存在多个继承树 －C++...
System.Directory___DTString
zhengl的专栏
08-10 1456
// ==++==// // // Copyright (c) 2002 Microsoft Corporation. All rights reserved.// // The use and distribution terms for this software are contained in the file// named licen
重载数组下标操作符，使用operator
gencheng的专栏
04-01 3577
重载数组下标操作符，使用operator 原贴：http://blog.csdn.net/keeplooking2510/article/details/8042057     数组在类的定义中确定好了长度之后，就会限制所要存储的元素的个数，假如我们要存储的元素的个数超过了已确定的数组的长度，那么就会导致数组越界。故最好的办法就是在创建对象的时候才确定要存储元素的个数，即数组的长度
C语言-字符串常量存储与释放、生命周期、定义及内存区域分布详解
C语言-字符串常量（超详细） 本文将详细介绍C语言中字符串常量的相关内容，并通过对内存分布、存储方式、生命周期、定义方式、字符数组和字符指针等进行讲解，帮助读者全面了解字符串常量在C语言中的使用。 1. ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值