C语言字符串

时间：2025-03-08 08:40:18

文章目录

        • 字符串：
          • 1、c语言中表示一个字符串：
            • 字符串的输入和输入：
            • 如何用scanf输入带空格的字符串？
          • 2、char型指针和char型数组的区别
          • 3、字符串长度获取strlen
          • 4、字符串拷贝strcpy
          • 5、字符串拼接strcat
            • 注意：要求前面字符串申请的地址空间足够长，必须容纳两个字符串，否则会越界
          • 6、字符串的比较strcmp
            • 字符串比较是要区分大小写
            • strncmp比较的是前n个字符相不相同，而不是第n个字符相不相同
          • 7、strstr判断字符串时候有某个字符串
          • 8、strtok 分割字符串 同sscanf
          • 9、strchr 查找字符串中第一个出现的指定字符
          • 10、atoi将所有为数字字符的字符串转成整数
          • 11、字符串的传参和返回
          • 12、字符串的输入和输出
          • 13、assert() 宏用法

字符串：
1、c语言中表示一个字符串：
常量“hello world”
char型数组：char ch1[] = "hello world";
char型指针：char *ch2 = "hello world";
字符串的输入和输入：
char str[50];
scanf("%s", str);   //gets(str);//使用的时候不安全，不会停止接收
printf("%s\n", str);  //puts(str);
如何用scanf输入带空格的字符串？
gets();
2、char型指针和char型数组的区别

char型数组和char型指针在表示字符串的区别：

	char ch1[] = "hello world";	//char型数组
	char *ch2 = "hello world";	//char型指针，字符指针常		量
	printf("ch1 = %s\n", ch1);
	printf("ch2 = %s\n", ch2);

	ch1[2] = 'b';
	ch2[2] = 'b';  //不可以更改
	
	printf("ch1 = %s\n", ch1);
	printf("ch2 = %s\n", ch2);
3、字符串长度获取strlen

strlen（表示字符串包含多少个有效字符，不包括字符串结束符’\0’）

#include <>//函数需要包含的头文件

size_t strlen(const char *s);//函数功能，获取有效字符长度
函数参数：
const char *s：传入的字符串
返回值：
size_t：有效字符长度

注意：strlen函数会从字符串的第0个字节开始计算，知道遇到第一个字符串结束符‘\0’，就统计结束，sizeof，计算的是一个变量或者数据，实际在内存中所占用的空间大小（不考虑变量的值，空字符在内存中也是需要占用一个字节位置的）

	char str[20] = "hello world";
	int sizelen = strlen(str);
	printf("sizelen = %d\n", sizelen);
4、字符串拷贝strcpy
#include <>//函数需要包含的头文件

char *strcpy(char *dest, const char *src); //函数功能，拷贝字符串
char *strncpy(char *dest, const char *src, size_t n);
参数列表：
char *dest：拷贝位置
const char *src：拷贝的字符串
size_t n：拷贝的字符串的长度
返回值：
char *：拷贝之后的字符串的地址

strcpy函数会把第二个字符串的结束符一起拷贝，但是使用的时候必须要保证前面的字符串申请的地址空间要足够大

	char str[20];
	strcpy(str, "hello world");
	
	char str1[20];
	strncpy(str1, str, 5);

	printf("str = %s\n", str);
	printf("str1 = %s\n", str1);
5、字符串拼接strcat
#include <>

char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t n);
参数列表：
char *dest：拼接字符串的前一个
const char *src：拼接字符串的前一个
size_t n：拼接长度
注意：要求前面字符串申请的地址空间足够长，必须容纳两个字符串，否则会越界
6、字符串的比较strcmp
#include <>

int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
参数列表：
const char *s1：比较的第一个字符串
const char *s2：比较的第二个字符串
size_t n：比较字符的长度
返回值：
int：如果两个字符串相同，那么返回值为0，如果两个字符串不同，要么为正数，要么为负数，正数和负数就是这两个字符之间相差的值
字符串比较是要区分大小写
strncmp比较的是前n个字符相不相同，而不是第n个字符相不相同
7、strstr判断字符串时候有某个字符串
#include <>

char *strstr(const char *haystack, const char *needle);

const char *haystack：父字符串
const char *needle：子字符串
返回值：
如果包含，则返回找到的字符串的地址，如果不包含，则返回NULL

strstr(s1, s2);判断s1字符串里面是不是包含s2字符串

如果包含，则返回扎到的字符串的地址，第一次s2在s1中出现的位置，如果不包含，则返回NULL

8、strtok 分割字符串 同sscanf
	#include <>
	char *strtok(char *str, const char *delim)
	char str[20] = "hello world nihao";	
	char *p1 = strtok(str, " ");
	char *p2 = strtok(NULL, " ");
	char *p3 = strtok(NULL, " ");

	printf("p1 = %s\n", p1);
	printf("p2 = %s\n", p2);
	printf("p3 = %s\n", p3
9、strchr 查找字符串中第一个出现的指定字符
#include <>

char *strchr(const char *s, int c);//从左往右找第一个出现的字符，返回地址
char *strrchr(const char *s, int c); //从右往左找第一个出现的字符，返回地址

	char str[20] = "hello world";
	printf("%s\n", strchr(str, 'l'));
	printf("%s\n", strrchr(str, 'l'));
10、atoi将所有为数字字符的字符串转成整数
#include <>

int atoi(const char *nptr);//转换成int
long atol(const char *nptr); //转换成long
long long atoll(const char *nptr); //转换成long long
11、字符串的传参和返回

字符串的传参实际上传递的是首字符的地址

字符串作为函数的返回，还是返回首字符的地址

char *func(char *str)
{
	return str;
}

char *func1()
{
	char *str = malloc(20);
	return str;
}

int main(int argc, char const *argv[])
{
	char str[20] = "hello world";
	// str = "hello world";//不可以

	char *str2 = malloc(20);
	char *str4 = malloc(20);
	char *str3;
	str2 = "hello world";//可以,将hello world的首地址赋值
	str3 = "hello world";//可以,将hello world的首地址赋值
	//这种赋值，将str2指针指向了常量区"hello world"，变成了字符常量指针
	// str2[3] = 'z';//不可以更改
	// str3[3] = 'z';//不可以更改
	strcpy(str4, "hello world");
	str4[3] = 'z';

	printf("str2 = %s\n", str2);
	printf("str3 = %s\n", str3);
	printf("str4 = %s\n", str4);


	char *str5 = func(str);
	char *str6 = func(str4);
	char *str7 = func("hello world");

	printf("str5 = %s\n", str5);
	printf("str6 = %s\n", str6);
	printf("str7 = %s\n", str7);


	char *q = func("hello");
	char *p = func1();
	strcpy(p, "nihao");
	printf("q = %s\n", q);
	printf("p = %s\n", p);
	// free(q);
	free(p);

	return 0;
}
12、字符串的输入和输出

输入：scanf() gets()

区别：

scanf：scanf遇到空格和换行符都会作为最后一个变量获取完毕

gets()：gets遇到空格不会结束，遇到换行符结束，gets专门用来获取输入字符串，但是gets是不安全的

char str[10];
scanf("%[^\n]", str);

输出：printf() puts()

区别：

printf：格式化输出，各种类型都可以，不会默认换行

puts()：只能输出字符串，会默认换行

13、assert() 宏用法

注意：assert是宏，而不是函数。在C的[]头文件中。assert宏的原型定义在<>中，其作用是如果它的条件返回错误，则终止程序执行，原型定义：

#include <>
void assert( int expression );

assert的作用是先计算表达式[expression]，如果其值为假（即为0），那么它先向标准错误流[stderr]打印一条出错信息，然后通过调用[abort]来终止程序运行；否则，assert()无任何作用。宏assert（）一般用于确认程序的正常操作，其中表达式构造无错时才为真值。完成调试后，不必从源代码中删除assert()语句，因为宏NDEBUG有定义时，宏assert()的定义为空。

#include <>
#include <>
#include <>
unsigned long myStrLen(char *s)
{
	assert(s);
	unsigned long cnt=0;
	while(*s!='\0')
	{
		cnt++;
		s++;
	}
	return cnt;
}

char * myStrCopy(char *dest,const char* source)
{
	assert(source);
	assert(dest);
	while(*source!='\0')
	{
		*dest++=*source++;
	}
	*dest = '\0';
	return dest;
}

char * myStrNCopy(char *dest,const char *source,int n)
{
	assert(dest);
	assert(source);
	while(n)
	{
		*dest++=*source++;
		n--;
	}
	*dest = '\0';
	return dest;
}

int myStrCompare(const char *dest,const char * source)
{
	assert(dest);
	assert(source);

	while(*dest!='\0'||*source!='\0')
	{
		if(*dest!=*source)
			return *dest-*source;
		dest++;
		source++;
	}
	return 0;
}
int myStrNCompare(const char *dest,const char *src,int n)
{
	assert(dest);
	assert(src);
	
	while(n&&*dest!='\0'&&*src!='\0')
	{
		if(*dest!=*src)
			return *dest-*src;
		n--;
		src++;
		dest++;
	}
	return 0;
}

 char *myStrCat(char *dest, const char *src)
 {
 	assert(dest);
 	assert(src);
 	while(*dest!='\0')
 		dest++;
 	while(*src!='\0')
 		*dest++ = *src++;

 	*dest = '\0';
 	return dest;
 }


 char *myStrNCat(char *dest,const char *src,int n)
 {
 	assert(dest);
 	assert(src);
 	while(*dest!='\0')
 		dest++;
 	while(n)
 	{
 		*dest++=*src++;
 		n--;
 	}
 	*dest='\0';
 	return dest;
 }
char *myStrStr(char *haystack,char *needle)
{

   for(;;++haystack)
   {
		char* h = haystack;  

		for(char* n = needle;;++n,++h)
		{
			if(*n=='\0')
				return haystack;
			if(*h !=*n)
				break;   
		}
		if(*h=='\0')
			return NULL;   
	}   
}



int main(int argc, char const *argv[])
{
	char s[]="hello world";
	char sc[100]="hello world";
	// char s2[] = "hello world";
	// // char *s1 = (char *)malloc(myStrLen(s)+1);
	// // myStrCopy(s1,s);
	// // printf("s = %ld\ns1 = %ld\n",strlen(s),myStrLen(s1));
	// // printf("%ld\n",myStrLen(s));
	// // myStrNCopy(s1,s,5);
	// // printf("%s\n",s1);
	// // free(s1);

	// printf("%d\n",myStrCompare(s,s2));	

	
	// myStrCat(sc,s);
	// printf("%s\n",sc);
	int ret = myStrCompare(s,sc);
	printf("%d\n",ret);



	return 0;
}


 *s1 = (char *)malloc(myStrLen(s)+1);
	// // myStrCopy(s1,s);
	// // printf("s = %ld\ns1 = %ld\n",strlen(s),myStrLen(s1));
	// // printf("%ld\n",myStrLen(s));
	// // myStrNCopy(s1,s,5);
	// // printf("%s\n",s1);
	// // free(s1);

	// printf("%d\n",myStrCompare(s,s2));	

	// myStrCat(sc,s);
	// printf("%s\n",sc);
	int ret = myStrCompare(s,sc);
	printf("%d\n",ret);

	return 0;
	}

相关文章