21-字符串操作

单字符输入输出

putchar

• int putchar(int c);
• 向标准输出写一个字符
• 返回写了几个字符，EOF（-1）表示写失败

getchar

• int getchar(void);
• 从标准输入读入一个字符
• 返回类型是int是为了返回EOF(-1)
• Windows —>Ctrl-Z 结束
• Unix —>Ctrl-D 结束

例子：

#include <stdio.h>

int main(int argc, char const *argv[])
{
	int ch;
	while ( ( ch = getchar() ) != EOF ) {
		putchar( ch) ;
	}
	printf ( "EOF\n" ) ;
	return 0;
}

这里有一些获取的过程看翁恺老师视频加以理解：MOOC

字符串数组

-char **a; —a是一个指针，指向另外一个指针，那个指针指向一个字符串，这不是字符串数组

• char [][] , 这是一个二维数组，但是二维数组的第二维一定有确切的值，否则无法编译
  eg: char a [][10] = {“hello”,“world”, }
  每个单元的长度固定为10，有一定的局限性
• char *a []; 字符串数组
  a [0]指向一个字符串，a[1]指向另一个字符串…

程序参数

• int main(int argc , char const *argv[]);
• argv[0]是命令本身
• 当使用Unix的符号连接时，反映符号连接的名字

字符串函数的实现

strlen

• 函数原型:int size_t strlen(const char *s);
• 返回:s的字符串长度
• 实现：

size_t mylen(const char* s)
{
	int idx = 0;
	while (s [idx] != '10') {
		idx++;
	}
	return idx;
}

strcmp

• 函数原型:int strcmp(const char *s1 , const char *s2);
• 比较函数两个字符串.返回:
  0: s1 == s2
  1: s1 > s2
  -1: s1 < s2
• 用数组实现：

int mycmp ( const char* s1,const char* s2)
{
	int idx = 0;
	while ( s1[idx] == s2 [idx] && s1[idx] !=‘\0’) {
		idx ++;
	}
	return s1 [idx] - s2 [idx];
}

• 用指针实现：

int mycmp ( const charx s1,const char* s2)
{
	while ( *s1 ==*s2 &&*s1 !='10') {
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

strcpy

• 函数原型:char *strcpy(char *restrict dst , const char *restrict src);
• 把src的字符串拷贝到dst
• restrist表明src和dst不重叠
• 返回:指针dst,让代码连起来
• 复制一个字符串：

char *dst = (char*)mallco(strlen(src)+1);
strcpy(dst,src);

• 实现：

char* mycpy(char* dst,const char* src)
{
	char* ret = dst;
	while (*src != ‘\0’) {
		*dst =*src;
		dst++;
		src++;
	}
	*dst = '\0';
	return rest;
}

strcat

• 函数原型:char *strcat (char *restrict s1 , const char *restrict s2);
• 把s2拷贝到s1后面,接成一个长的字符串
• 返回:指针s1, (注:s1必须具有足够的空间)
• 实现：

char *mycat(char *a,const char*b)
{
	char *str=(char*)malloc(strlen(a)+strlen(b)+1;
	
	strcpy(str,a);
	
	char*s=str+strlen(a);
	
	strcpy(s,b);
	
	return str;
}

strchr

• 函数原型:char *strchr(const *s , int c);
• (从左边)寻找c在字符串中第一次出现的位置
• 返回:指针,指向那个位置
• 寻找第二次出现的位置（二次定位）

#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[])
{
	char s[] = "hello";
	char *p = strchr(s,. 'l');
	p = strchr( p+1,'l');
	printf( "%sln", p);

	return 0;
}

• 把‘hello’,中的‘llo’拷贝到t中：先定位，后拷贝

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
char s[] = "hello";
char *p = strchr( s, 'l');       //定位
char *t = ( charx)malloc( strlen(p)+1);  //动态分配内存
strcpy(t, p);                   //拷贝
printf ( "%s \n", t);
free(t);        //记得在最后释放内存

return 0;
}

输出为llo

• 把‘hello’中的‘he’拷贝到t中：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char const *argv [])
{
	char s[] = "hello";
	char *p = strchr(s, 'l' );        //定位l的位置
	char c =*p;                      //将l赋给c
	*p = '\0' ;          //把p所指地址的值改为0，也就是字符串数组此时在e后面就有了标志结束的0，该数组现在表示的字符串就是‘he’
	char *t = ( char*)malloc(strlen( s)+1);    //动态分配内存
	strcpy(t, s);     //将'he'拷贝到t中
	printf("%s\n", t);
	free(t);         //释放内存
	
	return 0;
}

字符串中找字符串

• char * strstr(const char *s1, const char *s2);.
  在字符串中寻找字符串
• char * strcasestr(const char *s1, const char *s2);
  在寻找过程中忽略大小写