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

最新推荐文章于 2024-04-13 01:48:15 发布
最新推荐文章于 2024-04-13 01:48:15 发布
阅读量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
    评论
专栏目录
NewList.zip
07-12
`CString`是对标准C++库中`std::string`的一种自定义实现，它可能包含了字符串操作的常见功能，如拼接、查找、替换等。`CList`则可能是模仿STL中的`std::list`，实现了一个动态链表容器，用于存储和管理元素。这种...
通讯录管理系统，C++编写
05-10
C++的`fstream`库可以用来读写文件，而序列化技术如JSON、XML或自定义二进制格式可以将对象转换为字节流以便存储。 6. **错误处理与异常安全**：在编程过程中，确保良好的错误处理和异常安全是非常重要的。C++的...
【C++】手把手教你写出你自己的String类
就爱摆烂
11-29 4636
在之前的 【C++】深入理解String类（一）里，我们讲解了string类的相关知识与其中部分库函数的使用方法。 这次我们要根据string的用法，模仿实现写一个string类。 注：我们模拟实现这个类，不是为了完美复制源码，而是熟悉string框架，加深对string的理解,我会用我们已经学习过的有限知识，来简单还原string. ...
C++自定义实现string类型
qq_51004011的博客
07-26 1321
对于C++中独有的一种类型，string类型不管在使用还是维护，都特别的方便。那么今天我们就来自定义实现一个string类型。
C++实现一个自定义字符串类（string）
最新发布
2301_77754590的博客
04-13 1992
本博客将详细介绍如何在C++中实现一个自定义的字符串类 string，这个类模仿了标准库中 std::string 的关键功能。这个过程将涵盖从声明到定义的每一步，重点介绍内存管理、操作符重载以及提供一些关键的实现细节。
C++ 自己动手简单实现字符串String类
魔筝炼药师
03-29 4763
实现一个自己的String类是一道考验C++基础知识的好题。能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_pData，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。 仔...
自定义 string类（C++）
qq_69459941的博客
09-13 135
【代码】自定义 string类（C++）
C++零基础（08）——自定义string类
jiabin12230的博客
10-09 503
Lesson 08 自定义string类一、string基本使用1. C风格字符串对比2. string运算符使用二、自定义string类1、构造和析构函数2. 运算符重载总结： C++ 标准库提供了 string 类，跟方便字符串的处理。 一、string基本使用 1. C风格字符串对比 char *name = NULL; name = new char[100]; strcpy(name...
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中的容器，书中会解释不同容器的特性（如...
c++自定义string类
04-07
自定义String类 构造函数 拷贝构造 =运算符重载 +运算符重载 运算符重载 等 等
自定义string（C++）
qq_45865950的博客
11-27 925
剑指offer学习笔记，自定义string，C++异常安全
自定义一个String类
weixin_39774936的博客
11-06 273
可以自定义包名不为java.lang的String类，并区别包名正常使用自定义包名为java.lang的String类String类下写main方法：由于双亲委派模型，在加载String类时，会最终委派给Bootstrap ClassLoader去加载，加载的是rt.jar包中的那个java.lang.String，而rt.jar包中的String类是没有main方法的，因此报错误。
C++中自己的string类实现与定义
weixin_45888136的博客
05-26 1148
在Qt环境下实现自己的string，其他环境区别不大，写出来的函数底部有测试，作业党那走不谢！！！
编写一个String类（c++实现）
qq_40821469的博客
10-03 4857
编写一个string类，要求实现构造函数，拷贝构造函数，析构函数，运算符重载，获取指定位置的子串，显示字符串等功能。 详细代码： #include <iostream> #include <cstring> using namespace std; class String{ private: char* m_data; int length; public: String(const char *src = NULL);//构造函数 String
C++自定义string类
起风了~
11-28 243
为提高自身编码能力，学习书写自定义string类。
C++ 自定义string类
墨上烟雨
04-23 800
String.h #ifndef STRING_H #define STRING_H #include <iostream> using namespace std; class String { public: String(); //默认构造函数 String(const char *str); //构造函数：C字符串...
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、付费专栏及课程。

余额充值