字符串操作

电玩女神 2022-08-02 06:02 233阅读 0赞

字符串反转

#include "stdafx.h"
    #include<iostream>
    using namespace std;
    char*reverse_str(char*str);
    int _tmain(int argc, _TCHAR* argv[])
    {
    	char*str = "abcdefgh";
    	char*dst = reverse_str(str);
    	cout << dst << endl;
    	system("pause");
    	return 0;
    }
    
    char*reverse_str(char*str)
    {
    	char*dst=new char[strlen(str)+1];
    	*dst = '\0';
    	
    	while (*str != '\0')
    	{
    		*(--dst) = *(str++);
    		cout << *dst << endl;
    	}
    	return dst;
    }

atoi

// my_atoi.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include<iostream>
    using namespace std;
    int my_atoi(char*in);
    int _tmain(int argc, _TCHAR* argv[])
    {
    	char*in = "0123h4dfdd";
    	cout << atoi(in) <<endl;
    	cout << my_atoi(in) << endl;
    	system("pause");
    	return 0;
    }
    
    int my_atoi(char*in)
    {
    	int kk = 0;
    	int sum = 0;
    	while (*in <= '9'&&*in >= '0')
    	{
    		int kk=*in-'0';
    		sum = sum*10+kk;
    		++in;
    	}
    	return sum;
    }

itoa

// my_itoa.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include<iostream>
    using namespace std;
    
    char*my_itoa(int value, char *string, int radix)
    {
    	int k = 0;
    	int m;
    	int a = value;
    	while (a > 0)
    	{
    		k++;
    		a = a / radix;
    	}
    	string[k] = '\0';
    	while (k > 0)
    	{
    		m = value%radix;
    		string[k - 1] = m + '0';
    		value = value / radix;
    		--k;
    	}
    	return string;
    }
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	char*str=new char[10000];
    	cout << my_itoa(132, str, 2) << endl;
    	system("pause");
    	return 0;
    }

编写一个程序实现功能：将两个字符串合并为一个字符串并且输出，用指针实现。

</pre><pre name="code" class="cpp">#include "stdafx.h"
    #include<iostream>
    using namespace std;
    char*my_strcat(char*src, char*dst)
    {
    	char*p = dst;
    	while (*p != '\0')
    		p++;
    	while (*src != '\0')
    	{
    		*p = *src;
    		p++;
    		src++;
    
    	}
    	*p = '\0';
    
    	return dst;
    
    }
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	char*src = new char[100];
    	strcpy(src, "RST");
    	char*dst = new char[100];
    	strcpy(dst, "ggggg");
    
    	cout << my_strcat(src, dst);
    	system("pause");
    	return 0;
    }

子字符串的替换（C语言）   
描述：编写一个字符串替换函数，如函数名为 StrReplace(char\* strSrc, char\* strFind, char\* strReplace)，strSrc为原字符串，strFind是待替换的字符串，strReplace为替换字符串。   
举个直观的例子吧，如：“ABCDEFGHIJKLMNOPQRSTUVWXYZ”这个字符串，把其中的“RST”替换为“gggg”这个字符串，结果就变成了： ABCDEFGHIJKLMNOPQggggUVWXYZ

// StrReplace.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include<iostream>
    using namespace std;
    
    
    char*StrReplace(char* strSrc, char* strFind, char* strReplace)
    {
    	char*p1 = strSrc;
    	char*p2 = strFind;
    	char*p=NULL;
    	bool flag = false;
    	while (*p1 != '\0')
    	{
    		if (*p1 == *p2)
    		{
    			p = p1;
    			while (*p1 == *p2&&*p1 != '\0')
    			{
    				p1++;
    				p2++;
    				if (*p2 == '\0')
    				{
    					flag = true;
    					break;
    				}
    			}
    		}
    		else
    			p1++;
    		if (flag)
    			break;
    
    		}
    	if (flag)
    	{
    		char*p3=new char[100];
    		//char*p4 = p3;
    		char*p5 = p1;
    		//while (*p1 != '\0')
    		//	*(p3++) = *(p1++);
    		strcpy(p3, p1);
    		//*p3 = '\0';
    		
    		while (*strReplace != '\0')
    		{
    			*p = *strReplace;
    			p++;
    			strReplace++;
    		}
    		while (*p3 != '\0')
    		{
    			*(p) = *(p3);
    			++p;
    			++p3;
    		}
    		*p = '\0';
    	}
    	return strSrc;
    
    }
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	char*src = new char[100];
    	strcpy(src, "ABCDEFGHIJKLMNOPQRSTpVWXYZ");
    	//src = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";不能直接传const char*类型的值，否则在程序中无法改变值
    	char*find = new char[100];
    	//char*find = "RST";
    	strcpy(find, "RST");
    	char*replace = new char[100];
    	strcpy(replace, "ggggg");
    	//char*replace = "ggggggggg";
    	cout << StrReplace(src, find, replace) << endl;
    	system("pause");
    	return 0;
    }

字符串分割

int split(const std::string& str, std::vector<std::string>& ret_, std::string sep = ",")  
    {  
        if (str.empty())  
        {  
            return 0;  
        }  
      
        std::string tmp;  
        std::string::size_type pos_begin = str.find_first_not_of(sep);  
        std::string::size_type comma_pos = 0;  
      
        while (pos_begin != std::string::npos)  
        {  
            comma_pos = str.find(sep, pos_begin);  
            if (comma_pos != std::string::npos)  
            {  
                tmp = str.substr(pos_begin, comma_pos - pos_begin);  
                pos_begin = comma_pos + sep.length();  
            }  
            else  
            {  
                tmp = str.substr(pos_begin);  
                pos_begin = comma_pos;  
            }  
      
            if (!tmp.empty())  
            {  
                ret_.push_back(tmp);  
                tmp.clear();  
            }  
        }  
        return 0;  
    }

sprintf

字符串格式化命令，主要功能是把格式化的数据写入某个字符串中

\#include<stdio.h>/\*某个stdio.h\*/  
   
int　main()/\*主函数“整数”类型\*/  
\{  
　char　buffer\[50\];/\*“字符”类型的数组，下面共有50个元素。\*/  
　int　n,a=5,b=3;/\*三个变量都为“整数”类型,int中间要有空格\*/  
n=sprintf(buffer,"%d plus %d is %d",a,b,a+b);/\*赋予数值\*/  
printf("\[%s\]is a string %d chars long\\n",buffer,n);/\*“格式输出函数”\*/  
return　0;/\*“返回零”  
也就是程序正常退出\*/  
\}  
输出结果：  
5 plus 3 is 8

下面这个函数处理文本很有用

fscanf

\#include <stdio.h>  
FILE \*stream;  
int main(void)  
\{  
    long l;  
    float fp;  
    char s\[81\];  
    char c;  
    stream = fopen("fscanf.out", "w+");  
    if(stream==NULL)  
    printf("The file fscanf.out was not opened\\n");  
    else  
    \{  
        fprintf(stream,"%s%ld%f%c","a-string", 65000,3.14159, 'x');  
        /\*将指针设置至文件开头\*/  
        fseek(stream,0L,SEEK\_SET);  
        /\*从文件中读取数据\*/  
        fscanf(stream,"%s",s);  
        fscanf(stream,"%ld",&l);  
        fscanf(stream,"%f",&fp);  
        fscanf(stream,"%c",&c);  
       /\*输出读取的数据\*/  
        printf("%s\\n",s);  
        printf("%ld\\n",l);  
        printf("%f\\n",fp);  
        printf("%c\\n",c);  
        fclose(stream);  
    \}  
    return 0;  
\}

1.使用sizeof获取字符串长度

sizeof的含义很明确，它用以获取字符数组的字节数（当然包括结束符\\0）。对于ANSI字符串和UNICODE字符串，形式如下：  
sizeof(cs)/sizeof(char)    
sizeof(ws)/sizeof(wchar\_t)   
可以采用类似的方式，获取到其字符的数目。如果遇到MBCS，如"中文ABC"，很显然，这种办法就无法奏效了，因为sizeof()并不知道哪个char是半个字符。  
2.使用strlen()获取字符串长度  
strlen()及wcslen()是标准C++定义的函数，它们分别获取ASCII字符串及宽字符串的长度，如：  
size\_t strlen( const char \*string );    
size\_t wcslen( const wchar\_t \*string );   
strlen()与wcslen()采取\\0作为字符串的结束符，并返回不包括\\0在内的字符数目。  
3.使用CString::GetLength()获取字符串长度  
CStringT继承于CSimpleStringT类，该类具有函数：  
int GetLength( ) const throw( );   
GetLength()返回字符而非字节的数目。比如：CStringW中，"中文ABC"的GetLength()会返回5，而非10。那么对于MBCS呢？同样，它也只能将一个字节当做一个字符，CStringA表示的"中文ABC"的GetLength()则会返回7。  
4.使用std::string::size()获取字符串长度  
basic\_string同样具有获取大小的函数：  
size\_type length( ) const;    
size\_type size( ) const;   
length()和size()的功能完全一样，它们仅仅返回字符而非字节的个数。如果遇到MCBS，它的表现和CStringA::GetLength()一样。  
5.使用\_bstr\_t::length()获取字符串长度  
\_bstr\_t类的length()方法也许是获取字符数目的最佳方案，严格意义来讲，\_bstr\_t还称不上一个完善的字符串类，它主要提供了对BSTR类型的封装，基本上没几个字符串操作的函数。不过，\_bstr\_t 提供了length()函数：  
unsigned int length ( ) const throw( );    
该函数返回字符的数目。值得称道的是，对于MBCS字符串，它会返回真正的字符数目。  
现在动手  
编写如下程序，体验获取字符串长度的各种方法。  
【程序 4-8】各种获取字符串长度的方法  
01  \#include "stdafx.h"   
02  \#include "string"   
03  \#include "comutil.h"   
04  \#pragma comment( lib, "comsuppw.lib" )    
05      
06  using namespace std;    
07      
08  int main()    
09  \{    
10      char s1\[\] = "中文ABC";    
11      wchar\_t s2\[\] = L"中文ABC";    
12      
13      //使用sizeof获取字符串长度    
14      printf("sizeof s1: %d\\r\\n", sizeof(s1));    
15      printf("sizeof s2: %d\\r\\n", sizeof(s2));    
16      
17      //使用strlen获取字符串长度    
18      printf("strlen(s1): %d\\r\\n", strlen(s1));    
19      printf("wcslen(s2): %d\\r\\n", wcslen(s2));    
20      
21      //使用CString::GetLength()获取字符串长度    
22      CStringA sa = s1;    
23      CStringW sw = s2;    
24      
25      printf("sa.GetLength(): %d\\r\\n", sa.GetLength());    
26      printf("sw.GetLength(): %d\\r\\n", sw.GetLength());    
27      
28      //使用string::size()获取字符串长度    
29      string ss1 = s1;    
30      wstring ss2 = s2;    
31      
32      printf("ss1.size(): %d\\r\\n", ss1.size());    
33      printf("ss2.size(): %d\\r\\n", ss2.size());    
34      
35      //使用\_bstr\_t::length()获取字符串长度    
36      \_bstr\_t bs1(s1);    
37      \_bstr\_t bs2(s2);    
38      
39      printf("bs1.length(): %d\\r\\n", bs1.length());    
40      printf("bs2.length(): %d\\r\\n", bs2.length());    
41      
42      return 0;  
43 \}   
输出结果:  
sizeof   s1:  8  
sizeof   s2:  12  
strlen(s1):  7  
wcslen(s2):  5  
sa.GetLength():  7  
sw.GetLength():  5  
ss1.size():  7  
ss2.size():  5  
bs1.length():  5

bs2.length():  5