1野指针强化：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 野指针产生的原因
//指针变量和它指向的内存空间变量是两个不同的概念
//释放了指针所指向的内存空间，但是指针变量本省没有重置为NULL
//造成释放的时候，通过if(p1 != NUll)
//避免方法：
// 1)定义指针的时候，初始化成NULL
// 2）释放指针所指向的内存空间，把指针重置成NULL
int main()
{
char *p1 = NULL;
p1 = (char *)malloc(100);
if (p1 == NULL)
{
printf("没有分配到堆空间 \n");
return 0;
}
strcpy(p1, "1234567890");
printf("%s \n", p1);
if (p1 != NULL)
{
free(p1);
//p1 = NULL;//如果没有这个步骤，下面的再次释放就导致程序出错(VS2013)
}
if (p1 != NULL)
{
free(p1);
}
}
NULL 地址写入数据
不可预料的地址写入数据
不断改变指针的指向：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char buf[20] = { ‘a‘, ‘1‘, ‘b‘, ‘2‘, ‘c‘, ‘3‘, ‘d‘, ‘4‘, ‘e‘, ‘5‘ };
char *p1 = NULL;
char *p2 = NULL;
p1 = &buf[0];
p1 = &buf[1];
p1 = &buf[2];
int i = 0;
for (i = 0; i < 10; i++)
{
p1 = &buf[i];
printf("%c ", *p1);
}
p2 = (char *)malloc(20);
strcpy(p2,"1234567890");
for (i = 0; i < 10; i++)//不断的修改指针的值，相当于不断改变指针的指向
{
p1 = p2+i;//注意p2的步长是char
printf("%c ",*p1);
}
free(p2);
system("pause");
}
编译运行：
C:\Users\chunli>gcc main.c & a
a 1 b 2 c 3 d 4 e 5 1 2 3 4 5 6 7 8 9 0 请按任意键继续. . .
字面量：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
//结论：字面量不能取地址，没有放在栈区，也没有放在堆区，因为没法取其地址
//我觉得放在代码区
int i = 0; //字面量 0 0不能取地址
for (i = 0; i < 10; i++) //字面量 10 10不能取地址
{
printf("Hello World! \n");
}
}
便于运行：
C:\Users\chunli>gcc main.c & a
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
从0级指针到1级指针：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int fun1()
{
int a = 20;
return a;
}
int fun2(int a)
{
a = 30;
}
int fun3(int *a)
{
*a = 40;
}
int main()
{
int a = 10;
int *p = NULL;
p = &a;
printf("%d \n",*p);
fun1();
printf("%d \n", *p);
fun2(a); //只是把a的数值传过来，用来初始化函数的值，除此之外，函数内与a没有任何关系了
printf("%d \n", *p);
fun3(&a); //只有把a的地址传过来，才能对a进行修改
printf("%d \n", *p);
system("pause");
}
/*
编译运行：
10
10
10
40
请按任意键继续. . .
*/
从1级指针到2级指针：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void fun1(char **p2) //只有这种方法才能修改一级指针的数值
{
*p2 = 0xff; //间接修改一级指针的值，而不是修改一级指针指向的内存块
}
void fun2(char *p2) //这种方法永远也不可能修改传过来的一级指针的数值
{
//char *p2 就相当于是在这里定义了一个p2指针变量，和外界的一级指针没有任何关系
p2 = 0xf;
}
int main()
{
char *p1 = NULL;
char *p2 = NULL;
//直接修改p1的值
p1 = 0x22;
p2 = 0x55;
//间接是修改p1的值
p2 = &p1; //把p1的地址装入p2
*p2 = 100; //把变量p1的值修改为100
printf("%d \n",p1); //把p1的数值打印出来
fun1(&p1); //间接修改一级指针的值，而不是修改一级指针指向的内存块
printf("%d \n", p1); //把p1的数值打印出来
fun2(p1);
printf("%d \n", p1); //把p1的数值打印出来
system("pause");
}
/*
编译运行：
100
255
255
请按任意键继续. . .
*/
间接赋值(*p) 是指针存在的最大意义
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void fun1(char **myp1, int *mylen1, char **myp2, int *mylen2)
{
int ret = 0;
char *tmp1 = NULL;
char *tmp2 = NULL;
//间接赋值
tmp1 = (char *)malloc(100);
strcpy(tmp1, "1234567890");
*mylen1 = strlen(tmp1);// 1级指针
*myp1 = tmp1; //2级指针
tmp2 = (char *)malloc(200);
strcpy(tmp2, "abcdefg");
*mylen2 = strlen(tmp2);// 1级指针
*myp2 = tmp2; //2级指针
}
int main()
{
/*
原来p1的值是NULL，通过函数调用，p1指向了一块内存区域
*/
char *p1 = NULL;
char *p2 = NULL;
int len1 = 0;
int len2 = 0l;
int ret = 0;
fun1(&p1, &len1, &p2, &len2);
if (ret != 0)
{
printf("error :%d \n", ret);
}
printf("%s \n", p1);
printf("%s \n", p2);
if (p1 != NULL)
{
free(p1);
p1 = NULL;
}
if (p2 != NULL)
{
free(p2);
p2 = NULL;
}
system("pause");
return ret;
}
/*
编译运行：
1234567890
abcdefg
请按任意键继续. . .
*/
间接赋值的成立条件：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void fun1(int *p)
{
*p = 50;
}
int main()
{
//条件1，定义了2个变量
int a = 0;
int *p = NULL;
//条件2，建立关联
p = &a;
//条件3，*p间接修改
*p = 10;
printf("%d \n",a);
//一级指针与函数
fun1(&a); //把实参的地址传给形参，建立关联
printf("%d \n", a);
system("pause");
return 0;
}
/*
编译运行：
10
请按任意键继续. . .
*/
//间接赋值的应用场景
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
间接赋值成立的三个条件：
条件1：定义变量（实参），定义变量（形参）
条件2：建立关联
条件3：形参去间接的修改了实参的值
*/
//间接赋值的应用场景
// 条件1 2 3 写在一个函数中
int main()
{
char from[100] = { 0 };
char to[100] = { 0 };
char *p1 = from;
char *p2 = to;
strcpy(from,"112233445566");
while (*p1 != ‘\0‘)
{
*p2++ = *p1++;
}
printf("%s \n",to);
system("pause");
return 0;
}
/*
编译运行：
112233445566
请按任意键继续. . .
*/
字符串与一级指针 专题 --- //字符数组的初始化
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//字符串与一级指针 专题 --- //字符数组的初始化
// 1 C语言中的字符串是以数字0结尾的
// 2 在C语言中没有字符串类型，通过字符数组来模拟字符串
// 3 字符串的内存分配可以在堆上 栈上 常量区
int main()
{
char buf1[100] = { ‘a‘, ‘b‘, ‘c‘, ‘d‘ };//除前面4个外，其他全是0
printf("%d \n",buf1[99]);
//char buf2[2] = { ‘a‘, ‘b‘, ‘c‘, ‘d‘ };//大于初始化的内存个数，编译器报错
char buf3[] = { ‘a‘, ‘b‘, ‘c‘, ‘d‘ };//这不是以0结尾的字符串
char buf4[] = "abcd"; //数组的大小是5，字符长度是4
int size = sizeof(buf4);
int len = strlen(buf4);
printf("size=%d, len=%d \n",size,len);
system("pause");
return 0;
}
/*
编译运行：
0
size=5, len=4
请按任意键继续. . .
*/
字符串与一级指针 专题 -- 用数组和指针操作字符串
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//字符串与一级指针 专题 -- 用数组和指针操作字符串
//普通指针与数组变量名字的区别
int main()
{
int i = 0;
char *p1 = NULL;
char buf1[128] = "abcdefg";
for (i = 0; i < strlen(buf1);i++)
{
printf("%c ",buf1[i]);
}
//用指针操作字符串
p1 = buf1;//buf代表数组元素的地址，这句话是错误的。应该说，buf代表数组首元素的地址
for (i = 0; i < strlen(buf1); i++)
{
printf("%c ", *(p1 + i)); //效果一样
printf("%c ", *(buf1 + i)); //效果一样 相当于buf1[i]
//[] 到* 的推导过程
//buf1[i] => buf1[0+i] => *(buf+i) ，buf代表数组首元素的地址
//其实[] 与 * 操作数组，没有多大的区别，只是中括号便于人们的阅读
}
//不允许的操作
//buf1 = buf1 + 1; 左操作数必须为左值
system("pause");
return 0;
}
// 中括号[]的本质：和*是一样，只不过是符合程序员的阅读习惯
// buf是一个指针，只读的常量，buf是一个常量指针。
//为什么这么做？
//buf是一个常量指针，析构内存的时候，保证buf空间完整释放
/*
编译运行：
a b c d e f g a a b b c c d d e e f f g g 请按任意键继续. . .
*/
一级指针 内存模型的建立
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//一级指针 内存模型的建立
int main()
{
char buf1[20] = "aaa";
char buf2[] = "bbbb";
char *p1 = "11111111111111";
char *p2 = malloc(100);
strcpy(p2,"333333");
system("pause");
return 0;
//见图
}
/*
编译运行：
*/
字符串做函数参数
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//字符串做函数参数
int main()
{
char a[] = "i am a student";
char b[64];
int i = 0;
for (i = 0; *(a + i) != ‘\0‘; i++)
{
*(b + i) = *(a + i); //‘\0‘ 并不会存入
}
b[i] = ‘\0‘; //‘\0‘ 并不会存入
printf("%s \n",b);
system("pause");
return 0;
}
/*
编译运行：
i am a student
请按任意键继续. . .
*/
字符串拷贝，3种方法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//字符串拷贝，3种方法
void copy_str1(char *from, char *to)
{
while (*from != ‘\0‘) //当遇到0就跳出来了
{
//指针的指向不断变化，小心啊
// ++ 优先级高
*to++ = *from++; //‘\0‘ 并不会存入
//相当于先 *to = *from, 在to++ from++
}
*to = ‘\0‘;
return;
}
void copy_str2(char *from, char *to) //优化一下
{
while ((*to = *from) != ‘\0‘) //先把值赋过去，再判断
{
*to++;
*from++;
}
}
//经典程序之一 字符串拷贝
void copy_str(char *from, char *to) //再优化一下
{
while (*to++ = *from++); //先把值赋过去，再判断
}
int main()
{
char *from = "Hello";
char buf[100] = {0};
copy_str(from,buf);
printf("%s \n",buf);
system("pause");
return 0;
}
/*
编译运行：
i am a student
请按任意键继续. . .
*/
经典程序之一 字符串拷贝
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//字符串拷贝，3种方法
//经典程序之一 字符串拷贝
//不要轻易改变形参的值
int copy_str(char *from, char *to) //再优化一下
{
char * tmp_to = to; //引进一个辅助
if (from == NULL || to == NULL) return -1;
while (*to++ = *from++); //先把值赋过去，再判断
//不能出现 printf("%s \n",to)这样的语句，因为to已经改变了
printf("%s \n",tmp_to);
return 0;
}
int main()
{
int ret = 0;
char *from = "Hello";
//char *buf = NULL;
char buf[20] ;
ret = copy_str(from,buf);
if (ret != 0)
{
printf("fun copy_str error %d \n", ret);
}
printf("%s \n",buf);
system("pause");
return ret;
}
/*
编译运行：
i am a student
请按任意键继续. . .
*/
项目开发字符串模型 do while 模型
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//项目开发字符串模型 do while 模型
int main()
{
int count = 0;
char *p = "11abcd123abcd234abcd23abcd2345abcd";
do
{
p = strstr(p, "abcd");
if (p != NULL)
{
count++;
p = p + strlen("abcd");
}
else
{
break;
}
} while (*p != ‘\0‘);
printf("%d \n" ,count);
system("pause");
return 0;
}
/*
编译运行：
*/
项目开发字符串模型 while 模型
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//项目开发字符串模型 while 模型
int main()
{
int count = 0;
char *p = "11abcd123abcd234abcd23abcd2345abcd";
while (p=strstr(p,"abcd"))
{
count++;
p = p + strlen("abcd");
if (*p == ‘\0‘)
{
break;
}
}
printf("%d \n" ,count);
system("pause");
return 0;
}
/*
编译运行：
*/
项目开发字符串模型 while 模型 -- API封装
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//项目开发字符串模型 while 模型 -- API封装
int getCount(char *String/*in*/, char *sub/*i*/, int *count/* out*/)
{
int tmp_count = 0;
int ret = 0;
char *p = String;
if (String == NULL || sub == NULL)
{
ret = -1;
printf("fun getCount error String == NULL || sub == NULL %d \n ",ret);
return ret;
}
while (p = strstr(p, sub))
{
tmp_count++;
p = p + strlen(sub);
if (*p == ‘\0‘)
{
break;
}
}
*count = tmp_count;
return 0;
}
int main()
{
int ret = 0;
int count = 0;
char *p1 = "11abcd123abcd234abcd23abcd2345abcd";
char *p2 = "abcd";
ret = getCount(p1,p2,&count);
if (ret != 0)
{
printf("fun fetCount error %d \n",ret);
}
printf("%d \n" ,count);
system("pause");
return ret;
}
/*
编译运行：
*/
练习题：
第一题，我的答案：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int str_del(const char *str1/*in*/, char * str2/*out*/)
{
int ret = 0;
if (str1 == NULL || str2 == NULL)
{
ret = -1;
printf("fun str_del str1 == NULL || str2 == NULL error: %d \n",ret);
return ret;
}
char *p = str1;
while (*p == ‘ ‘)
{
p++;//跳出空格
}
strcpy(str2, p);//从第一个非空格开始，写入原字符串
int len = strlen(str2);
if (str2[len-1] == ‘ ‘)//如果最后一位有空格
{
p = str2+len-1;//找到最后一个空格的位置
while (*p == ‘ ‘)
{
*p = 0;
p--;
}
}
return ret;
}
int main()
{
int ret = 0;
char *str1 =" abc 123 ";
char str2[128];
ret = str_del(str1,str2);
if (ret != 0)
{
printf("error in fun str_del code:%d\n",ret);
return ret;
}
printf("%s", str2);
system("pause");
return ret;
}
/*
编译运行：
abc 123请按任意键继续. . .
*/
第二题，我的答案：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int getstr(const char *str1/*in*/, char * str2/*out*/, char * str3/*out*/)
{
int ret = 0;
if (str1 == NULL || str2 == NULL || str3 == NULL)
{
ret = -1;
printf("fun str_del str1 == NULL || str2 == NULL || str3 == NULL error: %d \n",ret);
return ret;
}
char *p1 = str1;
char *p2 = str2;
char *p3 = str3;
int i = 0;
while (*p1 != ‘\0‘)
{
if (i % 2)
*p2++ = *p1;
else
*p3++ = *p1;
i++;
p1++;
}
return ret;
}
int main()
{
int ret = 0;
char *string ="1a2b3c4da1b2c3d4";
char str1[128] = { 0 };
char str2[128] = { 0 };
ret = getstr(string,str1,str2);
if (ret != 0)
{
printf("error in fun str_del code:%d\n",ret);
return ret;
}
printf("str1=%s\n", str1);
printf("str2=%s\n", str2);
system("pause");
return ret;
}
/*
编译运行：
str1=abcd1234
str2=1234abcd
请按任意键继续. . .
*/
指针经典话语：
1，指针指向谁，就把谁的地址赋给指针；
2，指针变量 和 它指向的内存空间变量是两个不同的概念
3，理解指针的关键是内存，没有内存哪里来的指针
变量的本质是一个固定大小的数据块，变量名就是数据块的编号
内存的使用范围：
main函数可以在栈分配内存/堆分配内存/全局分配内存，可以给子函数使用
子函数在栈分配的内存不能给主函数使用，但是堆内存与全局变量是可以给main使用
编译器会为每个程序分配一个内存4区，主函数与子函数公用这个内存4区
建立正确程序运行内存布局图是学好C的关键！
指针铁律1：指针是一种数据类型
1）指针也是一种变量，占有内存空间，用来保存内存地址
2）*p 操作内存；
3）*就像一把钥匙，通过一个地址(&a),去修改a变量的标示的内存空间
4）不断的给指针赋值，相当于不停的改变指针的指向。
5） 指针是一种数据类型，是指它指向内存空间的数据类型
指针铁律1：间接赋值(*p) 是指针存在的最大意义
时间： 2024-10-05 05:41:35