String类（****）

最新推荐文章于 2023-05-27 16:08:49 发布
最新推荐文章于 2023-05-27 16:08:49 发布
阅读量290 收藏
点赞数
分类专栏： c++语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34967445/article/details/70141647
版权 
奋斗奋斗奋斗

//#pragma once
//
//class String
//{
//public:
//	String(char* str = "")
//		:_str(new char[strlen(str)+1])
//	{
//		strcpy(_str, str);
//		_str[strlen(str)] = '\0';
//	}
//
//	// 传统写法
//	//String s2(s1);
//	//String(const String& s)
//	//	:_str(new char[strlen(s._str)+1])
//	//{
//	//	strcpy(_str, s._str);
//	//	_str[strlen(s._str)] = '\0';
//	//}
//
//	// s2 = s2
//	// s2 = s3	 => s2.operator(&s2, s3)
//	//String& operator=(const String& s)
//	//{
//	//	if (this != &s)
//	//	{
//	//		delete[] _str;
//	//		size_t len = strlen(s._str);
//	//		_str = new char[len+1];
//	//		//strcpy(this->_str, s._str);
//	//		//_str[len] = '\0';
//	//		memcpy(_str, s._str, len+1);
//	//	}
//	//	
//	//	return *this;
//	//}
//
//	// s2 = s3
//	//String& operator=(const String& s)
//	//{
//	//	if (this != &s)
//	//	{
//	//		size_t len = strlen(s._str);
//	//		char* tmp = new char[len+1];
//	//		memcpy(tmp, s._str, len+1);
//
//	//		delete[] _str;
//	//		_str = tmp;
//	//	}
//
//	//	return *this;
//	//}
//
//	// 现代写法
//	String(const String& s)
//	{
//		String tmp(s._str);
//		swap(_str, s._str);
//	}
//
//	String& operator=(String s)
//	{
//		swap(s._str, _str);
//		return *this;
//	}
//
//	~String()
//	{
//		delete[] _str;
//	}
//
//public:
//	//void PushBack(char ch);
//	//void 
//
//public:
//	char* _str;
//
//	size_t _size;
//	size_t _capacity;
//};
//
//void TestString1()
//{
//	// 深浅拷贝
//	String s1("string1");
//	String s2(s1);
//	String s3("peter");
//
//	s2 = s3;
//	//s2 = s2;
//
//	String s4;
//}


#pragma once
// mystrcpy
// mymemmove

// 传统写法
//class String
//{
//public:
//	String(const char* str = "")
//		:_str(new char[strlen(str)+1])
//	{
//		//strcpy(_str, str);
//		//_str[strlen(str)] = '\0';
//		memcpy(_str, str, strlen(str)+1);
//	}
//
//	//String s2(s1); 
//	String(const String& s)
//		//:_str(new char[strlen(s._str)+1])
//	{
//		size_t len = strlen(s._str);
//		_str = new char[len+1];
//		memcpy(this->_str, s._str, len+1);
//	}
//
//	// s1 = s2;
//	String& operator=(const String& s)
//	{
//		if (this != &s)
//		{
//			// 开辟新的空间，并且拷贝数据
//			size_t len = strlen(s._str);
//			char* tmp = new char[len+1];
//			memcpy(tmp, s._str, len+1);
//
//			// 释放旧的空间
//			delete [] _str;
//
//			_str = tmp;
//		}
//
//		return *this;
//	}
//
//	~String()
//	{
//		delete[] _str;
//	}
//
//	char* GetStr()
//	{
//		return _str;
//	}
//
//protected:
//	char* _str;
//};

// 现代写法
//class String
//{
//public:
//	String(const char* str = "")
//		:_str(new char[strlen(str)+1])
//	{
//		//strcpy(_str, str);
//		//_str[strlen(str)] = '\0';
//		memcpy(_str, str, strlen(str)+1);
//	}
//
//	String(const String& s)
//		:_str(NULL)
//	{
//		String tmp(s._str);
//		swap(_str, tmp._str);
//	}
//
//	// s1 = s3
//	// s1 = s1
//	//String& operator=(const String& s)
//	//{
//	//	if (this != &s)
//	//	{
//	//		//String tmp(s._str);
//	//		String tmp(s);
//	//		swap(_str, tmp._str);
//	//	}
//
//	//	return *this;
//	//}
//
//	// s1 = s2; 
//	// s1 = s1;
//	String& operator=(String s)
//	{
//		swap(_str, s._str);
//		return *this;
//	}
//
//	~String()
//	{
//		delete[] _str;
//	}
//
//	char* GetStr()
//	{
//		return _str;
//	}
//
//protected:
//	char* _str;
//};

//
 扩展String功能--增删查改
//class String
//{
//public:
//	String(const char* str = "")
//		:_size(strlen(str))
//		,_capacity(_size+1)
//	{
//		_str = new char[_capacity];
//		memcpy(_str, str, _size+1);
//	}
//
//	String(const String& s)
//		:_str(NULL)
//	{
//		String tmp(s._str);
//		//swap(_str, tmp._str);
//		//this->Swap(tmp);
//		Swap(tmp); //Swap(this, tmp);
//	}
//
//	// s1 = s2
//	String& operator=(String s)
//	{
//		//swap(_str, s._str);
//		Swap(s); //
//		return *this;
//	}
//
//	// s1.Swap(s2)
//	void Swap(String& s)
//	{
//		swap(this->_str, s._str);
//		swap(this->_capacity, s._capacity);
//		swap(this->_size, s._size);
//	}
//
//	void PushBack(char ch)
//	{
//	/*	_CheckCapacity();
//		_str[_size] = ch;
//		++_size;
//		_str[_size] = '\0';*/
//
//		Insert(_size, ch);
//	}
//
//	void PopBack()
//	{
//		assert(_size > 0);
//		--_size;
//		_str[_size] = '\0';
//	}
//
//	void Insert(size_t pos, char ch)
//	{
//		_CheckCapacity(_size+2);
//
//		int end = _size;
//		while (end >= (int)pos) // ?bug
//		{
//			_str[end+1] = _str[end];
//			--end;
//		}
//	
//		++_size;
//		_str[end+1] = ch;
//	}
//
//	// 删除pos位置这个数据
//	void Erase(size_t pos)
//	{
//		assert(pos < _size);
//
//		for (size_t i = pos+1; i <= _size; ++i)
//		{
//			_str[i-1] = _str[i];
//		}
//
//		--_size;
//	}
//
//	// 删除pos位置开始往后的n个数据
//	void Erase(size_t pos, size_t n)
//	{
//		assert(pos < _size);
//
//		if (pos+n >= _size)
//		{
//			_str[pos] = '\0';
//		}
//		else
//		{
//			for (size_t i = pos+n; i <= _size; ++i)
//			{
//				_str[pos++] = _str[i];
//			}
//		}
//
//		_size -= n;
//	}
//
//	void Insert(size_t pos, const char* str)
//	{
//		size_t len = strlen(str);
//		_CheckCapacity(_size+1+len);
//
//		int end = _size; //?
//		while (end >= (int)pos)
//		{
//			_str[end+len] = _str[end];
//			--end;
//		}
//
//		char* dst = _str+pos;
//		while (*str)
//			*dst++ = *str++;
//
//		_size += 3;
//	}
//	
//	bool operator>(const String& s)
//	{
//		char* str1 = _str;
//		char* str2 = s._str;
//		
//		// "01234"
//		// 0  NULL '\0'  '0' "0"  
//		while (*str1 && *str2)
//		{
//			if (*str1 > *str2)
//			{
//				return true;
//			}
//			else if (*str1 < *str2)
//			{
//				return false;
//			}
//			else
//			{
//				++str1;
//				++str2;
//			}
//		}
//
//		//"hello"
//		//"hello world"
//
//		if (*str2)
//		{
//			return false;
//		}
//		else
//		{
//			return true;
//		}
//
//		if (*str1)
//		{
//			return true;
//		}
//		else if(*str2)
//		{
//			return false;
//		}
//		else
//		{
//			return true;
//		}
//	}
//
//	bool operator<(const String& s)
//	{
//		return !(*this > s || *this == s);
//	}
//
//	bool operator==(const String& s) const
//	{
//		if (_size == s._size)
//		{
//			for (size_t i = 0; i < _size; ++i)
//			{
//				if (_str[i] != s._str[i])
//				{
//					return false;
//				}
//			}
//
//			return true;
//		}
//
//		return false;
//	}
//	bool operator>=(const String& s);
//	bool operator<=(const String& s);
//
//
//	char& operator[](size_t pos) //???
//	{
//		return _str[pos];
//	}
//
//	// s1 + s2
//	String operator+(const String& s)
//	{
//		//String tmp(*this);
//		String tmp(this->_str);
//		tmp.Insert(tmp._size, s._str);
//
//		return tmp;
//	}
//
//	// s1 + "sssss"
//	String operator+(const char* str)
//	{
//		//String tmp(*this);
//		String tmp(this->_str);
//		tmp.Insert(tmp._size, str);
//
//		return tmp;
//	}
//
//	String& operator+=(const String& s)
//	{
//		Insert(_size, s._str);
//		return *this;
//	}
//
//	size_t Size()
//	{
//		return _size;
//	}
//
//	~String()
//	{
//		delete[] _str;
//	}
//
//	char* GetStr()
//	{
//		return _str;
//	}
//
//private:
//	void _CheckCapacity(size_t needSize)
//	{
//		if (needSize > _capacity)
//		{
//			size_t newCapacity = _capacity*2;
//			_str = (char*)realloc(_str, newCapacity);
//			_capacity = newCapacity;
//			assert(_str);
//		}
//	}
//
//private:
//	char* _str;
//	size_t _size;		// 字符个数
//	size_t _capacity;	// 容量
//};
//
//
//
void TestString1()
{
	char ptr1[] = "hello world";
	char* ptr2 = "hello world";

	String s1(ptr1);
	String s2(s1);

	String s3("hello");
	s1 = s3;

	s3.PushBack(' ');
	s3.PushBack('o');
	s3.PushBack('r');
	s3.PushBack('l');
	s3.PushBack('d');

	s3.Insert(6, 'w');
	cout<<s3.GetStr()<<endl;

	String s4(" world");
	s4.Insert(0, "hello");
	cout<<s4.GetStr()<<endl;

	s3[0] = 'x';
	cout<<s3.GetStr()<<endl;
}
//
//struct AA
//{
//	// 不允许进行隐式类型转换
//	AA(int aa, int bb)
//		:_aa(aa)
//	{
//		cout<<"AA()"<<endl;
//	}
//
//private:
//	int _aa;
//};
//
//void TestString2()
//{
//	char ptr1[] = "hello world";
//
//	String s1 = ("he world");
//	s1.Insert(2, "llo");
//	cout<<s1.GetStr()<<endl;
//
//	s1.Erase(2, 3);
//	cout<<s1.GetStr()<<endl;
//
//	s1[0] = 'x';
//	cout<<s1[3]<<endl;
//	cout<<s1.GetStr()<<endl;
//
//
//	String s2 = "hello";
//	String s3 = " world";
//
//	// 隐式转换
//	int i = 1.1;
//
//	String s5(s2 + s3);
//	String s6 = s2 + s3;
//	cout<<s5.GetStr()<<endl;
//
//	String s7 = s2 + " world";
//	cout<<s7.GetStr()<<endl;
//}

// 3.写时拷贝->效率、缺点：复杂，缺陷
//class String
//{
//public:
//	String(const char* str)
//	{
//		size_t len = strlen(str);
//		_str = new char[len+1];
//		memcpy(_str, str, len+1);
//
//		_refCount = new size_t(1);
//	}
//
//	String(const String& s)
//		:_str(s._str)
//		,_refCount(s._refCount)
//	{
//		++(*_refCount);
//	}
//
//	// s2 = s4
//	String& operator=(const String& s)
//	{
//		if (this != &s)
//		{
//			this->Release();
//
//			this->_str = s._str;
//			this->_refCount = s._refCount;
//			++(*s._refCount);
//		}
//
//		return *this;
//	}
//
//	void Release()
//	{
//		if (--(*this->_refCount) == 0)
//		{
//			cout<<"delete"<<endl;
//
//			delete _refCount;
//			delete[] _str;
//		}
//	}
//
//	~String()
//	{
//		Release();
//	}
//
//	char* GetStr()
//	{
//		return _str;
//	}
//
//	char& operator[](size_t pos)
//	{
//		if(*_refCount > 1)
//		{
//			cout<<"COW"<<endl;
//			String tmp(_str);
//			Swap(tmp);
//		}
//
//		return _str[pos];
//	}
//
//	void Swap(String& tmp)
//	{
//		swap(_str, tmp._str);
//		swap(_refCount, tmp._refCount);
//	}
//
//private:
//	char* _str;
//	size_t* _refCount;
//};
//
//void TestString1()
//{
//	String s1("hello");
//	String s2(s1);
//	String s3(s1);
//	//cout<<s1.GetStr()<<endl;
//	//cout<<s2.GetStr()<<endl;
//	//cout<<s3.GetStr()<<endl;
//
//	String s4("world");
//	String s5(s4);
//
//	//cout<<s4.GetStr()<<endl;
//	//cout<<s5.GetStr()<<endl;
//
//	s2 = s4;
//
//	cout<<s2.GetStr()<<endl;
//	cout<<s4.GetStr()<<endl;
//
//	String s6("xxxxx");
//	s6 = s4;
//}
//
 写时拷贝 COW copy on write
//void TestString2()
//{
//	String s1("hello");
//	String s2(s1);
//
//	//s1[0] = '1';
//	//s2[0] = '2';
//
//	cout<<s1[0]<<endl;
//	cout<<s1.GetStr()<<endl;
//	cout<<s2.GetStr()<<endl;
//}


class String
{
public:
	String(const char* str = "")
	{
		size_t len = strlen(str);
		len += 5;
		_str = new char[len];
		printf("new 0x%p\n", _str);

		GetRefCount(_str) = 1;

		_str += 4;
		strcpy(_str, str);
	}

	String(const String& s)
		:_str(s._str)
	{
		GetRefCount(_str-4)++;
	}

	size_t& GetRefCount(char* str)
	{
		return *((size_t*)str);
	}

	// s3 = s1  ==> s3.operator=(&s3, s1)
	//String& operator=(const String& s)
	//{
	//	if (this != &s)
	//	{
	//		Release();

	//		_str = s._str;
	//		GetRefCount(_str-4)++;
	//	}

	//	return *this;
	//}

	String& operator=(String s)
	{
		swap(_str, s._str);

		return *this;
	}

	void Release()
	{
		if (--GetRefCount(_str-4) == 0)
		{
			printf("delete 0x%p\n", _str-4);
			delete[] (_str-4);
		}
	}

	~String()
	{
		Release();
	}

	// s1 + s2
	String operator+(const String& s); //

	// s1 += s2
	String& operator+=(const String& s);

	char& operator[](size_t index)
	{
		//assert(index < _size);
		CopyOnWirte();

		return _str[index];
	}

	/*void CopyOnWirte()
	{
		if (GetRefCount(_str-4) > 1)
		{
			size_t len = strlen(_str);
			len += 5;
			char* tmp = new char[len];
			GetRefCount(tmp) = 1;
			tmp += 4;
			strcpy(tmp, _str);

			GetRefCount(_str-4)--;
			_str = tmp;
 		}
	}*/

	void CopyOnWirte()
	{
		if (GetRefCount(_str-4) > 1)
		{
			String tmp(_str);
			swap(_str, tmp._str);
		}
	}

	char* GetStr()
	{
		return _str;
	}

private:
	char* _str;
	//size_t* _refCount;
};

void TestString1()
{
	String s1("hello");
	String s2(s1);

	String s3("world");
	//String s4(s3);
	//s3 = s1;


	//s1 += "sss";
	s1[0] = 'x';
	s3[0] = 'x';

	cout<<s1.GetStr()<<endl;
	cout<<s2.GetStr()<<endl;
	cout<<s3.GetStr()<<endl;
	//cout<<s4.GetStr()<<endl;
}

浅拷贝

class String
{
public:
     String(const char* pStr = "")
     {
          _pStr = new char[my_strlen(pStr) + 1];
          my_strcpy(_pStr, pStr);
     }

     String(const String& s)
     {
          _pStr = s._pStr;
     }

     String& operator=(const String& s)
     {
          if (this != &s)
          {
              _pStr = s._pStr;
          }
          return *this;
     }

     ~String()
     {
          delete[] _pStr;
          _pStr = NULL;
     }

protected:
     int my_strlen(const char* str)
     {
          int count = 0;
          assert(str);
          while (*str)
          {
              str++;
              count++;
          }
          return count;
     }

     char* my_strcpy(char* dst, const char* src)
     {
          char* ret = dst;
          assert(dst);
          assert(src);
          while (*dst++ = *src++)
          {
              ;
          }
          return ret;
     }

private:
     char* _pStr;
};

深拷贝： 

//深拷贝普通版
class String
{
public:
     String(const char* pStr = "")
     {
          if (NULL == pStr)
          {
              _pStr = new char[1];
              *_pStr = '\0';
          }
          _pStr = new char[my_strlen(pStr) + 1];
          my_strcpy(_pStr, pStr);
     }

     String(const String& s)
     {
          _pStr = new char[strlen(s._pStr) + 1];
          strcpy(_pStr, s._pStr);
     }

     String& operator=(const String& s)
     {
          if (this != &s)
          {
              char *pTemp = new char[strlen(s._pStr) + 1];
              strcpy(pTemp, s._pStr);
              delete[]_pStr;
              _pStr = pTemp;
          }
          return *this;
     }

     ~String()
     {
          delete[] _pStr;
          _pStr = NULL;
     }

protected:
     int my_strlen(const char* str)
     {
          int count = 0;
          assert(str);
          while (*str)
          {
              str++;
              count++;
          }
          return count;
     }

     char* my_strcpy(char* dst, const char* src)
     {
          char* ret = dst;
          assert(dst);
          assert(src);
          while (*dst++ = *src++)
          {
              ;
          }
          return ret;
     }

private:
     char* _pStr;
};

//深拷贝简洁版
/*
class String
{
public:
     String(const char* pStr = "")
     {
          if (NULL == pStr)
          {
              _pStr = new char[1];
              *_pStr = '\0';
          }
          _pStr = new char[my_strlen(pStr) + 1];
          my_strcpy(_pStr, pStr);
     }

     String(const String& s)
          :_pStr(NULL)
     {
          String tmp(s._pStr);
          std::swap(_pStr, tmp._pStr);
     }

     String& operator=(const String& s)
     {
          if (this != &s)
          {
              String tmp(s);
              std::swap(tmp._pStr, _pStr);
          }
          return *this;
     }

     ~String()
     {
          if (_pStr)
          {
              delete[] _pStr;
              _pStr = NULL;
          }
     }

protected:
     int my_strlen(const char* str)
     {
          int count = 0;
          assert(str);
          while (*str)
          {
              str++;
              count++;
          }
          return count;
     }

     char* my_strcpy(char* dst, const char* src)
     {
          char* ret = dst;
          assert(dst);
          assert(src);
          while (*dst++ = *src++)
          {
              ;
          }
          return ret;
     }

private:
     char* _pStr;
};
*/

注：深拷贝普通版： 拷贝构造：开辟新空间，进行内容的拷贝使其各自有各自的空间以至于在析构的时候各自有各自空间。
赋值运算符重载：开辟新空间，释放原空间，拷贝内容。
深拷贝简洁版： 引入交换。

夏天的呆子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义String类
10-31
通过C语言实现的C++中自定义的模拟String类代码，实现基本工程操作
String详解
crazy_xieyi的博客
05-13 5030
1 String 概述 2 String不可变的好处 3 String，StringBuffer和 StringBuilder的区别 4 字符串常量池（String Pool） 5 new String（String类中两种对象实例化的区别） 6 String 常用方法（字符串构造、String对象的比较 、字符串查找、转化、字符串替换、字符串拆分、字符串截取、其他操作方法）...
string的介绍和使用
work_hard423的博客
05-16 3806
233
string及其常见函数
wanxiangzx的博客
08-29 1979
查找、截字串、替换、与数字相互转换
【C++】STL常用容器总结之十二：string类
长相忆兮长相忆的专栏
08-25 2万+
13、string类声明string类本不是STL的容器，但是它与STL容器有着很多相似的操作，因此，把string放在这里一起进行介绍。 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下的需要。我们尽可以把它看成是C++的基本数据类型。 首先，为了在我
String类详解
weixin_65278827的博客
05-21 1万+
String类算是比较特殊的类型了，作为初学者我们甚至把这个引用类型时不时当成基本类型来用，而且发现，竟然差不多。然而实际呢？我们太年轻，差的真的很多，今天就来详细讲一讲到底差在哪。 一、创建字符串的四种方式 1.直接赋值 直接赋值，在堆中的常量池中创建该字符串对象 String str1 = "HelloWorld"; 2.通过构造方法创建对象 在堆中创建对象，并把该对象的拷贝放到常量池中 String str2 = new String("HelloWorld"); 3.通过字符数组
string类讲解文档
11-20
该文档讲解了C++string类的各项函数,讲解详细,内容充实且举例较多
string类的常用方法
最新发布
10-31
string类的常用方法
C++重写String类
05-26
C++重写String类C++重写String类C++重写String类C++重写String类
C++String类
12-08
自己写的C++String类，用的devc++这个编译软件，为了代码的可观，我用了多个头文件编写，这个String类很全面。
String...的用法
热门推荐
Keep on moving!
01-08 8万+
一、前言 在项目中，在检查参数是否为空的工具类中，出现了一个函数的参数列表是这种写法，于是学习了一下这种用法的使用。个人觉得这种处理还是很不错的，使得代码更加简洁。 二、用法 String…是java5新加入的功能，表示的是一个可变长度的参数列表。 其语法就是类型后跟…，表示此处接受的参数为0到多个Object类型的对象，或者是一个Object[]。 例如我们有一个方法叫做test(String…...
【C++】string介绍
You don't have the guts to be what you wanna be.
05-27 2720
string的一些介绍，最常用的几个函数和一些不常用的接口的示例。 这篇重点不在于记住这些函数接口，重点在于学会查文档。
string（字符串）干货归纳+用法示例
lzq8090的博客
04-14 3218
5.string一.string简介1.简介：2.常用操作函数汇总：二.string常用实例1.字符串构造（初始化）2.char*（char[]）、int与string的相互转换（c_str）3.字符串大小和容量（size、max_size、capacity）：4.字符串比较（>,>=,<,<=,==,!=、compare）：5.字符串切割、拼接（substr、append、+） ：6.字符串等增、删（push_back、insert、erase） ：7.字符串的查找（find） ：
字符串解码
weixin_45927758的博客
05-29 159
LeetCode算法网站题目 https://leetcode-cn.com/problems/decode-string/ 1.递归 class Solution { public: string analysis(string s, int& index) { string res; int num = 0; string temp; while (index < s.size()) .
【C++】string 类
qq_37924645的博客
08-03 317
1、完成String类普通版深拷贝和简洁版深拷贝 2、在上述String类中完成如下函数（要求不能调用C中的库函数）： size_t Size()const; char& operator[](size_t index); const char& operator[](size_t index)const; String operator+(const String& s); bool operator>(const String& s); bool operator<(const
String
LingYaaa的博客
06-14 1万+
字符串：就是由多个字符组成的一串数据。也可以看成是一个字符数组。构造方法： * public String():空构造 * public String(byte[] bytes):把字节数组转成字符串 * public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串 * public String(char[] value...
递归+堆栈 394. 字符串解码
BLUEsang的博客
05-28 252
394. 字符串解码 给定一个经过编码的字符串，返回它解码后的字符串。 编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。 你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。 此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。 示例: s = "3[a]2[bc]", 返回 "aaabcbc". s = "3
C++关于string的详细讲解
写博客记录分享学习笔记
02-01 1万+
本文介绍了C++中string的详细使用方法。
string和char*
07-28
使用string类，我们可以方便地进行字符串的赋值、拼接、查找、替换等操作，而无需手动管理内存。例如： ```cpp #include <string> using namespace std; string str = "Hello"; // 使用string类定义一个字符串 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值