C++_string类 (理解深浅拷贝)

2019-09-22 0 条评论 166 次阅读 0 人点赞

在C语言中,字符串是以'\0'结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问, 十分的不方便。

C++中有一个string类来有效代替C语言中的str系列函数,在我们平时见到的大多数问题也会使用string来解决。

  1. 字符串是表示字符序列的类
  2. 标准的字符串类提供了对此类对象的支持,其接口类似于标准字符容器的接口,但添加了专门用于操作
    单字节字符字符串的设计特性。
  3. string类是使用char(即作为它的字符类型,使用它的默认char_traits和分配器类型(关于模板的更多信
    息,请参阅basic_string)。
  4. string类是basic_string模板类的一个实例,它使用char来实例化basic_string模板类,并用char_traits
    和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
  5. 注意,这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列,这个
    类的所有成员(如长度或大小)以及它的迭代器,将仍然按照字节(而不是实际编码的字符)来操作。

总结:

  1. string是表示字符串的字符串类
  2. 该类的接口与常规容器的接口基本相同,再添加了一些专门用来操作string的常规操作。
    比特科技
  3. string在底层实际是:basic_string模板类的别名,typedef basic_string<char, char_traits, allocator> string;
  4. 不能操作多字节或者变长字符的序列。
    在使用string类时,必须包含 #include<string> 头文件以及using namespace std;
  • string类中常用接口介绍

    1. string类对象的常见构造

函数名称 功能说明
string() (重点) 构造空的string类对象,即空字符串
string(const char* s) (重点) 用C-string来构造string类对象
string(size_t n, char c) string类对象中包含n个字符c
string(const string&s) (重点) 拷贝构造函数

示例代码:

void TestString(){
 string s1; // 构造空的string类对象s1
 string s2("hello bit"); // 用C格式字符串构造string类对象s2
 string s3(s2); // 拷贝构造s3
}

2.string类对象的容量操作

函数名称 功能说明
size (重点) 返回字符串有效字符长度
length 返回字符串有效字符长度
capacity 返回空间总大小
empty (重点) 检测字符串释放为空串,是返回true,否则返回false
clear (重点) 清空有效字符
reserve (重点) 为字符串预留空间**
resize (重点) 将有效字符的个数该成n个,多出的空间用字符c填充

示例代码:

// size/clear/resize
void TestString(){

 // 注意:string类对象支持直接用cin和cout进行输入和输出
 string s("hello, bit!!!");

 cout << s.size() << endl;
 cout << s.length() << endl;
 cout << s.capacity() << endl;
 cout << s <<endl;

 // 将s中的字符串清空,注意清空时只是将size清0,不改变底层空间的大小
 s.clear();
 cout << s.size() << endl;
 cout << s.capacity() << endl;

 // 将s中有效字符个数增加到10个,多出位置用'a'进行填充
 // “aaaaaaaaaa”
 s.resize(10, 'a');
 cout << s.size() << endl;
 cout << s.capacity() << endl;

 // 将s中有效字符个数增加到15个,多出位置用缺省值'\0'进行填充
 // "aaaaaaaaaa\0\0\0\0\0"
 // 注意此时s中有效字符个数已经增加到15个
 s.resize(15);
 cout << s.size() << endl;
 cout << s.capacity() << endl;
 cout << s << endl;

 // 将s中有效字符个数缩小到5个
 s.resize(5);
 cout << s.size() << endl;
 cout << s.capacity() << endl;
 cout << s << endl;
}

注意:

  1. size()length()方法底层实现原理完全相同,引入size()的原因是为了与其他容器的接口保持一
    致,一般情况下基本都是用size()
  2. clear()只是将string中有效字符清空,不改变底层空间大小。
  3. resize(size_t n)resize(size_t n, char c)都是将字符串中有效字符个数改变到n个,不同的是当字
    符个数增多时:resize(n)用0来填充多出的元素空间,resize(size_t n, char c)用字符c来填充多出的元素空间。注意:resize在改变元素个数时,如果是将元素个数增多,可能会改变底层容量的大
    小,如果是将元素个数减少,底层空间总大小不变。
  4. reserve(size_t res_arg=0):为string预留空间,不改变有效元素个数,当reserve的参数小于
    string的底层空间总大小时,reserver不会改变容量大小。

3. string类对象的访问及遍历操作

函数名称 功能说明
operator[] (重点) 返回pos位置的字符,const string类对象调用
begin + end begin获取第一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
rbegin + rend rbegin获取最后一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
范围for C++11支持更简洁的范围for的新遍历方式
void TestString(){
 string s1("hello Bit");
 const string s2("Hello Bit");
 cout  << s1 << " " << s2 << endl;
 cout << s1[0] << " " << s2[0] << endl;

 s1[0] = 'H';
 cout << s1 << endl;
 // s2[0] = 'h'; 代码编译失败,因为const类型对象不能修改
}
void TestString(){
 string s("hello Bit");

 // 3种遍历方式:
 // 需要注意的以下三种方式除了遍历string对象,还可以遍历是修改string中的字符,
 // 另外以下三种方式对于string而言,第一种使用最多

 // 1. for+operator[]
 for(size_t i = 0; i < s.size(); ++i)
 cout << s[i] << endl;

 // 2.迭代器
 string::iterator it = s.begin();
 while(it != s.end()){
 cout << *it << endl;
 ++it;
 }

 string::reverse_iterator rit = s.rbegin();
 while(rit != s.rend())
 cout << *rit << endl;

 // 3.范围for
for(auto ch : s){
     cout << ch << endl;
}

4.string类对象的修改操作

函数名称 功能说明
push_back 在字符串后尾插字符c
append 在字符串后追加一个字符串
operator+= (重点) 在字符串后追加字符串str
c_str (重点) 返回C格式字符串
find + npos (重点) 从字符串pos位置开始往后找字符c,返回该字符在字符串中的位置
rfind 从字符串pos位置开始往前找字符c,返回该字符在字符串中的位置
substr 在str中从pos位置开始,截取n个字符,然后将其返回

示例代码:

void TestString(){
 string str;
 str.push_back(' '); // 在str后插入空格
 str.append("hello"); // 在str后追加一个字符"hello"
 str += 'b'; // 在str后追加一个字符'b'
 str += "it"; // 在str后追加一个字符串"it"
 cout<<str<<endl;
 cout<<str.c_str()<<endl; // 以C语言的方式打印字符串

 // 获取file的后缀
 string file1("string.cpp");
 size_t pos = file.rfind('.');
 string suffix(file.substr(pos, file.size()-pos));
 cout << suffix << endl;

 // npos是string里面的一个静态成员变量
 // static const size_t npos = -1;

 // 取出url中的域名
 sring url("http://www.cplusplus.com/reference/string/string/find/");
 cout << url << endl;
 size_t start = url.find("://");
 if (start == string::npos){
 cout << "invalid url" << endl;
 return;
 }
 start += 3;
 size_t finish = url.find('/', start);
 string address = url.substr(start, finish - start);
    cout << address << endl;

 // 删除url的协议前缀
 pos = url.find("://");
 url.erase(0, pos+3);
 cout<<url<<endl;
}

注意:

  1. 在string尾部追加字符时,s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多,一般
    情况下string类的+=操作用的比较多,+=操作不仅可以连接单个字符,还可以连接字符串。
  2. 对string操作时,如果能够大概预估到放多少字符,可以先通过reserve()把空间预留好。

5.string类非成员函数

函数 功能说明
operator+ 尽量少用,因为传值返回,导致深拷贝效率低
operator>> (重点) 输入运算符重载
operator<< (重点) 输出运算符重载
getline (重点) 获取一行字符串
relational operators (重点) 大小比较

+的重载不是string容器的成员,+=才是

getline()是为了解决cin输入字符串碰到空格就停的问题,getline()碰到回车才会停
getline()用法示例: getline(cin, str);

  • 深拷贝、浅拷贝、写时拷贝

当String类没有显式定义其拷贝构造函数与赋值运算符重载,此时编译器会合成默认的,当用s1构
造s2时,编译器会调用默认的拷贝构造。最终导致的问题是,s1、s2共用同一块内存空间,在释放时同一块
空间被释放多次而引起程序崩溃,这种拷贝方式,称为浅拷贝。

  • 浅拷贝

    (C语言中的所有拷贝方式都是浅拷贝)也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为还有效,所以 当继续对资源进项操作时,就会发生发生了访问违规。要解决浅拷贝问题,C++中引入了深拷贝。如图:浅拷贝:(C语言中的所有拷贝方式都是浅拷贝)也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为还有效,所以 当继续对资源进项操作时,就会发生发生了访问违规。要解决浅拷贝问题,C++中引入了深拷贝。如图:
    在这里插入图片述

    String(const char* str = ""){
    // 构造string类对象时,如果传递nullptr指针,认为程序非法,此处断言下
    if(nullptr == str){
    assert(false);
    return;
    }
    void TestString(){
    String s1("hello");
    String s2(s1);
    }
  • 深拷贝:

    如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情
    况都是按照深拷贝方式提供: 每个string类都要独立的空间来存放字符串, 深拷贝给每个对象独立分配资源, 保证多个对象间不会因共享资源而造成多次释放而导致程序崩溃问题 , 如图:
    在这里插入图片描述

    String(const String& s)
    :_str(new char[strlen(s._str)+1]){
    strcpy(_str, s._str);
    }
  • 写时拷贝

    写时拷贝就是一种拖延症,是在浅拷贝的基础之上增加了引用计数的方式来实现的。
    引用计数:用来记录资源使用者的个数。在构造时,将资源的计数给成1,每增加一个对象使用该资源,就给
    计数增加1,当某个对象被销毁时,先给该计数减1,然后再检查是否需要释放资源,如果计数为1,说明该
    对象时资源的最后一个使用者,将该资源释放;否则就不能释放,因为还有其他对象在使用该资源。(注意析构函数)

这个部分我觉得COOLSHELL的这两篇文章写得很好:
C++写时拷贝COPY-ON-WRITE技术
C++写时拷贝的读取效率缺陷

图例------《深入理解理解计算机系统》:
虚有对象是使用一种叫做写实拷贝(copy-on-write)的巧妙技术被映射到虚拟存储器中的。

string类的模拟实现

#include <iostream>
#include <cstring>
#include <cstdlib>
            using namespace std;
#define DEFAULTCAPA 16
#define COUNTCAPA(size)  (((size) / DEFAULTCAPA + 1) * DEFAULTCAPA)

            class String{
                char* m_data;
                size_t m_size;
                size_t m_capacity;
            public:
                String(const char* str = ""):
                        m_capacity(DEFAULTCAPA){
                    if(nullptr == str){
                        str = "";
                    }
                    /*    m_size = 0;
                    }*/
                    m_size = strlen(str);//要扩容
                    m_capacity = COUNTCAPA(m_size);
                    m_data = new char[m_capacity];
                    strncpy(m_data, str, m_size);
                }

                //拷贝构造
                String(String &s){
                    m_size = s.m_size;
                    m_capacity = s.m_capacity;
                    //m_data 深拷贝
                    m_data = new char[m_capacity];
                    strcpy(m_data, s.m_data);
                }

                String &operator=(const char* str){
                    m_size = strlen(str);
                    Reserve(m_size);
                    strcpy(m_data, str);
                    return *this;
                }

                String & operator=(String & s){
                    m_size = s.m_size;
                    Reserve(m_size);
                    strcpy(m_data, s.m_data);
                    return *this;
                }

                String(size_t n, char ch):
                        m_size(n),
                        m_capacity(DEFAULTCAPA){
                    Reserve(m_size);

                    m_data = new char[m_capacity];
                    //memset初始化
                    memset(m_data, ch, m_size);//也可以用循环写
                }

                ~String(){
                    if(m_data){
                        delete[] m_data;
                        m_data = nullptr;
        }
        m_size = m_capacity = 0;
    }

    size_t Size(){
        return m_size;
    }

    size_t Length(){
        return m_size;
    }

    size_t Capacity(){
        return m_capacity - 1;
    }

    bool Empty(){
        return m_size == 0;
    }

    void Clear(){
        m_size = 0;
    }

    void Resize(size_t size, char ch = '\0'){
        Reserve(size);
        if(m_size < size){
            memset(m_data + m_size, ch, size - m_size);
        }//清除
        m_size = size;
    }

    void Reserve(size_t size){
        if(size >= m_capacity){
            m_capacity = (size / DEFAULTCAPA + 1) * DEFAULTCAPA;
            m_data = (char*)realloc(m_data, m_capacity);

        }
    }

    char &operator[](int i){
        return m_data[i];
    }

    typedef char* iterator;
    iterator begin(){
        return m_data;
    }
    iterator end(){
        return m_data + m_size;
    }

    void push_Back(char ch){
        Reserve(m_size);
        m_data[m_size] = ch;
        m_size++;
    }
    void pop_Back(){
        if(!Empty()) {
            m_size--;
        }
    }

    String &operator+=(const char * str){
//        m_data[m_size] = '\0';
        int tmp = m_size;
        m_size += strlen(str);
        Reserve(m_size);

//        strcat(m_data, str);//strcat把str接到m_data
        strcpy(m_data + tmp, str);
        return *this;
    }

    String & operator+=(String & s){
//        m_data[m_size] = '\0';
        int tmp = m_size;
        m_size += s.m_size;
        Reserve(m_size);

//        strcat(m_data + m_size, s.m_data);
        strcpy(m_data + tmp, s.m_data);
        return *this;
    }

    const char* c_str(){
        return m_data;
    }

    size_t find(char ch, int pos = 0){
        if(pos < 0 || pos >= m_size){
            return -1;
        }
        char *tmp = strchr(m_data + pos, ch);
        if(tmp){
            return tmp - m_data;//减首位置就是他的位置
        }
        return -1;
    }

    size_t find(const char* str, int pos = 0){
        if(pos < 0 || pos >= m_size){
            return -1;
        }
        char *tmp = strstr(m_data + pos, str);
        if(tmp){
            return tmp - m_data;//减首位置就是他的位置
        }
        return -1;
    }

    size_t find(const String &s, int pos = 0){
        if(pos < 0 || pos >= m_size){
            return -1;
        }
        char *tmp = strstr(m_data + pos, s.m_data);
        if(tmp){
            return tmp - m_data;//减首位置就是他的位置
        }
        return -1;
    }

    String substr(size_t start, size_t num){
        String tmp;
        tmp.Resize(num);
        strncpy(tmp.m_data, m_data + start, num);
        return tmp;
    }

    String operator+(const char* str)const;//普通
    String operator+(const String &s)const;//在左
    friend String operator+(const char* str, const String &s);//在两边

    bool operator>(const char* str)const;
    bool operator<(const char* str)const;
    bool operator>=(const char* str)const;
    bool operator<=(const char* str)const;
    bool operator==(const char* str)const;
    bool operator!=(const char* str)const;

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

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

    friend ostream & operator<<(ostream& os, const String &s);
    friend istream & operator>>(istream& is, String &s);
};

ostream& operator<<(ostream& os, const String &s){
    int i;
    for(i = 0; i < s.m_size ; i++){
        os << s.m_data[i];
    }
    return os;
}

istream& operator>>(istream& is, String &s){
//    is >> s.m_data;//const
    char* tmp = new char[1024];
    is.getline(tmp, 1024);

    s.m_size = strlen(tmp);
    s.m_capacity = COUNTCAPA(s.m_size);
    delete[]s.m_data;
    s.m_data = tmp;

    /*strcpy(s.m_data, tmp);
    delete(tmp);*/

    return is;
}

String String::operator+(const char* str)const{
    String res;
    res.m_size = m_size + strlen(str);
    res.Reserve(res.m_size);

    strncpy(res.m_data, m_data, m_size);
    strcpy(res.m_data + m_size, str);
    return res;
}
String String::operator+(const String &s)const{
    String res;
    res.m_size = m_size + s.m_size;
    res.Reserve(res.m_size);

    strncpy(res.m_data, m_data, m_size);
    strncpy(res.m_data + m_size, s.m_data, s.m_size);
    return res;
}
String operator+(const char* str, const String &s){
    String res;
    res.m_size = strlen(str) + s.m_size;
    res.Reserve(res.m_size);

    strcpy(res.m_data, str);//注意前后顺序
    strncat(res.m_data, s.m_data, s.m_size);
    return res;
}

bool String::operator>(const char* str)const{
//    int tmp = strncmp(m_data, str, m_size);
//   if(tmp = 0 && strlen(str) > m_size){
//       return false;
//    }
//    return tmp > 0;
    return strncmp(m_data, str, m_size) > 0;

}
bool String::operator<(const char* str)const{
    int tmp = strncmp(m_data, str, m_size);
    if(!tmp && strlen(str) > m_size){
        return true;
    }
    return tmp;
}
bool String::operator>=(const char* str)const{
    return !(*this < str);
}
bool String::operator<=(const char* str)const{
    return !(*this >str);
}
bool String::operator==(const char* str)const{
    int tmp = strncmp(m_data, str, m_size);
    if(tmp == 0  && strlen(str) == m_size){
        return true;
    }
    return false;
}
bool String::operator!=(const char* str)const{
    return !(*this == str);
}

bool String::operator>(const String &s)const{
    int i;
    int minSize = m_size < s.m_size ? m_size : s.m_size;
    for(i = 0; i < minSize; i++){
        if(m_data[i] > s.m_data[i]){
            return true;
        }else if(m_data[i] < s.m_data[i]){
            return false;
        }
    }
    return m_size > s.m_size;
}
bool String::operator<(const String &s)const{
    int i;
    int minSize = m_size < s.m_size ? m_size : s.m_size;
    for(i = 0; i < minSize; i++){
        if(m_data[i] < s.m_data[i]){
            return true;
        }else if(m_data[i] > s.m_data[i]){
            return false;
        }
    }
    return m_size < s.m_size;
}
bool String::operator>=(const String &s)const{
    return !(*this < s);
}
bool String::operator<=(const String &s)const{
    return !(*this > s);
}
bool String::operator==(const String &s)const{
    int i;
    int minSize = m_size < s.m_size ? m_size : s.m_size;
    for(i = 0; i < minSize; i++){
        if(m_data[i] != s.m_data[i]){
            return false;
        }
    }
    return m_size == s.m_size;
}
bool String::operator!=(const String &s)const{
    return !(*this == s);
}

bool operator>(const char* str, const String &s){
    int tmp = strncmp(str, s.m_data, s.m_size);
    if(tmp == 0 && strlen(str) > s.m_size){
        return true;
    }
    return tmp > 0;
}
bool operator<(const char* str, const String &s){
    return strncmp(str, s.m_data, s.m_size) < 0;
}
bool operator>=(const char* str, const String &s){
    return !(str < s);
}
bool operator<=(const char* str, const String &s){
    return !(str > s);
}
bool operator==(const char* str, const String &s){
    int tmp = strncmp(s.m_data, str, s.m_size);
    if(tmp == 0  && strlen(str) == s.m_size){
        return true;
    }
    return false;
}
bool operator!=(const char* str, const String &s){
    return !(str == s);
}

L_KingMing

这个人太懒什么东西都没留下

文章评论(0)