【C++】String -- 详解(下)

简介: 【C++】String -- 详解(下)

【C++】String -- 详解(上)https://developer.aliyun.com/article/1514654?spm=a2c6h.13148508.setting.31.4b904f0ejdbHoA

⚪VS 下 string 的结构

string 总共占 28 个字节,内部结构稍微复杂一点,先是有一个联合体,联合体用来定义 string 中字 符串的存储空间

  • 当字符串长度小于 16 时,使用内部固定的字符数组来存放。
  • 当字符串长度大于等于 16 时,从堆上开辟空间。
union _Bxty
{   // storage for small buffer or pointer to larger one
    value_type _Buf[_BUF_SIZE];
    pointer _Ptr;
    char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;

这个联合体的目的是为了在存储较小的数据时使用数组,而在存储较大的数据时使用指针。通过使用联合体,可以在相同的内存空间中灵活地存储不同类型的数据。

注意:联合体的成员变量共享同一块内存空间,因此在使用时需要确保对应的成员变量是有效的。

这种设计也是有一定道理的,大多数情况下字符串的长度都小于 16,那 string 对象创建好之后,内部已经有了 16 个字符数组的固定空间,不需要通过堆创建,效率高。

其次,还有一个 size_t 字段保存字符串长度,占用4个字节, 一个 size_t 字段保存从堆上开辟空间总的容量,占用4个字节

最后,还有一个指针做一些其他事情,占用4个字节

故总共占 16+4+4+4=28 个字节。


⚪G++ 下 string 的结构

G++ 下,string 是通过写时拷贝实现的,string 对象总共占 4 个字节,内部只包含了一个指针,该指针将来指向一块堆空间,内部包含了如下字段:

  • 空间总大小
  • 字符串有效长度
  • 引用计数
struct _Rep_base
{
    size_type _M_length;
    size_type _M_capacity;
    _Atomic_word _M_refcount;
};
  • 指向堆空间的指针,用来存储字符串。

二、string类的模拟实现

模拟实现 string 类,最主要是实现 string 类的构造、拷贝构造、赋值运算符重载以及析构函数。


1、浅拷贝

浅拷贝 :也称位拷贝,编译器只是将 对象中的数据 按字节序拷贝过来。 如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为 还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。

// 为了和标准库区分,此处使用String
class String
{        
public:
    // 构造函数
  String(const char* pStr = "")
    {
        // 构造String类对象时,如果传递nullptr指针,可以认为程序非法
        if (nullptr == pStr)
        {
            assert(false);
            return;
        }
        _pStr = new char[strlen(pStr) + 1];
        strcpy(_pStr, pStr);
    }
    
    // 析构函数
    ~String()
    {
    if (_pStr)
        {
            delete[] _pStr;
            _pStr = nullptr;
        }
  }
private:
    char* _str;
};
 
void test()
{
  string s1("hello"); // 用一个常量字符串去构造string类对象s1
  string s2(s1);      // s2调用编译器默认生成的拷贝构造函数
}

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

这里必须是深拷贝,编译器默认生成的拷贝构造函数是浅拷贝,会导致两个 string 对象中的字符指针 _str 指向的是同一个字符数组。(因为浅拷贝只拷贝了 _str 数组指针的 4 个字节的内容)。

所以在上述类中必须要显式定义拷贝构造函数,否则编译器默认生成的拷贝构造函数无法正常完成拷贝。

那么我们可以 采用深拷贝解决浅拷贝问题 ,即:每个对象都有一份独立的资源,不要和其他对象共享

浅拷贝引发的问题

  1. 同一块空间会被析构多次。
  2. 一个对象修改会影响另外一个对象。

2、深拷贝

如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

深拷贝:给每个对象独立分配资源,保证多个对象之间不会因为共享资源问题而造成多次释放资源,导致程序崩溃。


(1)传统版写法的 String 类(拷贝构造&赋值运算符重载
class String
{
public:
    String(const char* str = "")
    {
        // 构造String类对象时,如果传递nullptr指针,可以认为程序非法
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
 
    // 拷贝构造
    String(const String& s) // 保护形参不被改变,加引用防止无穷递归
        : _str(new char[strlen(s._str) + 1]) // 给新对象申请一段和原对象一样大小的空间
    {
        strcpy(_str, s._str); // 把原对象的数据一一拷贝给新对象
    }
 
    // 赋值运算符重载构造
    String& operator=(const String& s)
    {
        if (this != &s) // 防止自己给自己赋值
        {
            char* pStr = new char[strlen(s._str) + 1]; // 重新开辟一块和s一样大小的空间
            delete[] _str;                             // 释放自己的空间
            _str = pStr;
            strcpy(pStr, s._str);                      // 把s的数据拷贝过来
        }
        return *this;
    }
 
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};
如果 new 开辟空间失败了怎么办?

所以我们先开辟空间,如果开辟空间没有失败,再去释放自己的空间。


(2)现代版写法的String类拷贝构造&赋值运算符重载

传统写法和现代写法的区别:

  • 传统写法:想要做深拷贝,都是自己去做,自己去开辟空间,自己去拷贝想要的内容。
  • 现代写法:想要做深拷贝,不是自己去做,而是去构造一个的新的临时对象,临时对象中的内容就是自己想要的内容,然后将临时对象与当前对象的成员变量分别进行交换,这样当前的对象就拿到了自己想要的内容,当函数调用结束后,临时对象出了作用域就会被自动析构。

拷贝构造函数的深拷贝(现代写法):

赋值运算符重载函数的深拷贝(现代写法):

class String
{
public:
    String(const char* str = "")
    {
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
 
    // 拷贝构造函数
    String(const String& s)
        : _str(nullptr) // 当前对象是一个正在构造的对象,成员变量还未初始化,是一个随机值,所以先置空
    {
        String strTmp(s._str);   // 拿s的内容,调用构造函数构造临时对象strTmp
        swap(_str, strTmp._str); // 将临时对象strTmp和当前对象的成员变量_str进行交换
    }
 
    // 写法一(更好)
    String& operator=(String s) //传值
    {
        // 传参时,调用拷贝构造函数,拷贝构造了一个string类对象s
 
        // 将拷贝构造出来的string类对象s和当前对象的成员变量_str进行交换
        swap(_str, s._str);
        return *this; // 返回当前对象
    }
 
    // 写法二
    //String& operator=(const String& s) // 传引用
    //{
    //    if(this != &s) // 防止自己给自己赋值
    //    {
    //        String strTmp(s); // 拿s的内容,调用构造函数构造临时对象strTmp 
    //        swap(_str, strTmp._str); // 将临时对象strTmp 和当前对象的成员变量_str进行交换
    //    }
    //    return *this;
    //}
 
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

赋值运算符重载函数的深拷贝中的方法二的缺点:需要进行额外的判断和创建临时对象,增加了代码的复杂度和开销。


(3)string 类的结构

string 是对字符串进行管理的类。实际上就是一个管理字符数组顺序表

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;
 
namespace xyl
{
    class string
    {
  public:
        // 迭代器
        typedef char* iterator;
        typedef const char* const_iterator;
        iterator begin() { return _str; }         // 返回指向第一个字符的迭代器
        iterator end() { return _str + _size; }   // 返回指向最后一个字符下一个字符的迭代器
        const_iterator begin() const { return _str; }       // 返回指向第一个字符的迭代器
        const_iterator end() const { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器
 
 
        // 默认成员函数:
        string(const char* str = ""); // 默认构造函数
        void swap(string& s);         // 交换两个对象的内容
        string(const string& s);      // 拷贝构造函数(深拷贝)
        string& operator=(string s);  // 赋值运算符重载(深拷贝)
        ~string(); // 析构函数
 
 
        // 访问元素([]运算符重载)     
        char& operator[](size_t pos);             // 可读可写
        const char& operator[](size_t pos) const; // 只读不能写
 
 
    // 容量操作:             
        size_t size() const { return _size; }         // 获取字符串有效元素个数
        size_t capacity() const { return _capacity; } // 获取字符串容量(有效字符的最大容量)       
        void clear() { _str[0] = '\0'; _size = 0; }   // 清空有效字符       
        void reserve(size_t n);                       // 更改容量(capacity)的大小
        void resize(size_t n, char ch = '\0');        // 调整字符串有效字符的长度
 
 
        // 修改操作:        
        string& insert(size_t pos, const char ch);     // 在pos位置插入一个字符       
        string& insert(size_t pos, const char* str);   // 在pos位置插入一个字符串        
        void push_back(const char ch);                 // 尾插一个字符        
        void append(const char* str);                  // 在当前字符串末尾追加一个字符串        
        string& operator+=(const char ch);             // 当前字符串末尾追加一个字符
        string& operator+=(const char* str);           // 当前字符串末尾追加一个字符串
        string& operator+=(const string& s);           // 当前字符串末尾追加一个字符/字符串                
        string& erase(size_t pos = 0, size_t len = npos); // 删除从pos位置开始的len个字符
        
 
        // String operations               
        size_t find(char ch, size_t pos = 0) const; // 从pos位置开始查找字符,若找到,则返回该字符的下标,若没找到,则返回npos  
        size_t find(const char* str, size_t pos = 0) const; // 从pos位置开始查找子串,若找到,则返回该子串首字符的下标,若没找到,则返回npos       
        char* c_str() const { return _str; } // 返回指向 C 格式字符串的数组的指针
 
 
    private:
        char* _str;       // 指向字符数组
        size_t _size;     // 有效字符数
        size_t _capacity; // 有效字符容量,不包含最后作标识的'\0'
        static const size_t npos;
    };
 
    const size_t string::npos = -1;
};

(4)写时拷贝

写时拷贝 就是一种拖延症,是在浅拷贝的基础之上增加了引用计数的方式来实现的。

引用计数:用来记录资源使用者的个数。在构造时,将资源的计数给成 1,每增加一个对象使用该资源,就给计数增加 1,当某个对象被销毁时,先给该计数减 1,然后再检查是否需要释放资源,如果计数为 1,说明该对象时资源的最后一个使用者,将该资源释放;否则就不能释放,因为还有其他对象在使用该资源。


(5)string类的模拟实现
#pragma once
 
#include <iostream>
#include <assert.h>
using namespace std;
 
namespace xyl
{
  class string
  {
  public:
    typedef char* iterator;
 
  public:
        // 默认构造函数
        string(const char* str = "")  // 空串并不是什么都没有,第一个字符为'\0'
            :_size(strlen(str))
          ,_capacity(_size)
        {
          _str = new char[_capacity + 1]; // +1是确保有足够的空间存储字符串,因为还需要额外的一个字节来存储'\0'
          strcpy(_str, str);              // 拷贝数据
        }
 
    // 拷贝构造函数(深拷贝)
        // s2(s1)
        string(const string& s)
            :_str(nullptr) // 当前对象是一个正在构造的对象,成员变量还未初始化,是一个随机值,所以先置空
          ,_size(0)
          ,_capacity(0)
        {
          string tmp(s._str); // 拿s的内容,调用构造函数构造临时对象tmp
          this->swap(tmp);    // 将临时对象tmp和当前对象的成员变量分别进行交换
        }
 
    // 赋值运算符重载(深拷贝)
        // s1 = s2
        string& operator=(string s)
        {
            this->swap(s); // 将拷贝构造的对象s和当前对象的成员变量分别进行交换
            return *this;  // 返回当前对象
        }
 
    // 析构函数
        ~string()
        {
            delete[] _str;
            _str = nullptr;
        }
 
 
    // iterator
    iterator begin()
    {
      return _str;
    }
    iterator end()
    {
      return _str + _size;
    }
 
    
    // modify
        // 在pos位置上插入字符c,并返回该字符的位置
        // 在pos位置插入一个字符
        string& insert(size_t pos, const char ch)
        {
            assert(pos >= 0 && pos <= _size);
        
            if (_size == _capacity) // 先检查是否需要扩容
            {
                // 防止是空串"",容量为0,扩容失败
                size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
 
                reserve(newcapacity);
            }
            // 挪动字符
            for (size_t i = _size + 1; i > pos; i--) // 注意
            {
                _str[i] = _str[i - 1];
            }
            _str[pos] = ch; // 插入字符
            _size++;        // 有效字符个数+1
 
            return *this;
        }
 
        // 在pos位置插入一个字符串
        string& insert(size_t pos, const char* str)
        {
            assert(pos >= 0 && pos <= _size);
            
            size_t len = strlen(str);
            if (_size + len >= _capacity) // 先检查是否需要扩容
            {
                reserve(_size + len);
            }
 
            // 挪动字符
            for (size_t i = _size + len; i >= pos + len; i--)
            {
                _str[i] = _str[i - len];
            }
            // 插入字符
            for (size_t i = 0; i < len; i++)
            {
                _str[pos++] = str[i];
            }
            _size += len; // 更新有效字符个数
 
            return *this;
        }
 
    void push_back(char c)
    {
      / *if (_size >= _capacity) // 先检查是否需要扩容
      {
        // 防止是空串"",容量为0,扩容失败
                size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
 
                reserve(newcapacity); // 扩2倍容
      }     
      _str[_size] = c;    // 尾插字符
            _size++;            // 有效字符个数+1
            _str[_size] = '\0'; // 补上字符串结束标志'\0' */
 
            insert(_size, ch);
    }
 
        string& erase(size_t pos = 0, size_t len = npos)
        {
            assert(pos >= 0 && pos < _size);
 
            // 1. 从pos位置开始,后面的字符删除完,这是一个O(1)的操作
            if (len == npos || pos + len >= _size)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            // 2. 从pos位置开始,后面的字符删除一部分,这是一个O(n)的操作
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
            return *this;
        }
 
 
    string& operator+=(const char c)
        {
            push_back(c);
            return *this;
        }
        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }
        string& operator+=(const string& s)
        {
            append(s._str);
            return *this;
        }
 
 
    void append(const char* str)
        {            
            /* size_t len = strlen(str);
            if (_size + len > _capacity) // 先检查是否需要扩容
            {
                reserve(_size + len); // 扩容
            }
            strcpy(_str + _size, str); // 尾插字符串(strcpy会拷贝'\0',并在该点停止)
            _size += len;              // 有效字符个数+len */
          
            insert(_size, str);
        }
 
 
    void clear()
    {
      _size = 0;
      _str[_size] = '\0';
    }
 
 
        // s1.swap(s2);
        void swap(string& s)
        {
            // 函数名冲突,指定去调用全局域里面的::swap
            ::swap(_str, s._str);
            ::swap(_size, s._size);
            ::swap(_capacity, s._capacity);
        }
 
 
    // capacity
    size_t size()const
    {
      return _size;
    }
    size_t capacity()const
    {
      return _capacity;
    }
    bool empty()const
    {
      return 0 == _size;
    }
 
 
        // 调整字符串有效字符的长度
        void resize(size_t n, char ch = '\0')
        {
            // 要调整的有效字符的长度小于原有_size大小
            if (n < _size)
            {
                _size = n;          // 更新有效字符个数
                _str[_size] = '\0'; // 补上字符串结束标志'\0'
            }
            // 要调整的有效字符的长度大于原有_size大小
            else if (n > _size)
            {
                // 要调整的有效字符的长度大于原有_capacity大小,先进行增容
                if (n > _capacity) reserve(n);
 
                // 多出的位置用字符ch(缺省值'\0')进行填充
                for (size_t i = _size; i < n; i++)
                {
                    _str[i] = ch;
                }
                _size = n;          // 更新有效字符个数
                _str[_size] = '\0'; // 补上字符串结束标志'\0'
            }
        }
 
 
        // 更改容量(capacity)的大小
        void reserve(size_t n)
        {
            if (n > _capacity) // 如果新容量大于旧容量,则开辟空间
            {
                // 开辟新空间
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);  // 旧空间数据拷贝到新空间
 
                // 释放旧空间,使用新空间
                delete[] _str;
                _str = tmp;    // 指向新空间
                _capacity = n; // 更新容量
            }
        }
 
 
    // access
    char& operator[](size_t index) // 用于访问字符串中指定位置的字符
    {
      assert(index < _size);
      return _str[index];
    }
 
 
    // 普通版本和const版本
        char& operator[](size_t pos) // 可读可写
        {
            assert(pos < _size);
            return _str[pos]; // *(_str + pos)
        }
        const char& operator[](size_t pos) const // 只读不能写
        {
            assert(pos < _size);
            return _str[pos]; // *(_str + pos)
        }
 
    
    // 比较两个对象的大小(按字符ascii码比较)
        // s1 > s2
        bool operator>(const string& s1, const string& s2)
        {
            // 指针 i 和 j 分别指向两个字符串的第一个字符
            size_t i = 0, j = 0;
            for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串
            {
                if (s1[i] != s2[j]) return s1[i] > s2[j];
            }
 
            if (i == s1.size() && j == s2.size()) return false; // 同时被遍历完,说明 s1 = s2
            else if (i == s1.size()) return false; // s1先被遍历完,说明 s1 < s2
            else if (j == s2.size()) return true;  // s2先被遍历完,说明 s1 > s2
        }
 
        // s1 == s2
        bool operator==(const string& s1, const string& s2)
        {
            // 指针 i 和 j 分别指向两个字符串的第一个字符
            size_t i = 0, j = 0;
            for (; i < s1.size() && j < s2.size(); i++, j++) // 同时遍历两个字符串
            {
                if (s1[i] != s2[j]) return false;
            }
 
            if (i == s1.size() && j == s2.size()) return true; // 同时被遍历完,说明 s1 = s2
            else return false; // 有一个字符串没被遍历完
        }
 
        // 下面的关系运算符重载,全都可以复用上面的代码
        // s1 != s2
        bool operator!=(const string& s1, const string& s2) { return !(s1 == s2); }
        // s1 >= s2
        bool operator>=(const string& s1, const string& s2) { return s1 > s2 || s1 == s2; }
        // s1 < s2
        bool operator<(const string& s1, const string& s2) { return !(s1 >= s2); }
        // s1 <= s2
        bool operator<=(const string& s1, const string& s2) { return !(s1 > s2); }
 
 
    // 返回c在string中第一次出现的位置
    size_t find(char c, size_t pos = 0) const
        {
            assert(pos >= 0 && pos < _size);
 
            for (size_t i = pos; i < _size; i++)
            {
                if (_str[i] == c) return i;
            }
            return npos;
        }
 
    // 返回子串s在string中第一次出现的位置
    size_t find(const char* s, size_t pos = 0) const
        {
            assert(pos >= 0 && pos < _size);
 
            // 在原串中去匹配子串s
            // 匹配成功,返回子串s首字符的地址
            // 匹配失败,返回空指针
            const char* p = strstr(_str + pos, s);
 
            if (p) return p - _str; // 通过子串s首字符的地址,计算出首字符的下标
            else return npos;
        }
 
  private:
    friend ostream& operator<<(ostream& _cout, const xyl::string& s);
    friend istream& operator>>(istream& _cin, xyl::string& s);
  private:
    char* _str;
    size_t _capacity;
    size_t _size;
  };
 
  ostream& operator<<(ostream& _cout, const xyl::string& s)
  {
    // 不能使用cout, 因为string的字符串内部可能会包含\0
    // 直接cout时, 是将_str当成char*打印的,遇到内部的\0时后序内容就不打印了
    //cout << s._str;
    for (size_t i = 0; i < s.size(); ++i)
    {
      _cout << s[i];
    }
    return _cout;
  }
 
    istream& operator>>(istream& _cin, string& s)
    {
        // 一个一个字符输入
        // 遇到空格或者换行符终止输入
        char c;
        _cin >> c; // 从流中获取一个字符
        while (c != ' ' && c != '\n')
        {
            s += c;  // 把提取的字符追加到sting类对象s中去
            _cin >> c; // 继续从流中获取下一个字符
        }
        return _cin;
    }
}
 
 
int main()
{
  xyl::string s1("hello");
  s1.push_back(' ');
  s1.push_back('w');
  s1.push_back('o');
  s1.push_back('r');
  s1 += 'l';
  s1 += 'd';
  cout << s1 << endl;            //hello world
  cout << s1.size() << endl;     //11
  cout << s1.capacity() << endl; //20
 
  // 利用迭代器打印string中的元素
  xyl::string::iterator it = s1.begin();
  while (it != s1.end())
  {
    cout << *it;
    ++it;
  }
  cout << endl;
 
  // 这里可以看到一个类只要支持的基本的iterator,就支持范围for
  for (auto ch : s1)
  {
    cout << ch;
  } 
  cout << endl;
    return 0;
}


相关文章
|
2天前
|
C++
C++ string中的函数和常用用法
C++ 中string中的函数和常用用法
11 4
|
18天前
|
C语言 C++
【C++】string模拟实现(下)
本文档介绍了自定义`string`类的一些关键功能实现,包括`reserve()`用于内存管理,`push_back()`和`append()`添加字符或字符串,运算符`+=`的重载,以及`insert()`, `erase()`进行插入和删除操作。此外,还涵盖了`find()`查找函数,字符串的比较运算符重载,`substr()`获取子串,`clear()`清除内容,以及流插入和提取操作。常量`npos`用于表示未找到的标记。文档以代码示例和运行结果展示各功能的使用。
|
18天前
|
编译器 程序员 C语言
【C++】string模拟实现
这篇博客探讨了自定义实现C++ `string` 类的关键功能,包括构造、拷贝构造、赋值运算符重载及析构函数。作者强调了理解并实现这些功能对于面试的重要性。博客介绍了`string` 类的头文件`string.h`,其中定义了迭代器、基本成员函数如`swap()`、`size()`、`c_str()`等,并提到了深拷贝概念。此外,还展示了构造函数、析构函数和赋值运算符的实现,以及迭代器的定义与使用。博客还包括对C语言字符串函数的引用,以辅助读者理解实现细节。
|
18天前
|
编译器 C++
【C++】string类的使用④(字符串操作String operations )
这篇博客探讨了C++ STL中`std::string`的几个关键操作,如`c_str()`和`data()`,它们分别返回指向字符串的const char*指针,前者保证以&#39;\0&#39;结尾,后者不保证。`get_allocator()`返回内存分配器,通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组,不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量,表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
|
18天前
|
存储 C++
【C++】string类的使用③(非成员函数重载Non-member function overloads)
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容,包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容,成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接,关系运算符(如`==`, `&lt;`等)用于比较字符串,以及`swap`非成员函数。此外,还介绍了`getline`函数,用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用,并给出了多个示例代码。
|
26天前
|
C++ 容器
C++字符串string容器(构造、赋值、拼接、查找、替换、比较、存取、插入、删除、子串)
C++字符串string容器(构造、赋值、拼接、查找、替换、比较、存取、插入、删除、子串)
23 1
|
18天前
|
C++
【C++】string类的使用④(常量成员Member constants)
C++ `std::string` 的 `find_first_of`, `find_last_of`, `find_first_not_of`, `find_last_not_of` 函数分别用于从不同方向查找目标字符或子串。它们都返回匹配位置,未找到则返回 `npos`。`substr` 用于提取子字符串,`compare` 则提供更灵活的字符串比较。`npos` 是一个表示最大值的常量,用于标记未找到匹配的情况。示例代码展示了这些函数的实际应用,如替换元音、分割路径、查找非字母字符等。
|
18天前
|
C++
C++】string类的使用③(修改器Modifiers)
这篇博客探讨了C++ STL中`string`类的修改器和非成员函数重载。文章介绍了`operator+=`用于在字符串末尾追加内容,并展示了不同重载形式。`append`函数提供了更多追加选项,包括子串、字符数组、单个字符等。`push_back`和`pop_back`分别用于在末尾添加和移除一个字符。`assign`用于替换字符串内容,而`insert`允许在任意位置插入字符串或字符。最后,`erase`函数用于删除字符串中的部分内容。每个函数都配以代码示例和说明。
|
18天前
|
安全 编译器 C++
【C++】string类的使用②(元素获取Element access)
```markdown 探索C++ `string`方法:`clear()`保持容量不变使字符串变空;`empty()`检查长度是否为0;C++11的`shrink_to_fit()`尝试减少容量。`operator[]`和`at()`安全访问元素,越界时`at()`抛异常。`back()`和`front()`分别访问首尾元素。了解这些,轻松操作字符串!💡 ```
|
18天前
|
存储 编译器 Linux
【C++】string类的使用②(容量接口Capacity )
这篇博客探讨了C++ STL中string的容量接口和元素访问方法。`size()`和`length()`函数等价,返回字符串的长度;`capacity()`提供已分配的字节数,可能大于长度;`max_size()`给出理论最大长度;`reserve()`预分配空间,不改变内容;`resize()`改变字符串长度,可指定填充字符。这些接口用于优化内存管理和适应字符串操作需求。