C++手写自定义实现string类

最新推荐文章于 2022-11-28 11:23:38 发布
最新推荐文章于 2022-11-28 11:23:38 发布
阅读量2.8k 收藏 41
点赞数 9
分类专栏： c++技术文档 文章标签： 手动实现String类 重载 重载操作运算符 字符串的实现 开辟空间
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011870022/article/details/96643017
版权 
     我们知道，C++给我们提供封装好了一个强大的工具类string类
  ，在使用时只需要#include<<string>>即可使用string类提供的各类函数。

那么我们能不能模仿string类来自己手写实现自己的MyString类呢？显然这是可以的。
在开始手写实现MyString类之前，我们要先了解一些操作运算符重载的基本概念和要注意的条件。
一：什么叫重载？
重载分为函数重载和操作运算符重载。
函数重载：函数重载是指一个函数可以和同一个作用域中的其他函数具有相同的名字
，但是这些同名的函数的形参列表必须互不相同。函数名相同但是参数列表至少满足
以下三个条件之一，就可以构成函数重载：
（1）参数的个数不同
（2）参数的个数相同但是参数类型不同
（3）参数个数相同但是参数顺序不同
但是函数的返回类型是不能够构成重载的。
例如：
（1）void func(int a,int b);
（2）void func(int a );
（3）void func(int a,string b);
（4）void func(string b,int a);
（5）int func(int a );
其中函数（1）（2）（3）(4)均两两构成重载。(1)和（2）是参数个数的不同，（1）和（3）是参数个数相同但是参数类型不同，（3）和（4）是参数个数和参数类型相同但是参数顺序不同，这些都能构成重载，但是函数（5）和函数（2）的函数名，参数个数和参数类型 均相同，只有返回值不同，那在这时在编译时编译器无法区分这两个函数，就会报错。
操作运算符重载：运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同的类型的数据是产生不同的结果。例如用加法运算符“+”可以对整数，单精确度，双精确度的数行加法运算，如“1+2", “1.1f+2.0f”, “2.2+3.2"等。实际上计算机对整数单精确度数，双精确度数的加法运算操作的过程是不同的。这谁因为c++语言对这些运算符针对预定义的数据类型做了适当的重载，使其能在不同的数据类型中进行不同的数据操作。而这些c++中预定义的运算符操作对象只能是基本的数据类型。但是，对于很多用户自定义的数据类型或除了基本数据类之外的数据型，比如复数类，string类，分数类等，这些数据也需要进行相似的运算操作，这就需要符进行重新定义，赋予已有运算符新的功能。
运算符重载要注意的事项；
在一般情况下，重载的运算符可以既可以作为类的成员函数来定义，也可以作为类的友元函数，但是有几个运算符是必须要注意的特例：
（1）赋值运算符“=“，函数调用运算符“（）“，下标运算符“[]” ,成员访问运算符“->“在重载时必须定义为类的成员变量。
（2）插入运算符”>>" 和抽取运算符“<<"不能作为类的成员函数，只能定义为类的友元函数。
（3：成员访问运算符“.“，成员指针访问运算符““，域运算符”：：“，长度运算符“sizeof",条件运算符“？ ：“，这几个是不能重载的。这是因为成员访问运算符“.“和成员指针访问运算符““不能重载保证了C++中访问成员功能的含义不能改变，如果重载了就有可能无法访问类的成员从而导致程序出错。域运算符”：：“和长度运算符“sizeof"的操作数是数据类型，而不是普通的变量或者表达式，所以不具备重载的特征。
运算符的重载有以下几条主要的规则：
（1）不能定义新的运算符。c++中除了少数的这几个运算符，其他操作符都能重载。
（2）运算符必须与当前的类有一定关系。也会是说重载的运算符的参数个数不能全部是预定义的数据类型。重载的运算符至少有一个参数的类型是与自定义的类有关的，这就要求这个参数或者是这个类的对象，或者这个类的引用或者是 这个类的指针。
（3）重载的时候，运算符的优先级，结合性以及操作数的个数是不能改变的。由于重载时不能改变运算的个数，因此定义为类的成员函数的单目运算符是没有参数的，而定义为友元类的函数时则有一个参数；同样，双目运算符如果被定义为类的成员函数，则只有一个参数，而定义为类的友元函数则有两个参数。
（4）除了赋值运算符“=“ 外，所有的其他函数都可以被派生类继承。
（5）应当使重载的运算符实现的功能类似于该运算符作用于标准的数据类型时所实现的功能。
以上便是关于运算符重载的基本要点。了解了这些要点，我们便开始对String进行手动实，在实现string类的过程中重写几个常见的运算符，从而达到 实现简易的string类。
首先，在测试中，我们要对MyString类进行测试：


#include<iostream>
#include "MyString.h"
using namespace std;
int main()
{
	MyString s1("123");
	cout <<"s1:"<< s1;
	MyString s2 = "456";
	cout << "s2:" << s2;
	MyString s3(s1);
	cout << "s3:" << s3;
	MyString s4 = s2;
	cout << "s4:" << s4;
	MyString s5 = s1 + s2+s3;
	cout << "s5:" << s5;
	s5[1] ='a';	
	cout << "s5:" << s5;
	cin >> s1>>s5; //输入新的s1: 789   ,  s5:abc
	cout << "s1:" << s1 << endl<< "s5:"<<s5<<endl;
	
	system("pause");
	return 0;

}

这段代码显然是会出错，这是因为我们都还没开始声明和定义这个MyString类。下面我们开始一一对这些要实现的方法进行定义。下面我们开始先使用声明和定义分离的方式来写出基本的MyString类的成员变量和成员函数。
首先声明MyString类：

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include<string>
#include<istream>
#include<ostream>
using namespace std;
class MyString
{
public:
	//默认无参构造
	MyString();
	//构造函数
	MyString(int len);
	MyString(const char* s);
	MyString(const MyString &s);
	//重载>>运算符,只能在类外实现
	friend ostream& operator<<(ostream &os,  MyString &s);
	//重载<<运算符,只能在类外实现
	friend  istream& operator>>(istream &is, MyString &s);
	//重载()运算符
	MyString& operator()(const MyString &str);
	//重载=运算符
	MyString& operator=(const MyString &str);
	//重载+运算符
	MyString operator+(const MyString &str);
	//重载[]运算符
	 char& operator[](int index);
	~MyString();
private:
	//长度
	int len;
	//S指针
	char *str;
};

至于为何要这样声明呢，下面笔者会对这些成员变量和成员函数以及相应的头文件进行讲解。

``首先是：#pragma once
#pragma once一般由编译器提供保证：同一个文件不会被包含多次。这里所说的”同一个文件”是指物理上的一个文件，而不是指内容相同的两个文件。无法对一个头文件中的一段代码作#pragma once声明，而只能针对文件。此方式不会出现宏名碰撞引发的奇怪问题，大型项目的编译速度也因此快了一些。缺点是如果某个头文件有多份拷贝，此方法不能保证它们不被重复包含。在C/C++中，#pragma once是一个非标准但是被广泛支持的方式。

#define _CRT_SECURE_NO_WARNINGS：
我们在编译老的用C++
语言的函数可能因为一些老的.cpp文件使用了strcpy,scanf，prinf ,等不安全的函数，而报警告和错误，而导致无法编译通过。在VS2017中为了防止在编译时出现报错而无法通过编译，我们此时有两种解决方案：

1.在指定的源文件的开头定义：#define _CRT_SECURE_NO_WARNINGS （只会在该文件里起作用）

2.在项目属性里设置，这会在整个项目里生效，依次选择：属性->配置属性->C/C++ ->预处理器->预处理器定义->编辑最下面加上一行：_CRT_SECURE_NO_WARNINGS （注意不需要#define）
在手动实现简易的MyString类时我们会使用到系统提供的string类中的一些strcpy等函数，所以要将这个问题解决掉，这里使用的是第一种方法。
下面这几个头文件和命名空间都是必须的
#include
#include：使用strcpy（），strlen（）这些函数时需要
#include：在重写“>>"运算符时需要
#include：在重写“<<"符时需要
using namespace std;
对于MyString类的成员变量：
private:
//长度
int len;
//str指针
char *str;
我们知道string的底层就是使用char[] 实现的，所以的话我们就需要使用char *的指针来指向一个char数组的空间，用len作为char []的长度。当然，事实上string里边底层的char[] 是以‘\0’这个字符串结尾的，所以在给str这个指针开辟char[] 的空间时，char[]数组的长度len要加上1来装载‘\0’这个默认的空字符。
public:
MyString();//默认无参构造
无参构造是为了使在没有给MyString对象给出参数时不报错。如 MyString str;这时候就会调用MyString（）这个无参构造从而 不会出错，否则若是没有MyString（）这个无参构造的话MyString str;会找不到相应的构造函数而报错。
MyString(int len);//构造函数
传入长度为 len，给str这个指针开辟长度为 len+1的空间来给 char[]。

MyString(const char* s); 
传入一个字符指针s，这个字符指针指向的空间存储的是一个字符串，
借助这个来对str进行构造得到相应的字符串。记住这里要加const这个关键字，
防止传入的指针s指向的字符串被修改，提高程序的安全性。特别是，
当我们传的参数是	MyString s1("123");这个时，由“123"是cost char*类型的，
若我们的这个构造函数是少了一个const关键字的	String(char* s); 那么编译器
就会在编译时报错：“初始化”: 无法从“const char [4]”转换为“MyString”	,这是因
为String(char* s); 中的参数是一个安全性低的普通指针s，而传入的	“123"的指针
是一个const char*	常量指针，安全性更高，所以不能把一个安全性高的指针赋
给一个安全性的指针，因此会报错。但是却可以将一个安全性低的指针赋给一个
安全更高的指针，所以我们要使用const这个关键字。

MyString(const MyString &s); //默认的拷贝构造
	为了防止调用默认的拷贝构造函数进行浅拷贝导致已经开辟空间的str指针在释放时被重复释放造成运行出错，所以要提供一个显式示的深度拷贝构造函数。
	

friend  istream& operator>>(istream &is, MyString &s);
//重载>>运算符,只能在类外实现

根据重载的规则我们知/重载>>运算符,必须要是友元类，返回的是一个引用，这样我们就可以进行连续的使用这个>>,如 cin>>str1>>str2; 若是返回的是一个匿名对象istream ，即
friend istream operator>>(istream &is, MyString &s);那么在 cin>>str1>>str2;时编译直接出错：在这里插入图片描述
所以我们要返回的是一个istream的引用。
而对于参数MyString &s，我们必须要使用 引用，这是因为，我们通过对象MyString s
引用的地址，在函数里输入 s的值时，s对应的内存空间保存的字符串也会改变，通过按引用传递来实现输入s的值后传入的形参s对应的原目标对象的值也会改变，从而达到输入的目的。比如：
MyString s(“123”);
cin>>s;//输入的值为 456
cout<<s;
那么修改后的s的值为s=“456”;输出的值自然就是字符串“456“。
如果我们使用的是fiend istream& operator>>(istream &is, MyString s);由于传递的MyString s是一个普通对象，根据按值传递，我们知道
,MyString s(“123”);
cin>>s;//输入的值为 456
相当于函数istream& operator>>(istream &is, MyString s);调用结束后，s的值没被改变，依旧是s=“123”.
cout<<s;
输出的值自然就是字符串“123"。
所以我们要使用friend istream& operator>>(istream &is, MyString &s);才行。
friend ostream& operator<<(ostream &os, MyString &s); //重载<<运算符,只能在类外实现
对于这个输出运算符，与输入运算符类似，返回的是一个引用，至于参数 MyString s
这个是一个引用或者普通对象都可以。这是因为输出是不需要改变对象s的数据的，只需要读取到s的数据即可。所以friend ostream& operator<<(ostream &os, MyString &s)或者friend ostream& operator<<(ostream &os, MyString s)都可以。

//重载()运算符
MyString& operator()(const MyString &str);
拷贝函数，防止参数str被修改，所以要使用const来限定。函数的返回值可以是返回的是一个对象，也可以是一个对象的引用。MyString& operator()(const MyString &str);或者MyString

operator()(const MyString &str)，形参可以是一个MyString对象也可以是一个MyString对象的的引用。

//重载=运算符
MyString& operator=(const MyString &str);

这个赋值操作符的返回类型可以是一个MyString对象的引用也可以是一个 MyString对象。
至于参数的话可以是一个MyString对象的引用也可以是一个 MyString对象。但是要加const这个关键字防止被修改。

MyString operator+(const MyString &str);//重载+运算符

传递的参数可以是 MyString的普通对象，也可以是 MyString对象的引用，而返回类型必须是 一个匿名的MyString对象，不能是引用，否则
若返回的是一个MyString对象的引用MyString& operator+(const MyString &str); ，则在 MyString s5 = s1 + s2+s3；时运行
就会报错。
在这里插入图片描述

 char& operator[](int index);	//重载[]运算符
 传入的是一个索引，返回的是一个char引用，这样便能达到修改str中的元素的作用。如果返回的是一个char  ，	 即char operator[](int index);那么编译时  s5[1] ='9';	就会报错，提示 error C2106: “=”: 左操作数必须为左值。

~MyString();  //析构函数，用于释放str指针指向的空间

理解了MyString中的成员变量和成员函数，下面我们便开始一个一个地实现这些函数。

首先是 ；
默认无参构造：MyString();的实现

MyString::MyString()
{
	this->len = 0;
	this->str = NULL;
}

其次/构造函数：MyString(int len);的实现。
先判定传入的参数是否是合理的，如果不合理就直接
this->len = 0;
this->str = NULL;
然后return;
如果参数合理，那就给str指针开辟长度为 len+1的空间，完整代码如下：

MyString::MyString(int len)
{
	//如果传入的len不合理
	if (len<=0)
	{
		this->len = 0;
		this->str = NULL;
		return;
	}
	//如果传入的len合理
	else
	{
	this->len = len;
	this->str = new char[this->len + 1];
	}
}

MyString(const char* s)的实现：

MyString::MyString(const char * s)
{
if (s==NULL)
{
this->len = 0;
this->str = new char[0 + 1];
strcpy(this->str, “”);
}
else
{
int Len = strlen(s);
this->len = Len;
this->str = new char[this->len + 1];
strcpy(this->str, s);
}
}

MyString(const MyString &s);的实现：

MyString::MyString(const MyString & s)

{
this->len = s.len;
this->str = new char[this->len + 1];
strcpy(this->str,s.str);
}

MyString & MyString::operator()(const MyString & s)的实现：
这个相当于深拷贝
MyString & MyString::operator()(const MyString & s)
{
if (this->str!=NULL)
{
this->len = 0;
delete this->str;
this->str = NULL;
}
this->len = s.len;
this->str = new char[this->len + 1];
strcpy(this->str,s.str);
return *this;
}
在重载=运算符时注意判定传进来的参数是不是本身，如果是本身，则直接返回，若缺少是这个判定，在运行时若是传的参数是本身，那么就会在运行时报错。所以要特别注意！！！！
MyString MyString::operator=(const MyString & s)
{
if (this==&s)
{
return *this;
}
if (this->str!=NULL)
{
this->len = 0;
delete this->str;
this->str = NULL;
}
this->len = s.len;
this->str = new char[this->len + 1];
strcpy(this->str, s.str);
return *this;
}

MyString MyString::operator+(const MyString & s)的实现：、

MyString MyString::operator+(const MyString & s)
{
int Len = this->len + s.len;
MyString temp(Len);
strcpy(temp.str, this->str);
strcat(temp.str, s.str);
return temp;

}

char& MyString::operator[](int index)的实现：
char& MyString::operator[](int index)
{
return this->str[index];
}

//析构函数
MyString::~MyString()
{
if (this->str!=NULL)
{
delete str;
str = NULL;
this->len = 0;

}

}

//重写<<运算符，返回的是ostream &
ostream & operator<<(ostream & os, MyString & s)
{
//输出字符串
os<< s.str << endl;
return os;
}
//重写<<运算符，返回的是istream &
在重载这个>>运算符时注意先判定s.str是否是空的，如果是非空的，那么就要先释放s.str的内存，防止内存泄露，然后再借助一个临时的char[] temp 来作为缓冲容器先读取cin输入的内容，然后再重新给s.str开辟空间后将缓冲容器的内容复制给s.str指向的空间。
istream & operator>>(istream & is, MyString & s)
{
if (s.str != NULL)
{
delete s.str;
s.str = NULL;
s.len = 0;
}
char temp[4096] = { 0 };
is >> temp;
int len = strlen(temp);
s.str = new char[len + 1];
strcpy(s.str, temp);
s.len = len;
return is;
}
这样我们就写完了这些基本的MyString类的相关函数，当然，系统封装的string中还要很多方法，想继续写的小伙伴们也可以继续自己手动实现，笔者就不再一一实现了。下面给出完整的源代码，这是基于Vs2017的：

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include<string>
#include<istream>
#include<ostream>
using namespace std;
class MyString
{
public:
	//默认无参构造
	MyString();
	//构造函数
	MyString(int len);
	MyString(const char* s);
	MyString(const MyString &s);
	//重载>>运算符,只能在类外实现
	friend ostream& operator<<(ostream &os,  MyString &s);
	//重载<<运算符,只能在类外实现
	friend  istream& operator>>(istream &is, MyString &s);
	//重载()运算符
	MyString& operator()(const MyString &str);
	//重载=运算符
	MyString operator=(const MyString &str);
	//重载+运算符
	MyString operator+(const MyString &str);
	//重载[]运算符
	 char& operator[](int index);
	~MyString();
private:
	//长度
	int len;
	//S指针
	char *str;
};



#include "MyString.h"


//默认构造函数
MyString::MyString()
{
	this->len = 0;
	this->str = NULL;
}
//构造函数
MyString::MyString(int len)
{
	//如果传入的len不合理
	if (len<=0)
	{
		this->len = 0;
		this->str = NULL;
		return;
	}
	//如果传入的len合理
	else
	{
	this->len = len;
	this->str = new char[this->len + 1];
	}
}
//构造函数
MyString::MyString(const char * s)
{
	if (s==NULL)
	{
		this->len = 0;
		this->str = new char[0 + 1];
		strcpy(this->str, "");
	}
	else
	{
		int Len = strlen(s);
		this->len = Len;
		this->str = new char[this->len + 1];
		strcpy(this->str, s);
	}
}
//构造函数
MyString::MyString(const MyString & s)
{
	this->len = s.len;
	this->str = new char[this->len + 1];
	strcpy(this->str,s.str);
}



//重写（）运算符，返回的是MyString &
MyString & MyString::operator()(const MyString & s)
{
	if (this->str!=NULL)
	{
		this->len = 0;
		delete this->str;
		this->str = NULL;
	}
	this->len = s.len;
	this->str = new char[this->len + 1];
	strcpy(this->str,s.str);
	return *this;
}
//重写=运算符返回的是MyString &
MyString  MyString::operator=(const MyString & s)
{
	if (this==&s)
	{
		return *this;
	}
	if (this->str!=NULL)
	{
		this->len = 0;
		delete this->str;
		this->str = NULL;
	}
	this->len = s.len;
	this->str = new char[this->len + 1];
	strcpy(this->str, s.str);
	return *this;
}
//重写+运算符，返回的是匿名对象
MyString  MyString::operator+(const MyString & s)
{
	int Len = this->len + s.len;
	MyString temp(Len);
	strcpy(temp.str, this->str);
	strcat(temp.str, s.str);
	return temp;
	
}
//重写[]运算符,返回的是char的引用
char& MyString::operator[](int index)
{
	return this->str[index];
}



//析构函数
MyString::~MyString()
{
	if (this->str!=NULL)
	{
	delete str;
	str = NULL;
	this->len = 0;

	}
}
//重写<<运算符，返回的是ostream &
ostream & operator<<(ostream & os, MyString & s)
{
	//输出字符串
	os<< s.str << endl;
	return os;
}
//重写<<运算符，返回的是istream &
istream & operator>>(istream & is, MyString & s)
{
	if (s.str != NULL)
	{
		delete s.str;
		s.str = NULL;
		s.len = 0;
	}
	char temp[4096] = { 0 };
	is >> temp;
	int len = strlen(temp);
	s.str = new char[len + 1];
	strcpy(s.str, temp);
	s.len = len;
	return is;
}

测试：


#include<iostream>
#include "MyString.h"
using namespace std;
int main()
{
	MyString s1("123");
	cout <<"s1:"<< s1;
	MyString s2 = "456";
	cout << "s2:" << s2;
	MyString s3(s1);
	cout << "s3:" << s3;
	MyString s4 = s2;
	cout << "s4:" << s4;
	MyString s5 = s1 + s2+s3;
	cout << "s5:" << s5;
	s5[1] ='a';	
	cout << "s5:" << s5;
	cin >> s1>>s5; //输入新的s1: 789   ,  s5:abc
	cout << "s1:" << s1 << endl<< "s5:"<<s5<<endl;
	
	system("pause");
	return 0;

}

运行后截图：
在这里插入图片描述

欢迎各位看官在底下评论斧正。

陌意随影
关注
  • 9
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
手写string类
shi_xiao_xuan的博客
04-17 2144
手写string类1.题目：实现string类2.分析（1）设计类（2）构造函数（2）拷贝构造函数（3）拷贝赋值函数（4）析构函数（5）operator+（6）operator+=（7）operator==（8）operator[ ]（9）operator<<3.完整代码 1.题目：实现string类 包含构造函数、拷贝构造函数、析构函数、拷贝赋值 扩展：重载+、重载+=、重载==、重...
C++实现string类
likesile的博客
10-13 191
实现Cstring.cpp。头文件Cstirng.h。
【C++】手把手教你写出你自己的String类
就爱摆烂
11-29 4705
在之前的 【C++】深入理解String类（一）里，我们讲解了string类的相关知识与其中部分库函数的使用方法。 这次我们要根据string的用法，模仿实现写一个string类。 注：我们模拟实现这个类，不是为了完美复制源码，而是熟悉string框架，加深对string的理解,我会用我们已经学习过的有限知识，来简单还原string. ...
手写C++ string类
weixin_45867382的博客
05-31 1177
手写的 string 类包含构造函数、拷贝构造函数、移动构造函数、拷贝赋值函数、析构函数以及重载输出操作符。
c++手写string类
crazyfox的博客
08-11 1278
string类是带指针的类，所以一些基础函数的定义要特别注意，很考验功底 0. 类声明含数据成员 1. 普通构造函数 2. 拷贝构造函数 3. 拷贝赋值运算符 4. 析构函数 5. 移动构造函数 6. 移动赋值运算符 ...
C++ 手写String类
weixin_49220519的博客
09-04 554
面试准备，记录一下
手写 string 类
大道至简
08-15 552
// 头文件 #ifndef MYSTRING_H #define MYSTRING_H #include <iostream> #include <cstring> #include <cstdlib> using namespace std; class myString { friend ostream & operator<<(ostream & out, myString &) ; friend istre.
C++ String类编写
qq_38211852的博客
09-01 711
1. h文件 #ifndef _STR_H_ #define _STR_H_ #include &lt;iostream&gt; using namespace std; class String { public: String(); //默认构造函数 String(const char*s); //普通构...
NewList.zip
07-12
`CString`是对标准C++库中`std::string`的一种自定义实现，它可能包含了字符串操作的常见功能，如拼接、查找、替换等。`CList`则可能是模仿STL中的`std::list`，实现了一个动态链表容器，用于存储和管理元素。这种...
通讯录管理系统，C++编写
05-10
C++的`fstream`库可以用来读写文件，而序列化技术如JSON、XML或自定义二进制格式可以将对象转换为字节流以便存储。 6. **错误处理与异常安全**：在编程过程中，确保良好的错误处理和异常安全是非常重要的。C++的...
C++标准程序库—自修教程与参考手册代码
02-03
第8章可能涵盖字符串和IO流，C++标准库中的`std::string`类提供了字符串操作，而IO流如`std::ifstream`和`std::ofstream`则支持文件读写。这一章可能会详细解释如何使用`std::getline`读取字符串，`std::cout`和`std...
C/C++ Reference
08-03
《C/C++参考指南》是IT领域中一本重要的参考资料，主要涵盖了C语言的标准库和C++的Standard Template Library（STL）。这篇详细解读将深入探讨这两个核心知识点。 首先，我们来了解一下C语言的标准库。标准库是...
C++标准程序库:自修教程与参考手册
11-24
7. **字符串类**：如std::string，提供字符串操作的便利。 在《C++标准程序库:自修教程与参考手册》中，作者会详细介绍每个组件的功能、用法以及最佳实践。例如，对于STL中的容器，书中会解释不同容器的特性（如...
自己写string类(C++)
jakelihua
11-28 644
数据类型，根据自己的理解自己仿写的一个。简介：这是作者当初自己根据。
手写基本的String类
AIxiaoming1105的博客
05-07 414
String类是C++模板库中的一个方法类，书写其基本方法是考研C++初学者一个很经典的考题，注意细节，写的完美的话也不是那么容易的，写个博客加强一下记忆。 //基本String类方法 class String { public : String(const char* str = NULL); String(const String &other); ~String();...
自主实现c++ string类
hclhy9191的博客
08-16 407
c++ 自主实现 string类 本是作者学习期间的练习，希望对学习者有所帮助。如有错误，不足之处，还请不吝赐教。
手动编写String类（C++）
一只不努力还想前进的狗
08-21 310
#include <iostream> #include <string.h> #include <stdio.h> #pragma warning(disable:4996) // vs2015中运行strcpy()函数总是报错，屏蔽这个错误 using namespace std; class String { private: char *data; ...
不存在的E11:C++ 手写string及注意事项
capsnever的博客
05-03 113
手写string时候发现了一个问题，就是怎么进行 这个操作，因为实现输入的数据量是不确定的。 然后上网查了一下博客，发现一个合适的都没有，比如下面这个 开了一个100的数组，那我直接输入一个1e5的量，不是直接爆炸吗。 后来想到了解决方案，每次都是一个一个字符读，然后重载+=运算符。 代码如下： #pragma once #include <cmath> #include <iostream> #include<assert.h> using namespace std
b051银行客户管理系统-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
最新发布
07-23
系统根据B/S，即所谓的电脑浏览器/网络服务器方式，运用Java技术性，挑选MySQL作为后台系统。系统主要包含对客服聊天管理、字典表管理、公告信息管理、金融工具管理、金融工具收藏管理、金融工具银行卡管理、借款管理、理财产品管理、理财产品收藏管理、理财产品银行卡管理、理财银行卡信息管理、银行卡管理、存款管理、银行卡记录管理、取款管理、转账管理、用户管理、员工管理等功能模块。 文中重点介绍了银行管理的专业技术发展背景和发展状况，随后遵照软件传统式研发流程，最先挑选适用思维和语言软件开发平台，依据需求分析报告模块和设计数据库结构，再根据系统功能模块的设计制作系统功能模块图、流程表和E-R图。随后设计架构以及编写代码，并实现系统能模块。最终基本完成系统检测和功能测试。结果显示，该系统能够实现所需要的作用，工作状态没有明显缺陷。 系统登录功能是程序必不可少的功能，在登录页面必填的数据有两项，一项就是账号，另一项数据就是密码，当管理员正确填写并提交这二者数据之后，管理员就可以进入系统后台功能操作区。进入银行卡列表，管理员可以进行查看列表、模糊搜索以及相关维护等操作。用户进入系统可以查看公告和模糊搜索公告信息、也可以进行公告维护操作。理财产品管理页面，管理员可以进行查看列表、模糊搜索以及相关维护等操作。产品类型管理页面，此页面提供给管理员的功能有：新增产品类型,修改产品类型,删除产品类型。
c++实现string类
02-28
C++中的string类是一个用于处理字符串的标准库类。它提供了一系列成员函数和操作符重载，使得字符串的操作更加方便和高效。 C++中的string类位于命名空间std中，因此在使用之前需要包含头文件< string >。 下面是一个简单的示例，展示了如何使用string类来创建、初始化和操作字符串： ```cpp #include <iostream> #include <string> int main() { // 创建一个空字符串 std::string str; // 初始化字符串 std::string greeting = "Hello, world!"; // 获取字符串长度 int length = greeting.length(); std::cout << "Length: " << length << std::endl; // 连接字符串 std::string name = "Alice"; std::string message = greeting + " My name is " + name; std::cout << "Message: " << message << std::endl; // 获取子串 std::string substring = message.substr(7, 5); std::cout << "Substring: " << substring << std::endl; // 查找子串 size_t position = message.find("world"); if (position != std::string::npos) { std::cout << "Found at position: " << position << std::endl; } else { std::cout << "Not found" << std::endl; } return 0; } ``` 上述示例中，我们首先创建了一个空字符串`str`，然后使用赋值运算符将字符串"Hello, world!"赋给了变量`greeting`。接着，我们使用`length()`函数获取了字符串的长度，并使用`+`运算符将多个字符串连接起来形成新的字符串。我们还使用`substr()`函数获取了字符串的子串，并使用`find()`函数查找了子串在原字符串中的位置。 除了上述示例中的操作，string类还提供了许多其他有用的成员函数和操作符重载，如插入、删除、替换、比较等。你可以参考C++的官方文档或其他相关资料来了解更多关于string类的详细信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陌意随影

您的鼓励是我最大的动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值