精华内容
下载资源
问答
  • String函数

    千次阅读 2018-06-25 15:27:49
    一、string类1、(1)字符串:字符的集合,以‘\0'结尾。 (2)字符数组:存放字符的数组。2、封装一个字符串,即封装string类:(1) # define _CRT_SECURE_NO_WARNINGS # include<iostream> # ...
    一、string类
    1、(1)字符串:字符的集合,以‘\0'结尾。
         (2)字符数组:存放字符的数组。
    2、封装一个字符串,即封装string类:
    (1)
     
    # define _CRT_SECURE_NO_WARNINGS
    # include<iostream>
    # include<string.h>
    using namespace std;
    //string类管理字符串,空间一般为一个字符数组
    class String
    {
    public:
     /*String()//构造函数
      :_pStr(new char[1])//该字符串中只有'\0',没有其他内容,把'\0'给到引用空间内
     {
        *_pStr = '\0';//正确
      //*_pStr = 0;//此方法可取
      //_pStr = 0;//把指针置空,存在内存泄漏
      //_pStr = '\0';//把指针置空
      //*_pStr = '0';//'\0'和字符0的含义不同
      }
     String(const char *pStr)//给出空间的首地址(该字符串除了'\0',还有其他的内容
     {
      //对指针进行判空
      if (NULL == pStr)
      {
       //把空指针当成空串进行处理,空串里面有一个'\0'
       _pStr = new char('\0');
      }
      //把字符串里面的内容存到空间里面
      //1、开辟空间
      _pStr = new char[strlen(pStr) + 1];
      //2、把内容拷贝到新空间里面
      strcpy(_pStr, pStr);
     }*/
     //将上述两中方式合为一个,给定空字符串为一个缺省值
     String(const char *pStr=" ")
     {   
       if (NULL == pStr)
      {
       _pStr = new char('\0');
      }
      else{
       //1、开辟空间
       _pStr = new char[strlen(pStr) + 1];
       //2、把内容拷贝到新空间里面
       strcpy(_pStr, pStr);
      }
      }
     String(const String& s)
      :_pStr(s._pStr)
     {}
     //赋值运算符重载
     String& operator=(const String& s)
     {
      if (this != &s)//若不是自己给自己赋值,字符指针和s中的内容相同
      {
       _pStr = s._pStr;
      }
      return *this;
     }
     ~String()
     {
      if (_pStr)
      {
       //空间存在,就释放空间
       delete[] _pStr;
       _pStr = NULL;
      }
     }
    private:
     char* _pStr;//给成动态数组,外部用户给与几个字符,即管理几个字符
    };
    void FuncTest()
    { 
     String s1("haha");
     String s2;
    }
    int main()
    {
     FuncTest();
     return 0;
    }

    此方式会导致程序崩溃,因为s1与s2会使用同一块空间

    当s2调用析构函数,释放空间后,s1并不知情,s1成为一个野指针;当s1会尝试把s2已经释放的空间再释放一次,就出现问题。
    (2)使用测试代码:如下,也会出现问题,程序会崩溃:
     
    void FuncTest()
    {
                    String s1("haha");
     String s3;
                    s3 = s1;
    }

    出现此问题是因为赋值运算符里面出现问题:

    以上(1),(2)即为浅拷贝,(只把对象里面的东西原样放到另一个对象里面,导致多个对象共用同一块空间,导致一块空间被释放多次,引起程序崩溃或内存泄漏。
    (3)上述问题的解决方式之一:深拷贝
    A、不要公用同一块空间,给每一个对象给一个空间
    a、此种方式会出现错误:
     
    String(const String& s)
      { 
      if (_pStr)
       delete[] _pStr;
      _pStr = new char[strlen(s._pStr) + 1];
      strcpy(_pStr, s._pStr);
     }

    错误原因:此时当前对象还不存在,不用考虑是否为空,若是释放,会导致程序崩溃。
    改正:先初始化为空,此时就不用判空和释放
     
    String(const String& s)
      :_pStr(NULL)
     { 
      _pStr = new char[strlen(s._pStr) + 1];
      strcpy(_pStr, s._pStr);
     }

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

    B、对于
    void FuncTest()
    {
                    String s1("haha");
     String s3;
                    s3 = s1;
    }

    a、方式1,可以采用:申请新空间、拷贝元素、释放旧空间、更改指向(指向新空间)

     
    String& operator=(const String& s)
     {
      if (this != &s) 
      {
       char *pTmp = new char[strlen(s._pStr) + 1];
       strcpy(pTmp, s._pStr);
       delete[] _pStr;
       _pStr = pTmp;//让当前对象指向新空间
       }
      return *this;
     }

    b、方式2
     
    String& operator=(const String& s)
     {
      delete[] _pStr;//释放旧空间
      _pStr = new char[strlen(s._pStr) + 1];//开辟和s大小相同新空间
      strcpy(_pStr, s._pStr);//把s中的内容拷贝过来
    }

    若是开辟空间失败,使用方式1不会对原来的空间造成影响;但是对于方式2开辟空间失败,会使原空间的内容不存在。

    深拷贝:让每一个对象都拥有自己的空间,让处理的更深。

    C、检测一下浅拷贝的方式有什么错误(实现一个简洁版本的浅拷贝):

    class String
    {
    public:
    	String(const char *pStr = " ")
    	{
    		if (NULL == pStr)
    		{
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1];
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
    	}
    	String(const String& s)
     	{ //当前对象,每个对象得String类里面都有一个_pStr指针,当前对象得指针没有赋初始值,所以是一个野指针,空间中最后存的得什么值,就指向以什么为地址得指针。
    		String strTmp(s._pStr);//创建临时对象,临时对象也有一块空间、有一个指针_pStr,通过s里面得字符串构造出来的,指针调用的是构造函数而不是拷贝构造函数。临时变量的指针指向tmp空间,该空间与s里面放的内容一模一样。
    		Swap(_pStr, strTmp._pStr);//交换两个对象中的内容,临时对象的指针变成一个野指针。出了函数的作用域要销毁,但是该空间不是从堆上创建的空间,释放会出错。
    	}
    	 //赋值运算符重载
    	/* 
    	String& operator=(const String& s)
    	{
    		if (this != &s)
    		{
    			String strTmp(s);
    			Swap(_pStr, strTmp._pStr);
    		}
    		return *this;
    	}
    	*/
    
    	/* //不用自己给自己赋值,直接交换
    	String& operator=(const String& s)
    	{ 
    			String strTmp(s);
    			Swap(_pStr, strTmp._pStr);
    		return *this;
    	}
    	*/
    	/*//不传引用,直接用s里面的值进行交换
    	String& operator=(String s)
    	{
     		Swap(_pStr, strTmp._pStr);
    		return *this;
    	}
    	*/
    	~String()
    	{
    		if (_pStr)
    		{
     			delete[] _pStr;
    			_pStr = NULL;
    		}
    	}
    private:
    	char* _pStr; 
    
    };
    void FuncTest()
    {
    	String s1("haha");
    	String s2(s1);
    }
    int main()
    {
    	FuncTest();
    	return 0;
    }

    此时程序崩溃,说明拷贝构造函数有问题。

    改正拷贝构造函数:

    //拷贝构造函数的解决方案:给定一个初始值,赋为空
      String(const String& s)
      :_pStr(NULL)
     {  
      String strTmp(s._pStr); 
      Swap(_pStr, strTmp._pStr); 
     }
    

    b、使用测试函数:

    void FuncTest()
    {
    	String s1("haha");
    	String s2;
    	s2 = s1;
    }

    说明赋值运算符的方式出现问题,创建临时变量,也会调用拷贝构造函数。此时不能判断是哪个函数出现问题(拷贝构造函数还是赋值运算符)。

    判断下列赋值运算符的函数是否出现问题:

    A、

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

    没有问题:直接拷贝拷贝构造函数的内容,用临时对象与当前对象交换当前对象和参数都已经存在,指针指向的空间一定是合法的,不用赋空,直接交换。出了if判断句,即释放this返回临时对象里面的空间。

    B、

    String& operator=(const String& s)
    	{ 
    			String strTmp(s);
    			Swap(_pStr, strTmp._pStr);
    		return *this;
    	}
    

    没有问题:只是少了一步检测是否为自己给自己赋值的操作。如果不是自己给自己赋值,没有问题;如果是自己给自己赋值,出了函数的作用域,销毁原来的空间,留下的是临时空间,自己给自己赋值时,相当于临时空间没有含义,但是不会出现问题。但是不如A的方式好。创建临时对象是在函数体里面由用户自己创建。

    C、

    String& operator=(String s)
    	{
     		Swap(_pStr, strTmp._pStr);
    		return *this;
    	}
    
    不会出现问题。传值,传参时相当于生成了一个临时变量,此时相当于当前对象和临时变量交换空间,出了作用域临时变量的空间会销毁,临时变量销毁的空间即为当前对象的旧空间。不论是不是自己给自己赋值都要创建临时对象(传参期间由编译器创建),原理与B类似。此种方式也不如A好。

    (3)为了解决浅拷贝的问题,还可以采用:同一块空间进行计数,销毁一次即减一,如果计数为1则s2不能销毁,当s1减一后为0,s1必须进行释放。就不会存在一个空间被释放两次的问题。

    a、把计数给成普通的类成员:不行

    class String
    {
    public:
    	String(const char *pStr = " ")
    	{
    		if (NULL == pStr)
    		{
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1];
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
    		_count = 1;//构造函数标记被几个函数在使用
    	}
    	//拷贝构造函数
    	String(const String& s)
    		:_pStr(s._pStr)
    		, _count(++s._count)
    	{
    
    	}
    	~String()
    	{
    		if (_pStr && 0 == --_count)
    		{
    			delete[] _pStr;
    		}
    	}
    private:
    	char* _pStr;
    	mutable int _count;//给定一块整型的计数空间
    };
    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    }
    int main()
    {
    	FunTest();
     	return 0;
    }

    但此时也会出现问题,每个对象都包含一份s2把自己计数减1,变为1;但是s1并不知道,此时也用2减,也为1,都不会释放,导致内存空间不能释放。

    b、让计数的变量共享,给成static。解决方式:s2释放后让s1知道s2释放了一个。

    class String
    {
    public:
    	String(const char *pStr = " ")
    	{
    		if (NULL == pStr)
    		{
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1];
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
    		_count = 1;//构造函数标记被几个函数在使用
    	}
    	//拷贝构造函数
    	String(const String& s)
    		:_pStr(s._pStr)
     	{
    		_count++;//静态成员变量不能出现在函数体里
    	}
    	~String()
    	{
    		if (_pStr && 0 == --_count)
    		{
    			delete[] _pStr;
    		}
    	}
    private:
    	char* _pStr;
    	static int _count;//给定一块整型的计数空间
    };
    int String::_count = 0;//刚开始没有空间,将初始值给为0
    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    }
    int main()
    {
    	FunTest();
     	return 0;
    }

    但是若是此时测试代码:

    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    	String s3;
    }

    对于s3出了作用域需要销毁,计数变量变为0。但是此时s1和s2的计数变量也是0,再销毁就会变成负数,出现错误。

    c、有几个空间,计数给几个;独立的用独立的空间,给定独立的计数,共享的给出一个计数空间。销毁空间时,若是一个计数已经用了,则减一,用另一个变量继续判定。直到计数为0,则释放。释放字符串空间和存放引用计数的空间。

    class String
    {
    public:
    	String(const char *pStr = " ")
    		:_pcount(new int(1))//引用计数初始值给为1
    	{
    		//存放字符串的空间
    		if (NULL == pStr)
    		{
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1];
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
     	}
    	//拷贝构造函数
    	String(const String& s)
    		:_pStr(s._pStr)
    		, _pcount(s._pcount)//共享计数空间
    	{
    		++(*_pcount);
     	}
    	~String()
    	{
    		if (_pStr && 0 == --*_pcount)
    		{
    			delete[] _pStr;//销毁字符串的空间
    			_pStr = NULL;
    			delete _pcount;//销毁引用变量的空间
    			_pcount = NULL;
    		}
    	}
    private:
    	char* _pStr;
    	int* _pcount;//几个空间就有几个计数
    };
     void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    	String s3;
    }
    int main()
    {
    	FunTest();
    	return 0;
    }

    (4)

    class String
    {
    public:
    	String(const char *pStr = " ")
    		:_pcount(new int(1))//引用计数初始值给为1
    	{
    		//存放字符串的空间
    		if (NULL == pStr)
    		{
                               _pStr = new char[1];
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1];
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
     	}
    	//拷贝构造函数
    	String(const String& s)
    		:_pStr(s._pStr)
    		, _pcount(s._pcount)//共享计数空间
    	{
    		++(*_pcount);
     	}
    	 
    	//赋值运算符的重载
    	String& operator=(const String&s)
    	{
     			//考虑是否为当前对象,若是共用同一块空间,改变引用计数的值;
    			//没有共用一块空间,则将引用计数减1,减1后若是为0,则释放原空间。,指向新空间,将新空间里面的计数加1
    			//如果两个对象共用一块空间,可以认为是自己给自己赋值。
    			//如果地址不相同,则当前对象和s没有共用同一块空间
    			if (_pStr != s._pStr)
    			{
    				if (_pStr && 0 == --*_pcount)
    				{
    					delete[] _pStr;
    					delete _pcount;
    				}
    				//共用同一块空间、共用同一个引用计数
    				_pStr = s._pStr;
    				_pcount = s._pcount;
    				++*_pcount;//引用计数增加
    			}
    		return *this;
    	}
    	~String()
    	{
    		if (_pStr && 0 == --*_pcount)
    		{
    			delete[] _pStr;//销毁字符串的空间
    			_pStr = NULL;
    			delete _pcount;//销毁引用变量的空间
    			_pcount = NULL;
    		}
    	}
    private:
    	char* _pStr;
    	int* _pcount;//几个空间就有几个计数
    };
     void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    	String s3;
    }
    int main()
    {
    	FunTest();
    	return 0;
    }

    若是少释放一个空间会导致错误,而且会存在空间的浪费。解决方案:把两个空间给成一个连续的空间,上面保存引用计数,下面保存字符串。指针向前倒4个字节即可以释放。代码如下:

    class String
    {
    public:
    	String(const char *pStr = " ")
     	{
    		//存放字符串的空间
    		if (NULL == pStr)
    		{
    			_pStr = new char[1+4];
    			_pStr += 4;//引用计数占前四个字节,真正开始,得从加上四个字节之后。
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1+4];
                            _pStr += 4;
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
    		//放引用计数,空间首地址得位置,_pStr向前偏移四个字节
    		GetRef() = 1;
    	}
    	//拷贝构造函数
    	String(const String& s)
    		:_pStr(s._pStr)
    	{
    		GetRef()++;
    	}
    
    	//赋值运算符的重载
    	String& operator=(const String&s)
    	{
    		//考虑是否为当前对象,若是共用同一块空间,改变引用计数的值;
    		//没有共用一块空间,则将引用计数减1,减1后若是为0,则释放原空间。,指向新空间,将新空间里面的计数加1
    		//如果两个对象共用一块空间,可以认为是自己给自己赋值。
    		//如果地址不相同,则当前对象和s没有共用同一块空间
    		if (_pStr != s._pStr)
    		{
    			Release();
    			//共用同一块空间、共用同一个引用计数
    			_pStr = s._pStr;
    			++GetRef();//引用计数增加
    		}
    		return *this;
    	}
    	~String()
    	{
    		Release();
    	}
    private:
    	//获取引用计数
    	int &GetRef()
    	{
    		return *((int *)_pStr - 4);
    	}
    	//释放得函数
    	void Release()
    	{
    		if (_pStr && 0 == --GetRef())
    		{
    			_pStr -= 4;
    			delete[] (_pStr-4);//销毁字符串的空间
    			_pStr = NULL;
    		}
    	}
    private:
    	char* _pStr;
     };
    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    	String s3;
    	s3 = s2;
    }
    int main()
    {
    	FunTest();
    	return 0;
    }

    (6)写时拷贝(COW):

    class String
    {
    public:
    	String(const char *pStr = " ")
     	{
    		//存放字符串的空间
    		if (NULL == pStr)
    		{
    			_pStr = new char[1+4];
    			_pStr += 4;//引用计数占前四个字节,真正开始,得从加上四个字节之后。
    			_pStr = new char('\0');
    		}
    		else{
    			//1、开辟空间
    			_pStr = new char[strlen(pStr) + 1+4];
    			_pStr += 4;
    			//2、把内容拷贝到新空间里面
    			strcpy(_pStr, pStr);
    		}
    		//放引用计数,空间首地址得位置,_pStr向前偏移四个字节
    		GetRef() = 1;
    	}
    	//拷贝构造函数
    	String(const String& s)
    		:_pStr(s._pStr)
    	{
    		GetRef()++;
    	}
    	//普通成员函数,不能调用const修饰得
    	char &operator[](size_t index)
    	{
    		return _pStr[index];
    	}
    	const char &operator[](size_t index)const
    	{
    		return _pStr[index];
    	}
    	//赋值运算符的重载
    	String& operator=(const String&s)
    	{
    		//考虑是否为当前对象,若是共用同一块空间,改变引用计数的值;
    		//没有共用一块空间,则将引用计数减1,减1后若是为0,则释放原空间。,指向新空间,将新空间里面的计数加1
    		//如果两个对象共用一块空间,可以认为是自己给自己赋值。
    		//如果地址不相同,则当前对象和s没有共用同一块空间
    		if (_pStr != s._pStr)
    		{
    			Release();
    			//共用同一块空间、共用同一个引用计数
    			_pStr = s._pStr;
    			++GetRef();//引用计数增加
    		}
    		return *this;
    	}
    	~String()
    	{
    		Release();
    	}
    private:
    	//获取引用计数
    	int &GetRef()
    	{
    		return *((int *)_pStr - 4);
    	}
    	//释放得函数
    	void Release()
    	{
    		if (_pStr && 0 == --GetRef())
    		{
    			_pStr -= 4;
    			delete[] _pStr;//销毁字符串的空间
    			_pStr = NULL;
    		}
    	}
    private:
    	char* _pStr;
     };
    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    	String s3;
    	s3 = s2;
    	const String s4("world");
    	s4[0];
    }
    int main()
    {
    	FunTest();
    	return 0;
    }

    但是此程序存在问题,如果s1和s2和S3共用同一个空间,修改一个三个都会发生改变,仍然为一个浅拷贝。如下测试代码,会导致s1和s2,S3同时发生改变。

    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
            String s3;
            String s4(s3);
            s3=s1;
    	s1[0] = 'w';
    }

    为了优化上述代码,我们要改变哪一个,则将该成员分离出来。我们改变重载下标函数中的内容如下:

    char &operator[](size_t index)
    	{
    		//引用计数大于1,当前对象一定和别人共用同一块引用空间,
    		if (GetRef()>1)
    		{
    			//分离当前对象,即引用计数减1
    			--GetRef();
    			//给当前对象重新开辟空间,用当前对象构造
    			String strTmp(_pStr);
    			//把当前对象的字符串赋值为空
    			_pStr = NULL;
    			Swap(_pStr, strTmp._pStr);
    		}
    		return _pStr[index];
    	}

    采用测试代码如下,会发生错误:

    void FunTest()
    {
    	String s1("haha");
    	String s2(s1);
    	String s3;
    	String s4(s3);
    	s3 = s1;
    	s1[0] = 'w';
    	const String s5(s4);
    	s5[0];
    }

    这是因为const类型的函数不能调用普通类型的成员函数。解决方法,再重载一个const类型的下标运算符

    	char &operator[](size_t index)
    	{
    		//引用计数大于1,当前对象一定和别人共用同一块引用空间,
    		if (GetRef()>1)
    		{
    			//分离当前对象,即引用计数减1
    			--GetRef();
    			//给当前对象重新开辟空间,用当前对象构造
    			String strTmp(_pStr);
    			//把当前对象的字符串赋值为空
    			_pStr = NULL;
    			Swap(_pStr, strTmp._pStr);
    		}
    		return _pStr[index];
    	}
    //const类型的引用的返回值一般都为const,因为当前对象不能改变
    	const char &operator[](size_t index)const
    	{
    		return _pStr[index];
    	}
    此String类不适用于多线程

    总结:

    1、浅拷贝:位拷贝、拷贝构造函数、赋值运算符重载

             多个对象共用同一块资源,当对象被销毁时,同一块资源会被释放 

             多次引起程序崩溃,或者内存泄漏

    解决方式:

    (1)深拷贝---每个对象共同拥有自己的资源,必须程序员显示提供拷贝构造函数以及赋值运算符提供:A、普通版本深拷贝 B、简洁版深拷贝---拷贝(调用构造函数创建临时变量,用临时变量和当前对象交换成员变量)。这种方式不易出错,建议使用。

                       ---赋值

    (2)引用计数---普通成员变量(每个对象中各有一份,改变自己的,不能改变其他人的 不行)

                          ----静态成员变量(所有的对象所共享,只要调用构造函数,计数置为1;被当前对象一个人使用,不行)

                          ----整型的指针

    2、一些常见的String类的功能:

    (1)构造空的字符串

    string ( );
    

    (2)拷贝构造函数(类类型对象的引用)

    string ( const string& str );
    

    (3)构造函数(不是用字符串中所有的内容构造当前对象,而是pos表示从pos位置开始向后取几个字符;npos取得字符得个数。

    string ( const string& str, size_t pos, size_t n = npos );
    

    (4)构造函数(用几个字符来构造,n代表有效字符得个数)

    string ( const char * s, size_t n );
    

    (5)用字符串直接构造当前对象

    string ( const char * s );
    

    (6)字符串构造好了,里面放了n个字符c

    string ( size_t n, char c );

    (7)用一段区间构造,

    template<class InputIterator> string (InputIterator begin, InputIterator end);

    (8)获取字符串得长度:size或者length

    (9)resize:把当前字符串中有效元素得个数改变成n个字符,char c说明把n个字符中多出来得用c补齐。

    void resize ( size_t n, char c );
    void resize ( size_t n );相当于调用上一个函数,少传递了第二个参数

    (10)capacty:底层空间得实际大小

    (11)reserve:把当前字符串底层空间得容量改变,容量既可以增大,又可以减小

    (12)clear:清空;调用后成为空字符串

    (13)下标运算符得重载:传递要获取地方得字符

    const char& operator[] ( size_t pos ) const;
          char& operator[] ( size_t pos );

    (14)at:返回这个位置得字符

    (15)append:拼接

    (16)push_back:尾插

    (17)assign:给字符串重新赋值(可以用一个字符串给另一个字符串赋值哦)【还可以用c格式得字符串进行赋值,相当于重写了一遍】

    string& assign ( size_t n, char c );把一个字符串赋值为c

    (18)insert:任意位置得插入字符或者字符串

    string& insert ( size_t pos1, const string& str );

    从当前位置pos1开始插入一个字符串;

     string& insert ( size_t pos1, size_t n, char c );
    

    从当前位置开始插入n个字符c

    (19)erase:删除


     string& erase ( size_t pos = 0, size_t n = npos );
    

    从当前位置开始删除多少字符

    如果两个参数都没有传,相当于清空,把所有得元素都删除

    (20)replace:替换某一个位置得字符

    (21)swap:对两个字符串进行交换

    (22)c_str:C语言格式得字符串

    const char* c_str ( ) const;

    (23)copy:拷贝

    find:查找

    rfind:反响查找:从后往前查找

    find_first_of:查找第一次出现得

    find_last_of:查找最后一次出现得

    substr:子串

    strcmp:比较

    此后就不一一重复介绍了,详细可以查看资料得意


    展开全文
  • C语言中string函数详解

    万次阅读 2016-11-01 14:10:55
    C语言中string函数

    linux kernel code :  kernel/lib/string.c

    strsep,strtok,strchr ,strstr ......


    PS:本文包含了大部分strings函数的说明,并附带举例说明。本来想自己整理一下的,发现已经有前辈整理过了,就转了过来。修改了原文一些源码的问题,主要是用char *字义字符串的问题,导致程序运行时崩溃。另外自己重写了部分测试程序,使其更能满足自己测试的需要。不当之处,还请海涵。

    @函数原型:  char *strdup(const char *s) 

    函数功能:  字符串拷贝,目的空间由该函数分配  

    函数返回:  指向拷贝后的字符串指针 

    参数说明:  src-待拷贝的源字符串 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>   
    3. #include <alloc.h>   
    4. int main()   
    5. {   
    6.   char *dup_str, *string="abcde";   
    7.   dup_str=strdup(string);   
    8.   printf("%s", dup_str);   
    9.   free(dup_str);   
    10.   return 0;   
    11. }  

     

    @函数名称:  strcpy 

    函数原型:  char* strcpy(char* str1,char* str2); 

    函数功能:  把str2指向的字符串拷贝到str1中去 

    函数返回:  返回str1,即指向str1的指针 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char string[10];   
    6.   char *str1="abcdefghi";   
    7.   strcpy(string,str1);   
    8.   printf("the string is:%s\n",string);   
    9.   return 0;   
    10. }  

     

    @函数名称:  strncpy 

    函数原型:  char *strncpy(char *dest, const char *src,intcount) 

    函数功能:  将字符串src中的count个字符拷贝到字符串dest中去 

    函数返回:  指向dest的指针 

    参数说明:  dest-目的字符串,src-源字符串,count-拷贝的字符个数 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.    char*src = "bbbbbbbbbbbbbbbbbbbb";//20 'b's  
    6.    char dest[50] ="aaaaaaaaaaaaaaaaaaaa";//20 'a's  
    7.    
    8.    puts(dest);  
    9.    strncpy(dest, src, 10);  
    10.    
    11.    puts(dest);    
    12.    return0;   
    13. }  
    输出:

    [cpp] view plain copy
    1. /******************************************* 
    2. aaaaaaaaaaaaaaaaaaaa 
    3. bbbbbbbbbbaaaaaaaaaa 
    4. *******************************************/  
    注意:strncpy只复制指定长度的字符,不会自动在末尾加'\0'。若指定长度超过源字符串长度,不够的部分补‘\0’,

     

    @函数名称:  strcat 

    函数原型:  char* strcat(char * str1,char * str2); 

    函数功能:  把字符串str2接到str1后面,str1最后的'\0'被取消 

    函数返回:  str1 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>  
    3. int main()   
    4. {   
    5.   char buffer[80];  
    6.   strcpy(buffer,"Hello ");   
    7.   strcat(buffer,"world");   
    8.   printf("%s\n",buffer);   
    9.   return 0;   
    10. }  

     

    @函数名称:  strncat 

    函数原型:  char *strncat(char *dest, const char *src, size_t maxlen) 

    函数功能:  将字符串src中前maxlen个字符连接到dest中 

    函数返回: 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>  
    3. char buffer[80];  
    4. int main()   
    5. {   
    6.   strcpy(buffer,"Hello ");   
    7.   strncat(buffer,"world",8);   
    8.   printf("%s\n",buffer);   
    9.   strncat(buffer,"*************",4);   
    10.   printf("%s\n",buffer);   
    11.   return 0;   
    12. }  
    注意:与strncpy不同的是,strncat会自动在末尾加‘\0’,若指定长度超过源字符串长度,则只复制源字符串长度即停止

     

    @函数名称:  strcmp 

    函数原型:  int strcmp(char * str1,char * str2); 

    函数功能:  比较两个字符串str1,str2. 

    函数返回:  str1<str2,返回负数;str1=str2,返回 0;str1>str2,返回正数.  

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   char *buf1="aaa", *buf2="bbb",*buf3="ccc";   
    6.   int ptr;   
    7.   ptr=strcmp(buf2, buf1);   
    8.   if(ptr>0)   
    9.     printf("buffer 2 is greater thanbuffer 1\n");   
    10.   else   
    11.     printf("buffer 2 is less thanbuffer 1\n");   
    12.   ptr=strcmp(buf2, buf3);   
    13.   if(ptr>0)   
    14.     printf("buffer 2 is greater thanbuffer 3\n");   
    15.   else   
    16.     printf("buffer 2 is less thanbuffer 3\n");   
    17.   return 0;   
    18. }  


     

    @函数名称:  strncmp 

    函数原型:  int strncmp(char *str1,char *str2,int count) 

    函数功能:  对str1和str2中的前count个字符按字典顺序比较 

    函数返回:  小于0:str1<str2,等于0:str1=str2,大于0:str1>str2 

    参数说明:  str1,str2-待比较的字符串,count-比较的长度 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.    char str1[] ="aabbc";//  
    6.    char str2[] = "abbcd";//  
    7.    //为使测试程序更简练,此处假定了strncmp只返回-1,0,1三个数  
    8.    char res_info[] = {'<','=','>'};  
    9.    int res;  
    10.    
    11.    //前1个字符比较  
    12.    res = strncmp(str1, str2, 1);  
    13.    printf("1:str1%c str2\n", res_info[res+1]);  
    14.     
    15.     //前3个字符比较  
    16.    res = strncmp(str1, str2, 3);  
    17.    printf("3:str1%c str2\n", res_info[res+1]);  
    18. }  

    输出:

    [cpp] view plain copy
    1. /**************************************** 
    2. 1:str1= str2 
    3. 3:str1< str2 
    4. *****************************************/  


     

    @函数名称:  strpbrk 

    函数原型:  char *strpbrk(const char *s1, const char *s2) 

    函数功能:  得到s1中第一个“同时也出现在s2中”字符的位置指针 

    函数返回:  位置指针 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.    char *p="Find all vowels";  
    6.    
    7.    p=strpbrk(p+1,"aeiouAEIOU");  
    8.    while(p)  
    9.    {  
    10.       printf("%s\n",p);  
    11.       p=strpbrk(p+1,"aeiouAEIOU");  
    12.        
    13.    }  
    14. return 0;   
    15. }  

    输出:

    [cpp] view plain copy
    1. /************************************** 
    2. ind all vowels 
    3. all vowels 
    4. owels 
    5. els 
    6. **************************************/  


     

    @函数名称:  strcspn 

    函数原型:  int strcspn(const char *s1, const char *s2) 

    函数功能:  统计s1中从头开始直到第一个“来自s2中的字符”出现的长度 

    函数返回:  长度 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>  
    3. int main()   
    4. {   
    5.  printf("%d\n",strcspn("abcbcadef","cba"));   
    6.  printf("%d\n",strcspn("xxxbcadef","cba"));   
    7.  printf("%d\n",strcspn("123456789","cba"));   
    8.   return 0;   
    9. }  

    输出:

    [cpp] view plain copy
    1. /************************ 
    2. 0 
    3. 3 
    4. 9 
    5. ************************/  


     

    @函数名称:  strspn 

    函数原型:  int strspn(const char *s1, const char *s2) 

    函数功能:  统计s1中从头开始直到第一个“不来自s2中的字符”出现的长度 

    函数返回:  位置指针 

    参数说明: 

    所属文件:  <string.h>

    [html] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>   
    3. #include<alloc.h>   
    4. int main()   
    5. {   
    6.    printf("%d\n",strspn("abcbcadef","cba"));  
    7.    printf("%d\n",strspn("xxxbcadef","cba"));  
    8.    printf("%d\n",strspn("123456789","cba"));  
    9.    return 0;   
    10. }  
    输出:

    [cpp] view plain copy
    1. /************************ 
    2. 6 
    3. 0 
    4. 0 
    5. ************************/  

     

    @函数名称:  strchr 

    函数原型:  char* strchr(char* str,char ch); 

    函数功能:  找出str指向的字符串中第一次出现字符ch的位置 

    函数返回:  返回指向该位置的指针,如找不到,则返回空指针 

    参数说明:  str-待搜索的字符串,ch-查找的字符 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.    char *str = "This is a string!";  
    6.    char ch;  
    7.    char *p;  
    8.    
    9.    while(1)  
    10.    {  
    11.       printf("Please input a char:");  
    12.       ch = getchar();  
    13.       p = strchr(str, ch);  
    14.       if(p)  
    15.          printf("%c is the %d character of\"%s\"\n",ch, (int)(p-str+1),str);  
    16.       else  
    17.          printf("Not found!\n");  
    18.    
    19.       printf("Press ESC to quit!\n\n");  
    20.       if(27 == getch())  
    21.          break;  
    22.       fflush(stdin);  
    23.    }  
    24.    
    25.   return 0;   
    26. }  

    运行结果:

    [cpp] view plain copy
    1. /******************************************** 
    2. Please input achar:i 
    3. i is the 3character of "This is a string!" 
    4. Press ESC to quit! 
    5.   
    6. Please input achar:l 
    7. Not found! 
    8. Press ESC to quit! 
    9.   
    10. Please input achar:s 
    11. s is the 4character of "This is a string!" 
    12. Press ESC to quit! 
    13. **********************************************/  


     

    @函数名称:  strrchr 

    函数原型:  char *strrchr(const char *s, int c) 

    函数功能:  得到字符串s中最后一个含有c字符的位置指针 

    函数返回:  位置指针 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.   charstring[15];   
    6.   char*ptr,c='r';   
    7.  strcpy(string,"This is a string");   
    8.  ptr=strrchr(string,c);   
    9.   if (ptr)   
    10.    printf("The character %c is at position:%d",c,ptr-string);   
    11.   else   
    12.    printf("The character was not found");   
    13.   return 0;   
    14. }  


     

    @函数名称:  strstr 

    函数原型:  char* strstr(char* str1,char* str2); 

    函数功能:  找出str2字符串在str1字符串中第一次出现的位置(不包括str2的串结束符) 

    函数返回:  返回该位置的指针,如找不到,返回空指针 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.   char*str1="Open Watcom C/C++",*str2="Watcom",*ptr;   
    6.  ptr=strstr(str1,str2);   
    7.  printf("The substring is:%s\n",ptr);   
    8.   return 0;   
    9. }  

    输出:

    The substringis:Watcom C/C++


    char *strcasestr(const char *haystack, const char *needle);
    用于在c串haystack中查找c串needle,忽略大小写。如果找到则返回needle串在haystack串中第一次出现的位置的char指针.


    C语言中(‍string.h)定义了用于进行忽略大小写的字符串比较的函数strcasecmpstrncasecmp

     

    @函数名称:  strrev 

     函数原型:  char *strrev(char *s) 

    函数功能:  将字符串中的所有字符颠倒次序排列 

    函数返回:  指向s的指针  

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.   char forward[]="string"//原文中定义为char*是不对的,指向代码段的指针内容是不可变的  
    6.  printf("Before strrev():%s",forward);   
    7.  strrev(forward);   
    8.   printf("Afterstrrev(): %s",forward);   
    9.   return 0;   
    10. }  
    输出:

    [cpp] view plain copy
    1. /************************************ 
    2. Beforestrrev():string 
    3. After strrev():gnirts 
    4. ************************************/  


     

    @函数名称:  strnset 

    函数原型:  char *strnset(char *s, int ch, size_t n) 

    函数功能:  将字符串s中前n个字符设置为ch的值 

    函数返回:  指向s的指针 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.    charstring[]="aaaaaaaaaaaaaaaaaaaaaaa";  
    6.    char letter='x';  
    7.    printf("string before strnset:%s\n",string);  
    8.    strnset(string,letter,10);  
    9.    printf("string after strnset:  %s\n",string);  
    10.    
    11. return 0;   
    12. }  

    输出:

    [cpp] view plain copy
    1. /************************************************* 
    2. string beforestrnset: aaaaaaaaaaaaaaaaaaaaaaa 
    3. string afterstrnset:  xxxxxxxxxxaaaaaaaaaaaaa 
    4. *************************************************/  


     

    @函数名称:  strset 

    函数原型:  char *strset(char *s, int ch) 

    函数功能:  将字符串s中所有字符设置为ch的值 

    函数返回:  指向s的指针  

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.   charstring[10]="123456789";   
    6.   charsymbol='c';   
    7.  printf("Before strset(): %s", string);   
    8.  strset(string, symbol);   
    9.  printf("After strset(): %s", string);   
    10.   return 0;   
    11. }  


     

    @函数名称:  strtok 

    函数原型:  char *strtok(char *s1, const char *s2) 

    函数功能:  分解s1字符串为用特定分隔符分隔的多个字符串(一般用于将英文句分解为单词) 

    函数返回:  字符串s1中首次出现s2中的字符前的子字符串指针 

    参数说明:  s2一般设置为s1中的分隔字符 

            规定进行子调用时(即分割s1的第二、三及后续子串)第一参数必须是NULL 

            在每一次匹配成功后,将s1中分割出的子串位置替换为NULL(摘下链中第一个环),因此s1被破坏了 

            函数会记忆指针位置以供下一次调用 

             

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.   char *p;   
    6.   char*buffer;   
    7.   char*delims={ " .," };  
    8.  buffer=strdup("Find words, all of them.");   
    9.  printf("%s\n",buffer);   
    10.  p=strtok(buffer,delims);   
    11.  while(p!=NULL){   
    12.    printf("word: %s\n",p);   
    13.    p=strtok(NULL,delims);   
    14.   }   
    15.  printf("%s\n",buffer);   
    16.   return 0;   
    17. }//根据测试,可以随时给strtok的第一个参数输入一个新的字符串,开始新字符串的分隔  

    PS:根据测试,可以随时给strtok的第一个参数输入一个新的字符串,开始新字符串的分隔


    strsep(),作为strtok的升级版,是一个很有用的字符串处理函数

    man strsep:

    #include <string.h>  

         char*strsep(char **stringp, const char *delim);

    Be cautious when using this function. If you do use it, note that:  

    This function modifies its first argument.  

    This function cannot be used on constant strings.  

    The identity of the delimiting character is lost.

    1. #include <stdio.h>   
    2. #include <string.h>  
    3. int main(void)  
    4. {     
    5.     char s[] = "hello world!";  
    6.     char *p = s;   
    7.     char *d = " ";    
    8.     printf("%s\n", strsep(&p, d));      
    9.     printf("%s\n", p);    
    10.     return 0;  
    11. }  
    12. 函数打印如下:helloworld!  


     

    @函数名称:  strupr 

    函数原型:  char *strupr(char *s) 

    函数功能:  将字符串s中的字符变为大写 

    函数返回: 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char string[]="abcdefghijklmnopqrstuvwxyz",*ptr; //会影响原字符串的内存,用char[]来声明  
    6.   ptr=strupr(string);   
    7.   printf("%s",ptr);   
    8.   return 0;   
    9. }  


     

    @函数名称:  strlwr 

    函数原型:  char *strlwr(char *s) 

    函数功能:  将字符串中的字符变为小写字符 

    函数返回:  指向s的指针 

    参数说明: 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include<string.h>   
    2. int main()   
    3. {   
    4.   char str[]="HOW TO SAY?";   
    5.   printf("%s",strlwr(str));   
    6.   return 0;   
    7. }  


     

    @函数名称:  strerror 

    函数原型:  char *strerror(int errnum) 

    函数功能:  得到错误信息的内容信息 

     函数返回:  错误提示信息字符串指针 

    参数说明:  errnum-错误编号 

    所属文件:  <string.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <errno.h>   
    3. int main()   
    4. {   
    5.   char *buffer;   
    6.   buffer=strerror(errno);   
    7.   printf("Error: %s",buffer);   
    8.   return 0;   
    9. }  


     

    @函数名称:  memcpy 

    函数原型:  void *memcpy(void *dest, const void *src, size_t n) 

    函数功能:  字符串拷贝 

    函数返回:  指向dest的指针 

    参数说明:  src-源字符串,n-拷贝的最大长度 

    所属文件:  <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char src[]="******************************";   
    6.   char dest[]="abcdefghijlkmnopqrstuvwxyz0123456709";   
    7.   char *ptr;   
    8.   printf("destination before memcpy:%s\n",dest);   
    9.   ptr=memcpy(dest,src,strlen(src));   
    10.   if (ptr)   
    11.     printf("destination after memcpy:%s\n",dest);   
    12.   else   
    13.     printf("memcpy failed");   
    14.   return 0;   
    15. }  
    输出:

    [cpp] view plain copy
    1. /************************************************************* 
    2. destination before memcpy:abcdefghijlkmnopqrstuvwxyz0123456709 
    3. destination after memcpy:******************************456709 
    4. **************************************************************/  



     

    @函数名称:  memccpy 

    函数原型:  void *memccpy(void *dest, const void *src, int c, size_t n) 

    函数功能:  字符串拷贝,到指定长度或遇到指定字符时停止拷贝 

    函数返回: 

    参数说明:  src-源字符串指针,c-中止拷贝检查字符,n-长度,dest-拷贝底目的字符串指针 

    所属文件:  <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   char *src="This is the source string";   
    6.   char dest[50];   
    7.   char *ptr;   
    8.   ptr=memccpy(dest,src,'c',strlen(src));   
    9.   if (ptr)   
    10.   {   
    11.     *ptr='\0';   
    12.     printf("The character wasfound:%s",dest);   
    13.   }   
    14.   else   
    15.     printf("The character wasn'tfound");   
    16.   return 0;   
    17. }  
    输出:

    [cpp] view plain copy
    1. /***************************************** 
    2. The character was found:This is the sourc 
    3. *****************************************/  

    PS:指定字符被复制到dest中,memccpy返回了dest中指定字符的下一处的地址,返回NULL表示未遇到指定字符

     

    @函数名称:  memchr 

    函数原型:  void *memchr(const void *s, int c, size_t n) 

    函数功能:  在字符串中第开始n个字符中寻找某个字符c的位置 

    函数返回:  返回c的位置指针,返回NULL时表示未找到 

    参数说明:  s-要搜索的字符串,c-要寻找的字符,n-指定长度 

    所属文件:  <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   char str[17];   
    6.   char *ptr;   
    7.   strcpy(str,"This is a string");   
    8.   ptr=memchr(str,'r',strlen(str));   
    9.   if (ptr)   
    10.   printf("The character 'r' is at position:%d",ptr-str);   
    11.   else   
    12.   printf("The character was not found");   
    13.   return 0;   
    14. }  

    memrchr 和上面类似只不过是返回ch的结尾。



     

    @函数名称:  memcmp 

    函数原型:  int memcmp(const void *s1, const void *s2,size_t n) 

    函数功能:  按字典顺序比较两个串s1和s2的前n个字节  

    函数返回:  <0,=0,>0分别表示s1<,=,>s2 

    参数说明:  s1,s2-要比较的字符串,n-比较的长度 

    所属文件:  <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()    
    4. {    
    5.   char *buf1="ABCDE123";    
    6.   char *buf2="abcde456";    
    7.   int stat;    
    8.   stat=memcmp(buf1,buf2,5);    
    9.   printf("The strings to position 5 are");    
    10.   if(stat) printf("not ");    
    11.   printf("the same\n");    
    12.   return 0;    
    13. }   


     

    @函数名称:  memicmp 

    函数原型:  int memicmp(const void *s1, const void *s2, size_t n) 

    函数功能:  按字典顺序、不考虑字母大小写对字符串s1,s2前n个字符比较 

    函数返回:  <0,=0,>0分别表示s1<,=,>s2 

    参数说明:  s1,s2-要比较的字符串,n-比较的长度 

    所属文件:  <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char *buf1="ABCDE123";   
    6.   char *buf2="abcde456";   
    7.   int stat;   
    8.   stat=memicmp(buf1,buf2,5);   
    9.   printf("The strings to position 5 are");   
    10.   if(stat) printf("not");   
    11.   printf("the same");   
    12.   return 0;   
    13. }  
    输出:

    [cpp] view plain copy
    1. /************************************** 
    2. The strings to position 5 are the same 
    3. ***************************************/  


     

    @函数名称:  memmove 

    函数原型:  void *memmove(void *dest, const void *src, size_t n) 

    函数功能:  字符串拷贝 

    函数返回:  指向dest的指针 

    参数说明:  src-源字符串,n-拷贝的最大长度 

    所属文件:  <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   chardest[40]="abcdefghijklmnopqrstuvwxyz0123456789";   
    6.   printf("destination prior tomemmove:%s\n",dest);   
    7.   memmove(dest+1,dest,35);   
    8.   printf("destination aftermemmove:%s",dest);   
    9.   return 0;   
    10. }  

    PS:与memcpy不同的是,memmove可以处理目的字符串与源字符串地址空间出现重叠的情况,可保证待复制的内容不被破坏。


    @函数名称:   memset

    函数原型:   void *memset(void *s, int c, size_t n)

    函数功能:   字符串中的n个字节内容设置为c

    函数返回:

    参数说明:   s-要设置的字符串,c-设置的内容,n-长度

    所属文件:   <string.h>,<mem.h>

    [cpp] view plain copy
    1. #include <string.h>  
    2. #include <stdio.h>  
    3. #include <mem.h>  
    4. int main()  
    5. {  
    6.   charbuffer[]="Hello world";  
    7.  printf("Buffer before memset:%s/n",buffer);  
    8.  memset(buffer,'*',strlen(buffer)-1);  
    9.  printf("Buffer after memset:%s",buffer);  
    10.   return 0;  
    11. }  

    展开全文
  • to_string函数的用法

    千次阅读 2019-07-20 19:12:23
    to_string 函数:将数字常量转换为字符串,返回值为转换完毕的字符串 头文件:#include<string> string s = to_string(i); //将整数i转换为字符串表示形式 string to_string (int val); string to_string ...

    to_string 函数:将数字常量转换为字符串,返回值为转换完毕的字符串

    头文件:#include<string>

    string s = to_string(i); //将整数i转换为字符串表示形式

    string to_string (int val);
    string to_string (long val);
    string to_string (long long val);
    string to_string (unsigned val);
    string to_string (unsigned long val);
    string to_string (unsigned long long val);
    string to_string (float val);
    string to_string (double val);
    string to_string (long double val);


    参考举例:

    #include <iostream>   
    #include <string>     
    using namespace std;
    
    int main()
    {
        string pi = "pi is " + std::to_string(3.1415926);
        string perfect = to_string(1 + 2 + 4 + 7 + 14) + " is a perfect number";
        cout << pi << '\n';
        cout << perfect << '\n';
        system("pause");
        return 0;
    }

    说明:本博客所有内容为参考书籍以及他人博客总结,为个人学习笔记所用。

    展开全文
  • c语言string函数详解

    万次阅读 多人点赞 2018-08-03 15:45:49
    linux kernel code : kernel/lib/string.c strsep,strtok,strchr ,strstr ......     PS:本文包含了大部分strings函数的说明,并附带举例说明。本来想自己整理一下的,发现已经有前辈整理过了,就转了过来...

    linux kernel code :  kernel/lib/string.c

    strsep,strtok,strchr ,strstr ......

     

     

    PS:本文包含了大部分strings函数的说明,并附带举例说明。本来想自己整理一下的,发现已经有前辈整理过了,就转了过来。

    @函数原型:  char *strdup(const char *s) 

     

    函数功能:  字符串拷贝,目的空间由该函数分配  

    函数返回:  指向拷贝后的字符串指针 

    参数说明:  src-待拷贝的源字符串 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>   
    3. #include <alloc.h>   
    4. int main()   
    5. {   
    6.   char *dup_str, *string="abcde";   
    7.   dup_str=strdup(string);   
    8.   printf("%s", dup_str);   
    9.   free(dup_str);   
    10.   return 0;   
    11. }  


     

     

    @函数名称:  strcpy 

    函数原型:  char* strcpy(char* str1,char* str2); 

    函数功能:  把str2指向的字符串拷贝到str1中去 

    函数返回:  返回str1,即指向str1的指针 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char string[10];   
    6.   char *str1="abcdefghi";   
    7.   strcpy(string,str1);   
    8.   printf("the string is:%s\n",string);   
    9.   return 0;   
    10. }  


     

     

    @函数名称:  strncpy 

    函数原型:  char *strncpy(char *dest, const char *src,intcount) 

    函数功能:  将字符串src中的count个字符拷贝到字符串dest中去 

    函数返回:  指向dest的指针 

    参数说明:  dest-目的字符串,src-源字符串,count-拷贝的字符个数 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.    char*src = "bbbbbbbbbbbbbbbbbbbb";//20 'b's  
    6.    char dest[50] ="aaaaaaaaaaaaaaaaaaaa";//20 'a's  
    7.    
    8.    puts(dest);  
    9.    strncpy(dest, src, 10);  
    10.    
    11.    puts(dest);    
    12.    return0;   
    13. }  

    输出:

     

     

    [cpp] view plain copy

    1. /******************************************* 
    2. aaaaaaaaaaaaaaaaaaaa 
    3. bbbbbbbbbbaaaaaaaaaa 
    4. *******************************************/  

    注意:strncpy只复制指定长度的字符,不会自动在末尾加'\0'。若指定长度超过源字符串长度,不够的部分补‘\0’,
     

     

     

    @函数名称:  strcat 

    函数原型:  char* strcat(char * str1,char * str2); 

    函数功能:  把字符串str2接到str1后面,str1最后的'\0'被取消 

    函数返回:  str1 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>  
    3. int main()   
    4. {   
    5.   char buffer[80];  
    6.   strcpy(buffer,"Hello ");   
    7.   strcat(buffer,"world");   
    8.   printf("%s\n",buffer);   
    9.   return 0;   
    10. }  


     

     

    @函数名称:  strncat 

    函数原型:  char *strncat(char *dest, const char *src, size_t maxlen) 

    函数功能:  将字符串src中前maxlen个字符连接到dest中 

    函数返回: 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>  
    3. char buffer[80];  
    4. int main()   
    5. {   
    6.   strcpy(buffer,"Hello ");   
    7.   strncat(buffer,"world",8);   
    8.   printf("%s\n",buffer);   
    9.   strncat(buffer,"*************",4);   
    10.   printf("%s\n",buffer);   
    11.   return 0;   
    12. }  

    注意:与strncpy不同的是,strncat会自动在末尾加‘\0’,若指定长度超过源字符串长度,则只复制源字符串长度即停止
     

     

     

    @函数名称:  strcmp 

    函数原型:  int strcmp(char * str1,char * str2); 

    函数功能:  比较两个字符串str1,str2. 

    函数返回:  str1<str2,返回负数;str1=str2,返回 0;str1>str2,返回正数.  

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   char *buf1="aaa", *buf2="bbb",*buf3="ccc";   
    6.   int ptr;   
    7.   ptr=strcmp(buf2, buf1);   
    8.   if(ptr>0)   
    9.     printf("buffer 2 is greater thanbuffer 1\n");   
    10.   else   
    11.     printf("buffer 2 is less thanbuffer 1\n");   
    12.   ptr=strcmp(buf2, buf3);   
    13.   if(ptr>0)   
    14.     printf("buffer 2 is greater thanbuffer 3\n");   
    15.   else   
    16.     printf("buffer 2 is less thanbuffer 3\n");   
    17.   return 0;   
    18. }  


     

     

     

    @函数名称:  strncmp 

    函数原型:  int strncmp(char *str1,char *str2,int count) 

    函数功能:  对str1和str2中的前count个字符按字典顺序比较 

    函数返回:  小于0:str1<str2,等于0:str1=str2,大于0:str1>str2 

    参数说明:  str1,str2-待比较的字符串,count-比较的长度 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.    char str1[] ="aabbc";//  
    6.    char str2[] = "abbcd";//  
    7.    //为使测试程序更简练,此处假定了strncmp只返回-1,0,1三个数  
    8.    char res_info[] = {'<','=','>'};  
    9.    int res;  
    10.    
    11.    //前1个字符比较  
    12.    res = strncmp(str1, str2, 1);  
    13.    printf("1:str1%c str2\n", res_info[res+1]);  
    14.     
    15.     //前3个字符比较  
    16.    res = strncmp(str1, str2, 3);  
    17.    printf("3:str1%c str2\n", res_info[res+1]);  
    18. }  

    输出:

     

    [cpp] view plain copy

    1. /**************************************** 
    2. 1:str1= str2 
    3. 3:str1< str2 
    4. *****************************************/  


     

     

     

    @函数名称:  strpbrk 

    函数原型:  char *strpbrk(const char *s1, const char *s2) 

    函数功能:  得到s1中第一个“同时也出现在s2中”字符的位置指针 

    函数返回:  位置指针 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.    char *p="Find all vowels";  
    6.    
    7.    p=strpbrk(p+1,"aeiouAEIOU");  
    8.    while(p)  
    9.    {  
    10.       printf("%s\n",p);  
    11.       p=strpbrk(p+1,"aeiouAEIOU");  
    12.        
    13.    }  
    14. return 0;   
    15. }  

    输出:

     

    [cpp] view plain copy

    1. /************************************** 
    2. ind all vowels 
    3. all vowels 
    4. owels 
    5. els 
    6. **************************************/  


     

     

     

    @函数名称:  strcspn 

    函数原型:  int strcspn(const char *s1, const char *s2) 

    函数功能:  统计s1中从头开始直到第一个“来自s2中的字符”出现的长度 

    函数返回:  长度 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>  
    3. int main()   
    4. {   
    5.  printf("%d\n",strcspn("abcbcadef","cba"));   
    6.  printf("%d\n",strcspn("xxxbcadef","cba"));   
    7.  printf("%d\n",strcspn("123456789","cba"));   
    8.   return 0;   
    9. }  

    输出:

     

    [cpp] view plain copy

    1. /************************ 
    2. ************************/  


     

     

     

    @函数名称:  strspn 

    函数原型:  int strspn(const char *s1, const char *s2) 

    函数功能:  统计s1中从头开始直到第一个“不来自s2中的字符”出现的长度 

    函数返回:  位置指针 

    参数说明: 

    所属文件:  <string.h>

     

    [html] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>   
    3. #include<alloc.h>   
    4. int main()   
    5. {   
    6.    printf("%d\n",strspn("abcbcadef","cba"));  
    7.    printf("%d\n",strspn("xxxbcadef","cba"));  
    8.    printf("%d\n",strspn("123456789","cba"));  
    9.    return 0;   
    10. }  

    输出:

     

     

    [cpp] view plain copy

    1. /************************ 
    2. ************************/  

     

     

     

    @函数名称:  strchr 

    函数原型:  char* strchr(char* str,char ch); 

    函数功能:  找出str指向的字符串中第一次出现字符ch的位置 

    函数返回:  返回指向该位置的指针,如找不到,则返回空指针 

    参数说明:  str-待搜索的字符串,ch-查找的字符 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.    char *str = "This is a string!";  
    6.    char ch;  
    7.    char *p;  
    8.    
    9.    while(1)  
    10.    {  
    11.       printf("Please input a char:");  
    12.       ch = getchar();  
    13.       p = strchr(str, ch);  
    14.       if(p)  
    15.          printf("%c is the %d character of\"%s\"\n",ch, (int)(p-str+1),str);  
    16.       else  
    17.          printf("Not found!\n");  
    18.    
    19.       printf("Press ESC to quit!\n\n");  
    20.       if(27 == getch())  
    21.          break;  
    22.       fflush(stdin);  
    23.    }  
    24.    
    25.   return 0;   
    26. }  

    运行结果:

     

    [cpp] view plain copy

    1. /******************************************** 
    2. Please input achar:i 
    3. i is the 3character of "This is a string!" 
    4. Press ESC to quit! 
    5.   
    6. Please input achar:l 
    7. Not found! 
    8. Press ESC to quit! 
    9.   
    10. Please input achar:s 
    11. s is the 4character of "This is a string!" 
    12. Press ESC to quit! 
    13. **********************************************/  


     

     

     

    @函数名称:  strrchr 

    函数原型:  char *strrchr(const char *s, int c) 

    函数功能:  得到字符串s中最后一个含有c字符的位置指针 

    函数返回:  位置指针 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.   charstring[15];   
    6.   char*ptr,c='r';   
    7.  strcpy(string,"This is a string");   
    8.  ptr=strrchr(string,c);   
    9.   if (ptr)   
    10.    printf("The character %c is at position:%d",c,ptr-string);   
    11.   else   
    12.    printf("The character was not found");   
    13.   return 0;   
    14. }  


     

     

     

    @函数名称:  strstr 

    函数原型:  char* strstr(char* str1,char* str2); 

    函数功能:  找出str2字符串在str1字符串中第一次出现的位置(不包括str2的串结束符) 

    函数返回:  返回该位置的指针,如找不到,返回空指针 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.   char*str1="Open Watcom C/C++",*str2="Watcom",*ptr;   
    6.  ptr=strstr(str1,str2);   
    7.  printf("The substring is:%s\n",ptr);   
    8.   return 0;   
    9. }  

    输出:

    The substringis:Watcom C/C++

     

     

    char *strcasestr(const char *haystack, const char *needle);
    用于在c串haystack中查找c串needle,忽略大小写。如果找到则返回needle串在haystack串中第一次出现的位置的char指针.

     

    C语言中(‍string.h)定义了用于进行忽略大小写的字符串比较的函数strcasecmpstrncasecmp

     

    @函数名称:  strrev 

     函数原型:  char *strrev(char *s) 

    函数功能:  将字符串中的所有字符颠倒次序排列 

    函数返回:  指向s的指针  

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.   char forward[]="string"; //原文中定义为char*是不对的,指向代码段的指针内容是不可变的  
    6.  printf("Before strrev():%s",forward);   
    7.  strrev(forward);   
    8.   printf("Afterstrrev(): %s",forward);   
    9.   return 0;   
    10. }  

    输出:

     

     

    [cpp] view plain copy

    1. /************************************ 
    2. Beforestrrev():string 
    3. After strrev():gnirts 
    4. ************************************/  


     

     

     

    @函数名称:  strnset 

    函数原型:  char *strnset(char *s, int ch, size_t n) 

    函数功能:  将字符串s中前n个字符设置为ch的值 

    函数返回:  指向s的指针 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.    charstring[]="aaaaaaaaaaaaaaaaaaaaaaa";  
    6.    char letter='x';  
    7.    printf("string before strnset:%s\n",string);  
    8.    strnset(string,letter,10);  
    9.    printf("string after strnset:  %s\n",string);  
    10.    
    11. return 0;   
    12. }  

    输出:

     

    [cpp] view plain copy

    1. /************************************************* 
    2. string beforestrnset: aaaaaaaaaaaaaaaaaaaaaaa 
    3. string afterstrnset:  xxxxxxxxxxaaaaaaaaaaaaa 
    4. *************************************************/  


     

     

     

    @函数名称:  strset 

    函数原型:  char *strset(char *s, int ch) 

    函数功能:  将字符串s中所有字符设置为ch的值 

    函数返回:  指向s的指针  

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<stdio.h>   
    2. #include<string.h>   
    3. int main()   
    4. {   
    5.   charstring[10]="123456789";   
    6.   charsymbol='c';   
    7.  printf("Before strset(): %s", string);   
    8.  strset(string, symbol);   
    9.  printf("After strset(): %s", string);   
    10.   return 0;   
    11. }  


     

     

     

    @函数名称:  strtok 

    函数原型:  char *strtok(char *s1, const char *s2) 

    函数功能:  分解s1字符串为用特定分隔符分隔的多个字符串(一般用于将英文句分解为单词) 

    函数返回:  字符串s1中首次出现s2中的字符前的子字符串指针 

    参数说明:  s2一般设置为s1中的分隔字符 

            规定进行子调用时(即分割s1的第二、三及后续子串)第一参数必须是NULL 

            在每一次匹配成功后,将s1中分割出的子串位置替换为NULL(摘下链中第一个环),因此s1被破坏了 

            函数会记忆指针位置以供下一次调用 

             

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<string.h>   
    2. #include<stdio.h>   
    3. int main()   
    4. {   
    5.   char *p;   
    6.   char*buffer;   
    7.   char*delims={ " .," };  
    8.  buffer=strdup("Find words, all of them.");   
    9.  printf("%s\n",buffer);   
    10.  p=strtok(buffer,delims);   
    11.  while(p!=NULL){   
    12.    printf("word: %s\n",p);   
    13.    p=strtok(NULL,delims);   
    14.   }   
    15.  printf("%s\n",buffer);   
    16.   return 0;   
    17. }//根据测试,可以随时给strtok的第一个参数输入一个新的字符串,开始新字符串的分隔  

    PS:根据测试,可以随时给strtok的第一个参数输入一个新的字符串,开始新字符串的分隔

     

     

    strsep(),作为strtok的升级版,是一个很有用的字符串处理函数

    man strsep:

    #include <string.h>  

         char*strsep(char **stringp, const char *delim);

    Be cautious when using this function. If you do use it, note that:  

    This function modifies its first argument.  

    This function cannot be used on constant strings.  

    The identity of the delimiting character is lost.

     

    [cpp] view plain copy

      

    1. #include <stdio.h>   
    2. #include <string.h>  
    3. int main(void)  
    4. {     
    5.     char s[] = "hello world!";  
    6.     char *p = s;   
    7.     char *d = " ";    
    8.     printf("%s\n", strsep(&p, d));      
    9.     printf("%s\n", p);    
    10.     return 0;  
    11. }  
    12. 函数打印如下:helloworld!  

     

     

     

    @函数名称:  strupr 

    函数原型:  char *strupr(char *s) 

    函数功能:  将字符串s中的字符变为大写 

    函数返回: 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char string[]="abcdefghijklmnopqrstuvwxyz",*ptr; //会影响原字符串的内存,用char[]来声明  
    6.   ptr=strupr(string);   
    7.   printf("%s",ptr);   
    8.   return 0;   
    9. }  


     

     

     

    @函数名称:  strlwr 

    函数原型:  char *strlwr(char *s) 

    函数功能:  将字符串中的字符变为小写字符 

    函数返回:  指向s的指针 

    参数说明: 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include<string.h>   
    2. int main()   
    3. {   
    4.   char str[]="HOW TO SAY?";   
    5.   printf("%s",strlwr(str));   
    6.   return 0;   
    7. }  


     

     

     

    @函数名称:  strerror 

    函数原型:  char *strerror(int errnum) 

    函数功能:  得到错误信息的内容信息 

     函数返回:  错误提示信息字符串指针 

    参数说明:  errnum-错误编号 

    所属文件:  <string.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <errno.h>   
    3. int main()   
    4. {   
    5.   char *buffer;   
    6.   buffer=strerror(errno);   
    7.   printf("Error: %s",buffer);   
    8.   return 0;   
    9. }  


     

     

     

    @函数名称:  memcpy 

    函数原型:  void *memcpy(void *dest, const void *src, size_t n) 

    函数功能:  字符串拷贝 

    函数返回:  指向dest的指针 

    参数说明:  src-源字符串,n-拷贝的最大长度 

    所属文件:  <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char src[]="******************************";   
    6.   char dest[]="abcdefghijlkmnopqrstuvwxyz0123456709";   
    7.   char *ptr;   
    8.   printf("destination before memcpy:%s\n",dest);   
    9.   ptr=memcpy(dest,src,strlen(src));   
    10.   if (ptr)   
    11.     printf("destination after memcpy:%s\n",dest);   
    12.   else   
    13.     printf("memcpy failed");   
    14.   return 0;   
    15. }  

    输出:

     

     

    [cpp] view plain copy

    1. /************************************************************* 
    2. destination before memcpy:abcdefghijlkmnopqrstuvwxyz0123456709 
    3. destination after memcpy:******************************456709 
    4. **************************************************************/  



     

     

     

    @函数名称:  memccpy 

    函数原型:  void *memccpy(void *dest, const void *src, int c, size_t n) 

    函数功能:  字符串拷贝,到指定长度或遇到指定字符时停止拷贝 

    函数返回: 

    参数说明:  src-源字符串指针,c-中止拷贝检查字符,n-长度,dest-拷贝底目的字符串指针 

    所属文件:  <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   char *src="This is the source string";   
    6.   char dest[50];   
    7.   char *ptr;   
    8.   ptr=memccpy(dest,src,'c',strlen(src));   
    9.   if (ptr)   
    10.   {   
    11.     *ptr='\0';   
    12.     printf("The character wasfound:%s",dest);   
    13.   }   
    14.   else   
    15.     printf("The character wasn'tfound");   
    16.   return 0;   
    17. }  

    输出:

     

     

    [cpp] view plain copy

    1. /***************************************** 
    2. The character was found:This is the sourc 
    3. *****************************************/  


    PS:指定字符被复制到dest中,memccpy返回了dest中指定字符的下一处的地址,返回NULL表示未遇到指定字符

     

     

    @函数名称:  memchr 

    函数原型:  void *memchr(const void *s, int c, size_t n) 

    函数功能:  在字符串中第开始n个字符中寻找某个字符c的位置 

    函数返回:  返回c的位置指针,返回NULL时表示未找到 

    参数说明:  s-要搜索的字符串,c-要寻找的字符,n-指定长度 

    所属文件:  <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   char str[17];   
    6.   char *ptr;   
    7.   strcpy(str,"This is a string");   
    8.   ptr=memchr(str,'r',strlen(str));   
    9.   if (ptr)   
    10.   printf("The character 'r' is at position:%d",ptr-str);   
    11.   else   
    12.   printf("The character was not found");   
    13.   return 0;   
    14. }  

    memrchr 和上面类似只不过是返回ch的结尾。


     

     

     

    @函数名称:  memcmp 

    函数原型:  int memcmp(const void *s1, const void *s2,size_t n) 

    函数功能:  按字典顺序比较两个串s1和s2的前n个字节  

    函数返回:  <0,=0,>0分别表示s1<,=,>s2 

    参数说明:  s1,s2-要比较的字符串,n-比较的长度 

    所属文件:  <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()    
    4. {    
    5.   char *buf1="ABCDE123";    
    6.   char *buf2="abcde456";    
    7.   int stat;    
    8.   stat=memcmp(buf1,buf2,5);    
    9.   printf("The strings to position 5 are");    
    10.   if(stat) printf("not ");    
    11.   printf("the same\n");    
    12.   return 0;    
    13. }   


     

     

     

    @函数名称:  memicmp 

    函数原型:  int memicmp(const void *s1, const void *s2, size_t n) 

    函数功能:  按字典顺序、不考虑字母大小写对字符串s1,s2前n个字符比较 

    函数返回:  <0,=0,>0分别表示s1<,=,>s2 

    参数说明:  s1,s2-要比较的字符串,n-比较的长度 

    所属文件:  <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <stdio.h>   
    2. #include <string.h>   
    3. int main()   
    4. {   
    5.   char *buf1="ABCDE123";   
    6.   char *buf2="abcde456";   
    7.   int stat;   
    8.   stat=memicmp(buf1,buf2,5);   
    9.   printf("The strings to position 5 are");   
    10.   if(stat) printf("not");   
    11.   printf("the same");   
    12.   return 0;   
    13. }  

    输出:

     

     

    [cpp] view plain copy

    1. /************************************** 
    2. The strings to position 5 are the same 
    3. ***************************************/  


     

     

     

    @函数名称:  memmove 

    函数原型:  void *memmove(void *dest, const void *src, size_t n) 

    函数功能:  字符串拷贝 

    函数返回:  指向dest的指针 

    参数说明:  src-源字符串,n-拷贝的最大长度 

    所属文件:  <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <string.h>   
    2. #include <stdio.h>   
    3. int main()   
    4. {   
    5.   chardest[40]="abcdefghijklmnopqrstuvwxyz0123456789";   
    6.   printf("destination prior tomemmove:%s\n",dest);   
    7.   memmove(dest+1,dest,35);   
    8.   printf("destination aftermemmove:%s",dest);   
    9.   return 0;   
    10. }  

     

    PS:与memcpy不同的是,memmove可以处理目的字符串与源字符串地址空间出现重叠的情况,可保证待复制的内容不被破坏。

     

    @函数名称:   memset

    函数原型:   void *memset(void *s, int c, size_t n)

    函数功能:   字符串中的n个字节内容设置为c

    函数返回:

    参数说明:   s-要设置的字符串,c-设置的内容,n-长度

    所属文件:   <string.h>,<mem.h>

     

    [cpp] view plain copy

    1. #include <string.h>  
    2. #include <stdio.h>  
    3. #include <mem.h>  
    4. int main()  
    5. {  
    6.   charbuffer[]="Hello world";  
    7.  printf("Buffer before memset:%s/n",buffer);  
    8.  memset(buffer,'*',strlen(buffer)-1);  
    9.  printf("Buffer after memset:%s",buffer);  
    10.   return 0;  
    11. }  
    展开全文
  • C++ string 函数 1、string类的构造函数string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外,string类还支持默认构造函数和复制构造函数,如string s1;string ...
  • string函数小结

    千次阅读 2020-01-29 15:37:49
    string> #include <cstring> 基本用法: string a, b; //定义两个字符串变量 a = "123 456"; //赋值 b = "abc def"; a = b; //赋值 len = a.length(); len = a.size(); //返回字符...
  • mysql_escape_string函数报错

    千次阅读 2014-10-31 13:17:59
    mysql数据库在插入数据时,为了防止数据攻击,会使用mysql_escape_string函数进行特殊字符的转义处理
  • JAVA中的String函数

    千次阅读 2010-08-02 11:05:00
    一些JAVA中常用的String函数,记录下来,以备后用。
  • Go string函数与strconv.Itoa函数的区别

    千次阅读 2019-09-02 09:58:58
    Go string()与strconv.Itoa()的区别。
  • --从右边截取字符串'hello world',返回长度为4的字符串 [master:21000] > select strright('hello world',4) as strright; +----------+ | strright | +----------+ | orld | +----------+
  • C语言实现各类string函数

    千次阅读 2019-06-21 23:05:54
    函数原型:char strcpy(char dest, const char src); strcpy把含有’\0’结束符的字符串复制到另一个地址空间,返回值的类型为char。 代码: #include<stdio.h> #include<windows.h> #include<...
  • impala常用String函数大全(超详细)

    千次阅读 2020-09-29 15:35:47
    Impala中字符串函数主要应用于 varchar、char、string类型,如果把varchar或者char类型的值传递给字符串函数,返回将是一个string类型的值 函数列表 base64encode(string str) base64decode(string str) ==> 加密...
  • c++string函数详解

    千次阅读 2012-04-08 08:35:53
    首先,为了在我们的程序中使用string类型,我们必须包含头文件 。...这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。上面的声明没有传入参数,所以就直接使用了string的默
  • C++实现to_string函数--int to string

    千次阅读 2018-02-13 15:36:33
    本文是转载博客,用于自己的学习,原文博客点击打开链接to_string()函数返回字符串形式,功能就是将整型的数字,转化为字符串.例如:#include&lt;iostream&gt; #include&lt;string&gt; using ...
  • PHP simplexml_load_string函数

    千次阅读 2019-04-18 12:28:56
    simplexml_load_string() 函数把 XML 字符串载入对象中。 如果失败,则返回 false。 语法 simplexml_load_file(string,class,options,ns,is_prefix) 返回值 返回类 SimpleXMLElement 的一个对象,该对象的属性包含 ...
  • c++ string函数详细返回值及用法!

    万次阅读 2016-08-04 11:25:14
    通过在网站上的资料搜集,得到了很多关于string类用法的文档,通过对这些资料的整理和加入一些自己的代码,就得出了一份比较完整的关于string函数有哪些和怎样用的文档了! 下面先罗列出string类的函数有哪一些,...
  • JAVA之String函数的20个方法详解

    万次阅读 多人点赞 2018-01-16 20:44:49
    系统类 String() 简介 主要学习系统的常用方法 字符串是个常量 常量字符串 只要是对字符串进行操作 都是返回的是一个新的字符串(原字符串不能更改)= 练习 String str1 = "wanglong"; ...
  • C# 将XmlDocument转化为string函数

    万次阅读 2014-01-08 09:45:30
    #region 将XmlDocument转化为string /// /// 将XmlDocument转化为string /// /// /// public string ConvertXmlToString(XmlDocument xmlDoc) { MemorySt

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 147,004
精华内容 58,801
关键字:

string函数