首页 > 其他分享 >string类

string类

时间：2024-12-27 21:31:35浏览次数：8  
标签：const string pos char str size

为什么学习string类？

1.1 C 语言中的字符串 C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。 1.2 面试题 在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本 都使用string类，很少有人去使用C库中的字符串操作函数。    

标准库中的string类

推荐一个c++函数网站：cplusplus

2.1 string 类 ( 了解 ) https://cplusplus.com/reference/string/string/?kw=string（可复制链接查看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 头文件以及 using namespace std;  

string类常用接口

1. string类对象的常见构造

6a232d6d53414dfda324b2e863ea37a2.jpeg

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

2. string类对象的容量操作

3878101e50a84df089b7317308f02faa.png   注意： 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类对象的访问及遍历操作

5150bf6a67864475a210a18b8a689954.png  

 

4. string类对象的修改操作

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

5. string类非成员函数

  65e1d1e9f65b439d9590ec37f86e726c.png   上面的几个接口大家了解一下，OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。  

string类的模拟实现完整代码

（注意，const string会匹配const 迭代器，返回const char* ，不能修改字符串。const operator[]，不能修改那个位置的字符.

非const string 会匹配正常迭代器，返回char*  ，可以修改字符串，operator[]，返回char＆可以修改那个位置的字符）

string.h

#include<assert.h>
#include<iostream>

using namespace std;

namespace jzy
{
	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;
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}

		string(const char* str = "");
		// ִд
		string(const string& s);
		string& operator=(string s);
		~string();

		const char& operator[](size_t pos) const;
		char& operator[](size_t pos);
		void reserve(size_t n);
		void push_back(char ch);

		void append(const char* str);
		string& operator+=(char ch);
		string& operator+=(const char* str);

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		void erase(size_t pos, size_t len = npos);
		void swap(string& s);
		size_t find(char ch, size_t pos = 0);
		//21:10
		size_t find(const char* str, size_t pos = 0);
		string substr(size_t pos = 0, size_t len = npos);
		void clear();

	private:
		size_t _capacity = 0;
		size_t _size = 0;
		char* _str = nullptr;

		const static size_t npos = -1;
	};

	istream& operator>>(istream& in, string& s);
	ostream& operator<<(ostream& out, const string& s);
}

string.cpp

#include"string.h"


namespace jzy
{
	string::string(const char* str)
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];

		strcpy(_str, str);
	}

    //拷贝构造现代写法
	string::string(const string& s)
	{
		string tmp(s._str);
		swap(tmp);
	}
   //赋值重载现代写法
	string& string::operator=(string s)
	{
		swap(s);

		return *this;
	}

	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = 0;
		_capacity = 0;
	}

	const char& string::operator[](size_t pos) const
	{
		assert(pos <= _size);

		return _str[pos];
	}

	char& string::operator[](size_t pos)
	{
		assert(pos <= _size);

		return _str[pos];
	}

	void string::reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}

	void string::push_back(char ch)
	{
		if (_size == _capacity)
		{
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newCapacity);
		}

		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';
	}

	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}

		strcpy(_str + _size, str);
		_size += len;
	}

	string& string::operator+=(char ch)
	{
		push_back(ch);

		return *this;
	}

	string& string::operator+=(const char* str)
	{
		append(str);

		return *this;
	}

	void string::insert(size_t pos, char ch)
	{
		assert(pos <= _size);

		if (_size == _capacity)
		{
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newCapacity);
		}

		/*int end = _size;
		while (end >= (int)pos)
		{
			_str[end + 1] = _str[end];
			--end;
		}*/

		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}

		_str[pos] = ch;
		_size++;
	}

	void string::insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}

		int end = _size;
		while (end >= (int)pos)
		{
			_str[end + len] = _str[end];
			--end;
		}

		strncpy(_str + pos, str, len);
		_size += len;
	}

	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);

		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}

	void string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}

	size_t string::find(char ch, size_t pos)
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
			{
				return i;
			}
		}

		return npos;
	}

	//21:10
	size_t string::find(const char* str, size_t pos)
	{
		const char* ptr = strstr(_str + pos, str);
		if (ptr == nullptr)
		{
			return npos;
		}
		else
		{
			return ptr - _str;
		}
	}

	string string::substr(size_t pos, size_t len)
	{
		assert(pos < _size);
		size_t end = pos + len;
		if (len == npos || pos + len >= _size)
		{
			end = _size;
		}

		string str;
		str.reserve(end - pos);
		for (size_t i = pos; i < end; i++)
		{
			str += _str[i];
		}

		return str;
	}

	void string::clear()
	{
		_size = 0;
		_str[0] = '\0';
	}


	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}

		return out;
	}

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char buff[128];
		char ch = in.get();
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}

			ch = in.get();
		}

		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}
}

test.cpp


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

namespace jzy
{
	void print_str(const string& s)
	{
		for (size_t i = 0; i < s.size(); i++)
		{
			
			cout << s[i] << " ";
		}
		cout << endl;

		string::const_iterator it = s.begin();
		while (it != s.end())
		{
			

			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

	void test_string1()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		string s2;
		cout << s2.c_str() << endl;

		for (size_t i = 0; i < s1.size(); i++)
		{
			s1[i]++;
		}
		cout << s1.c_str() << endl;

		string::iterator it = s1.begin();
		while (it != s1.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto ch : s1)
		{
			cout << ch << " ";
		}
		cout << endl;

		print_str(s1);
	}

	void test_string2()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		s1 += ' ';
		s1 += "xxxxxx";
		cout << s1.c_str() << endl;

		s1.insert(5, 'y');
		s1.insert(5, 'y');
		s1.insert(5, 'y');
		cout << s1.c_str() << endl;

		s1.insert(0, 'y');
		cout << s1.c_str() << endl;

		s1.insert(0, "zzzzzzz");
		cout << s1.c_str() << endl;
	}

	void test_string3()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		s1.erase(5, 4);
		cout << s1.c_str() << endl;

		s1.erase(5, 100);
		cout << s1.c_str() << endl;

		s1.erase(2);
		cout << s1.c_str() << endl;
	}

	void test_string4()
	{
		string s1("hello world");
		string s2("xxxx");
		std::swap(s1, s2);
		s1.swap(s2);


		string str("https://legacy.cplusplus.com/reference/string/string/substr/");
		string sub1, sub2, sub3;
		size_t pos1 = str.find(':');
		sub1 = str.substr(0, pos1 - 0);
		cout << sub1.c_str() << endl;

		size_t pos2 = str.find('/', pos1 + 3);
		sub2 = str.substr(pos1 + 3, pos2 - (pos1 + 3));
		cout << sub2.c_str() << endl;

		sub3 = str.substr(pos2 + 1);
		cout << sub3.c_str() << endl;
	}

	void test_string5()
	{
		string s1("hello world");
		string s2(s1);

		string s3("xxxx");
		s1 = s3;
	}


	void test_string6()
	{
		string s1("hello world");
		string s2(s1);

		string s3("xxxx");
		s1 = s3;

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

		cin >> s1;
		cout << s1 << endl;

		/*char ch1, ch2;
		cin >> ch1 >> ch2;*/

		cin >> s2;
		cout << s2 << endl;
	}

	void test_string7()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;
		cout << s1 << endl;

		s1.clear();
		cout << s1.c_str() << endl;
		cout << s1 << endl;
	}

	void test_string8()
	{
		string s1("hello world");
		string s2(s1);

		cout << s1 << endl;
		cout << s2 << endl;

		string s3("xxxxxxxxxxxxxxxx");
		s1 = s3;
		cout << s1 << endl;
		cout << s3 << endl;
	}
}




int main()
{
	jzy::test_string2();
return 0;
}

 

                     

 

标签：const,string,pos,char,str,size
From： https://blog.csdn.net/eixjdj/article/details/144750501

相关文章

  • String类是否可以被继承？int是否可以被继承
    不能，因为String类是被final修饰的类型，final类是不能被继承的，String类是不可变类型(Immutable)类。至于为什么要加final或将String类设置成不可变类，主要是两点：第一个原因是线程安全：不可变对象始终是线程安全的，因为线程必须完全构建它们，然后才能将它们传递给其他人——并且在构建......
  • string和stringBuilider的区别
    string和StringBuilder在C#中用于处理字符串，但它们在性能和使用场景上有显著的区别。以下是详细的比较和解释：1.值类型vs引用类型string：类型：值类型（valuetype），但实际存储在托管堆（managedheap）上。不可变性：string是不可变的（immutable），一旦创建就不能修改。任何对stri......
  • java8--方法--String--格式化--format
    1.程序：packageInputTest;importjava.util.Scanner;publicclassInputTest021227{publicstaticvoidmain(String[]args){//English();Chiness();}publicstaticvoidEnglish(){Scannerin=newScanner(System......
  • 如何在Windows上正确启用PHP的mbstring扩展？
    1.确保 php_mbstring.dll 文件存在首先，你需要确认你的PHP安装目录中确实包含了php_mbstring.dll文件。通常情况下，这个文件位于PHP安装目录下的ext文件夹中。如果你没有找到这个文件，可能是因为你下载的PHP版本默认没有包含这个扩展。此时，你可以考虑重新下载一个完整的PHP安装包......
  • 一维数组、多维数组、Array（deepToString sort fill binarySearch）方法2024122620241
    数组20241226[数组详情](深入理解Java数组-静默虚空-博客园)什么是数组：数组是相同类型数据的有序集合注意：必须是相同数据数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成其中,每一个数据称作一个数组元素。每个数组元素可以通过一个下标来访问......
  • string
    字符串指定位置获取字符串本质时char数组字符串转char数组char[]chars=str.ToCharArray();字符串拼接str=string.Format("{0}{1}",robot,1);正向查找字符的位置str="robot";//会返回2intindex=str.IndexOf("o");//如果没找到这样的字符默认会返回-1反向......
  • 字符串（String）
    在Python3中，字符串（String）是一种表示文本数据的核心数据类型。字符串可以包含字母、数字、符号和空格等字符，并且在Python中被广泛使用。以下是关于Python3字符串的详细讲解：1.定义字符串字符串可以用以下三种方式定义：单引号（'）双引号（"）三引号（'''或"""）示例：#使用单......
  • 【C/C++】字符数组和string字符串：从C语言到C++的演变
    字符数组和string字符串：从C语言到C++的演变在C语言和C++的编程中，字符数组和字符串（string）是非常重要的基础数据类型。它们在实际编程中常用于存储和操作文本数据，但是这两种类型的处理方式有所不同。在这篇博客中，我们将详细讲解字符数组和string字符串，从C语言的字符数组到C++......
  • substring( )的两种用法？
    xx.substring()括号中带的参数不一样，效果就会有很大的区别1.xx.substring(0,2)表示取第一个和第二个字符（0,1,2表示第一、二、三个字符，含头不含尾的原则就只包含第一、二个字符），返回一个新的字符串（只包含指定的第一和第二个字符）；2.xx.substring(2)表示去掉前两个字符，返回一个新的字......
  • 【Java教程】Day5-01 核心类：String 字符串全面解析
    在Java中，String 是一个非常常用的数据类型，它代表一个字符串。不同于其他类型，String 是一个引用类型，实际在内存中由一个字符数组（char[]）来表示。Java的 String 类提供了很多功能强大的方法来操作字符串数据，本篇文章将深入解析 String 类型的相关知识，帮助你更好地理解和......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99