C语言由浅到深学习笔记

女爷i 2023-01-06 05:28 137阅读 0赞

### 文章目录 ###

*  一 空指针和野指针
 *   *  空指针
     *  野指针
 *  二 指针的步长
 *  三 字符串的拷贝
 *  四 字符串反转
 *  五 字符串的格式化
 *  六 sscanf的用法
 *  七 查找子串
 *  八 位运算

# 一 空指针和野指针 #

## 空指针 ##

不容许向NULL和非法地址拷贝内存  
空指针可以释放

void test()
    {
        
    	char* p = NULL;
    	//给p指向的内存区域拷贝内容
    	strcpy(p, "1111");//错误
    	char* q = 0x1122;
    	//给q指向的内存区域拷贝内容
    	strcpy(q, "2222");//错误
    
        int* p = NULL;
    	free(p);//空指针是可以释放的
    	free(p);
    }

## 野指针 ##

1.未初始化的指针  
2.malloc之后free释放了，但是指针没有指向NULL  
3.指针操作超越变量的作用域  
野指针是不可以释放的

int *test()
    {
        
    	int a = 100;
    	int* p = &a;
    	return p;
    }
    //野指针
    void test02()
    {
        
    	int *p;//未初始化指针
        printf("%d\n",*p);
        
    	//2 malloc后也free了，但是指针没有置空
    	int* p = malloc(sizeof(int));
    	*p = 100;
    	free(p);//野指针
    	p = NULL;//将free后的指针要进行置空，防止野指针的出现
    	printf("%d\n", *p);
    
    	//3 指针操作超越变量，指针操作超越变量作用域
    	int* p2 = test();//p2就是野指针
    	printf("%d\n", *p2);
    
        int* p2 = malloc(4);
    	free(p2);
    	free(p2);//野指针是不可以释放的   
    }

# 二 指针的步长 #

1.指针变量+1之后，跳跃的字节数量

void test()
    {
        
    	char* p = NULL;
    	printf("%d\n", p);
    	printf("%d\n", p + 1);
    
    	double* p2 = NULL;
    	printf("%d\n", p2);
    	printf("%d\n", p2 + 1);
    }

2.解引用时候，取得字节数

void test()
    {
        
    	char buf[1024] = {
         0 };
    	int  a = 100;
    	memcpy(buf, &a, sizeof(int));
    	char* p = buf;//通过p找到buf的首地址
    	printf("buf中的a=%d\n", *(int*)(p + 1));
    }

3.自定义数据类型

struct Person
    {
        
    	char a;//0~3
    	int b;//4~7
    	char buf[64];//8~71
    };
    void test()
    {
        
    	struct Person p1 = {
         'a',10,"hello world",1000 };
    	//计算结构体中属性的偏移
    	printf("p1.d的偏移量为:%d\n", offsetof(struct Person, d));
    	//打印d 的值
    	printf("p1.d的值为：%d\n", *(int*)((char*)&p1 + offsetof(struct Person, d)));
    }

# 三 字符串的拷贝 #

1.利用\[\]

//参数1 目标字符串 参数2源字符串
    void copyString(char* dest, char* source)
    {
        
    	int len = strlen(source);
    	for (int i = 0; i < len; i++)
    	{
        
    		dest[i] = source[i];
    	}
    	dest[len] = '\0';
    }
    void test()
    {
        
    	char * str = (char*)"hello world";
    	char buf[1024];
    	copyString(buf, str);
    }

2.利用指针

void copyString(char* dest, char* source)
    {
        
    	while (*source!='\0')
    	{
        
    		*dest = *source;
    		dest++;
    		source++;
    	}
    	*dest = '\0';
    }
    void test()
    {
        
    	char * str = (char*)"hello world";
    	char buf[1024];
    	copyString(buf, str);
    }

3.利用偏移

void copyString(char* dest, char* source)
    {
        
    	while (*dest++=*source++){
        }
    }
    void test()
    {
        
    	char * str = (char*)"hello world";
    	char buf[1024];
    	copyString(buf, str);
    }

# 四 字符串反转 #

1，利用\[\]

void reverseString(char * str)
    {
        
    	int len = strlen(str);
    	int start = 0;
    	int end = len - 1;
    	while (start<end)
    	{
        
    		char temp = str[start];
    		str[start] = str[end];
    		str[end] = temp;
    		start++;
    		end--;
    	}
    }
    void test()
    {
        
    	char str[] = "abcdefg";
    	reverseString(str);
    	printf("%s\n", str);
    }

2.利用指针

void reverseString(char* str)
    {
        
    	int len = strlen(str);
    	char* start = str;
    	char* end = str + len - 1;
    	while (start < end)
    	{
        
    		char temp = *start;
    		*start = *end;
    		*end = temp;
    		start++;
    		end--;
    	}
    }
    void test()
    {
        
    	char str[] = "abcdefg";
    	reverseString(str);
    	printf("%s\n", str);
    }

# 五 字符串的格式化 #

void test()
    {
        
    	char buf[1024];
    	memset(buf, 0, 1024);
    	sprintf(buf, "我叫%s来自于%s今年%d岁\n", "XXX", "安庆师范大学",18);
    	printf("%s\n", buf);
    }

字符串拼接

void test()
    {
        
    	memset(buf, 0, 1024);
    	char str1[] = "hello";
    	char str2[] = "world";
    	int len = sprintf(buf, "%s%s", str1, str2);
    	printf("buf:%s len:%d\n", buf,len);
    }

数字转字符串

void test()
    {
        
    	memset(buf, 0, 1024);
    	int num = 100;
    	sprintf(buf, "%d", num);
    	printf("buf:%s\n", buf);
    }

# 六 sscanf的用法 #

1.%\*d或者%\*s 跳过数据

void test()
    {
        
    	char* str = "123456abcde";
    	char buf[1024] = {
         0 };
    	sscanf(str, "%*d%s", buf);//跳过数字
    	printf("%s\n", buf);
    }

![在这里插入图片描述][20210113232117453.png]  
2.%\[width\]s 读取指定宽度的数据

void test()
    {
        
    	char* str = "abcde123456";
    	char buf[1024] = {
         0 };
    	sscanf(str, "%6s", buf);
    	printf("%s\n", buf);
    }

![在这里插入图片描述][20210113232329628.png]  
3.%\[a-z\] 匹配a到z中任意字符

void test()
    {
        
    	char* str = "123456abcde";
    	char buf[1024] = {
         0 };
    	sscanf(str, "%*d%[a-c]", buf);
    	printf("%s\n", buf);
    }

![在这里插入图片描述][20210113232437567.png]  
4.%\[aBc\] 匹配a,B,c中一员，贪婪性

void test()
    {
        
    	char* str = "aabcde12345";
    	char buf[1024] = {
         0 };
    	sscanf(str, "%[abc]", buf);
    	printf("%s\n", buf);
    }

![在这里插入图片描述][20210113232607948.png]  
5、%\[^a\]匹配非a得任意字符，贪婪性

void test()
    {
        
    	char* str = "abcde12345";
    	char buf[1024] = {
         0 };
    	sscanf(str, "%[^c]", buf);
    	printf("%s\n", buf);
    }

![在这里插入图片描述][20210113232743166.png]  
6、%\[^a-z\]表示读取除a-z以外的所有字符

void test()
    {
        
    	char* str = "abcde12345";
    	char buf[1024] = {
         0 };
    	sscanf(str, "%[^0-9]", buf);
    	printf("%s\n", buf);
    }

![在这里插入图片描述][20210113232922322.png]

# 七 查找子串 #

int myStrstr(char* str, char* subStr)
    {
        
    	int num = 0;
    	while (*str!='\0')
    	{
        
    		if (*str != *subStr)
    		{
        
    			str++;
    			num++;
    			continue;
    		}
    		//创建临时指针
    		char * tmpStr = str;
    		char * tmpSubStr = subStr;
    		while (*tmpStr!='\0')
    		{
        
    			if (*tmpStr != *tmpSubStr)
    			{
        
    				//匹配失败
    				str++;
    				num++;
    				break;
    			}
    			tmpStr++;
    			tmpSubStr++;
    		}
    
    		if (*tmpSubStr == '\0')
    		{
        
    			//匹配成功
    			return num;
    		}
    	}
    	return -1;
    }
    void test()
    {
        
    	char* str = "abcdnfgdef";
    	int ret = myStrstr(str, "dnf");
    	if (ret == -1)
    	{
        
    		printf("未找到子串\n");
    	}
    	else
    	{
        
    		printf("找到了子串，位置为%d\n", ret);
    	}
    
    }

# 八 位运算 #

1.按位运算

> 010按位取反  
> 101源码  
> 101补码 110+1=111

void test()
    {
        
    	int num = 2;
    	printf("num=%d\n", ~num);//-3
    }

2.按位与&

> 10010100  
> 00000001  
> 00000000 --------全1为1 有0为0

void test()
    {
        
    	int num = 123;
    	if (num & 1 == 0)
    	{
        
    		printf("num为偶数\n");
    	}
    	else
    	{
        
    		printf("num为奇数\n");
    	}
    }

3.按位或|

> 0000 0101  
> 0000 0011  
> 0000 0111 ----全0 为0 有1为1

void test()
    {
        
    	int num1 = 5;
    	int num2 = 3;
    	printf("num1|num2=%d\n", num1 | num2); //7  
    }

4.交换两个数  
int num1 = 10;  
int num2 = 20;

1.利用临时变量
    int temp = num1;
    num1 = num2;
    num2 = temp;

2.利用按位异或实现两个数的交换
    num1=num1^num2;
    num2=num1^num2;
    num1=num1^num2;

3.不利用临时变量实现两个变量文件
    num1 = num1 + num2;
    num2 = num1 - num2;
    num1 = num1 - num2;

[20210113232117453.png]: /images/20221119/b6fd91c3c6c14fe39fbb54115b29d828.png
[20210113232329628.png]: /images/20221119/c4057d739c894873ba7fb04d4a53b8f2.png
[20210113232437567.png]: /images/20221119/e5ee1c75cf1b4c6ca0abe8633848aee1.png
[20210113232607948.png]: /images/20221119/3e3bac010db54769aca0edfe8d3bd933.png
[20210113232743166.png]: /images/20221119/5e3894bd78c44753b180dc9f446d5185.png
[20210113232922322.png]: https://img-blog.csdnimg.cn/20210113232922322.png