阅读背景：

字符串的一些基本操作，复制，长度，子串查找，单词反转，比较，字符串反转，删除指定字符。

来源：互联网  
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


')   //遍历一遍
	{
		if(*src==' ' || *src=='
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '
 
 
 
 
 
 
 
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <assert.h>
#include <algorithm>

using namespace std;
#define maxn 10005

//实现strSrc到strDest的复制
char *strCpy(char * strDest , char * strSrc)
{
	if(strSrc==NULL||strDest==NULL)return NULL; 

	while((*strDest++ = *strSrc++)!='\0'); 
	//将strSrc字符串的内容复制到strDest中...

	return strDest ;
}

//得到str的长度
int getStrLen1(const char *str)
{
	assert(NULL != str);
	int len  = 0 ; 
	while(*str++ != '\0')
	{
		len++;
	}
	return len; 
}

int getStrlen2(const char* str)
{
	assert(NULL != str);
	const char* temp = str ;   //保存str的首地址
	while(*str++!='\0');
	return (str-temp-1) ;  //返回尾部指针与首部指针的差就是长度
}

//从字符串src里面查找sub
const char* strStr(const char* src,const char* sub)
{
	if(src==NULL||sub==NULL) return NULL;
	const char* bp;
	const char* sp;
	while(*src)   //遍历src字符串
	{
		bp = src ;
		sp = sub ;
		do 
		{                                   //遍历sub数组
			if(!*sp)                        //如果到了sub的结束位置
				return src ;                //表示找到了sub字符串，退出
		} while (*bp++ == *sp++);
		src += 1 ;
	}
	return NULL ; 
}

//编程实现字符串中各单词的翻转
void recStr(char *str)
{
	char *start = str , *end = str , *src = str ; 
	while(*src++ != '\0') ;
	end = src - 2 ;    //找到字符串的末尾 
	
	while(start < end)
	{
		swap(*start++,*end--) ; //逆置整个字符串
	}
	
	start = str , end = src-2 ;  
	src = str ; 
	while(*src++ != '\0')   //遍历一遍
	{
		if(*src==' ' || *src=='\0')   //找到一个单词
		{
			end = src-1 ;  //end指向单词末尾
			while(start < end)swap(*start++,*end--); //逆置单词

			start = end = src + 1 ;  //指向下一个单词开头
		}
	}
}

//编程实现strcmp两个字符串的比较,返回1，0或者-1
int strCmp(const char* src,const char* dst)
{
	int ans = 0 ; 
	while(!(ans = *(unsigned char *)src - *(unsigned char*)dst) && *dst)
	{   //循环比较两个字符串是否相等，不想等或者到了dst的末尾就退出
		++src;
		++dst;
	}
	if(ans>1)ans = 1 ;
	if(ans<-1)ans = -1 ;
	return ans ; 
}

//字符串反转函数，下标操作
char *strrev1(const char* str)
{
	int len = strlen(str);
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;

	for(int i = 0 ; i < len/2 ; i++)
	{
		char c = temp[i] ; 
		temp[i] = temp[len-i-1] ; 
		temp[len-i-1] = c ; 

	}
	return temp ; 
}

//字符串反转函数,指针操作
char *strrev2(const char* str)
{
	int len = strlen(str) ;
	char *temp = new char[len+1] ;

	strcpy(temp,str) ;
	char *ans = temp ; 
	char *p = temp + len - 1 ;   //指向str的末尾

	while(temp<p)
	{
		char c = *temp ; 
		*temp = *p ; 
		*p = c ;
		--p ; 
		++temp ; 
	}
	return ans;
}

//实现删除字符串中所有指定的字符
char *delChar(char *str,char c)
{
	if(str==NULL)return NULL ;
	char *temp = str ; 
	char *head = str ; 

	while(*temp++)
	{
		if(*temp != c) 
		{
			*head++ = *temp ; 
		}
	}
	*head = '\0' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/
 
  
  
 
 


' ; 

	return head;
}


//测试用例
int main()
{
	char strSrc[maxn] ;
	char strDest[maxn] ;

	//cout<<delChar("1234554321",'1')<<endl;

	cout<<strrev1("12345")<<endl;
	cout<<strrev2("12345liuyan")<<endl;

	cout<<strCmp("12345","123456")<<endl ;
	cout<<strCmp("12345","12345")<<endl ;
	cout<<strCmp("123456","12345")<<endl ;

	int len = 0 ; 
	cout<<strStr("12345","34")<<endl;

	cin.getline(strSrc,maxn);
	recStr(strSrc) ; 
	cout<<strSrc<<endl;

	cin.getline(strSrc,maxn);
	strCpy(strDest,strSrc);
	len = getStrLen1(strDest);
	cout<<strDest<<" 的长度为： "<<len<<endl;
	return 0; 
}

//getline的用法
/************************************************************************/
/* 
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

char line[100];
cin.getline(line,100);
//注意这儿的getline是要读入空白符。但是不包括最后的换行符。
*/

/*
istream& getline ( istream& is, string& str, char delim );
istream& getline ( istream& is, string& str );

string line;
getline(cin,line);
//此处也是不读入换行符的。
*/
/************************************************************************/#include <iostream>
#include <cstdio>



        
        
        

        

        

            
你的当前访问异常,请进行认证后继续阅读剩余内容。

            

            
            

            
            

            
        

        

        
        

                    

                        

                            

                                

                                
分享到：

                                

                                    
                                

                                

                                    
                                

                                

                                    
                                

                                

                                    
                                

                            

                        

                        
                    

                

            

        

        
    









    
    
    
    





    

        

            

                

                    
你可能喜欢:

                    
                

            


            

                

                    
相关阅读:

                    
                

            

            

                

                    
随便看看: