指针与数据关系：
1、指针与变量
2、指针与数组（一维，二维）
3、指针与结构体的变量
4、二级和多级指针
一级指针变量：专门用于存放普通变量的地址
eg: int b=200; int* a=&b;
二级指针变量：专门用于存一级指针变量的地址
二级定义变量： 类型** 变量名
5、指针与函数的关系：
C语言：面向过程（模块（函数）：功能）
函数分类：自定义函数，系统函数
系统函数：由系统提供的模块接口（API）
printf(实参) ...
1、调用函数： 函数名(实参列表);
注：调用函数一定要函数名匹配
2、自定义函数：f(x,y)=3x+y;
函数类型 函数名(形参列表)
{
函数体;//功能模块的过程描述
}
1、无返回值 无形参
viod 函数名(void)
{
}
2、有形参 无返回值
void 函数名（形参列表）
{
}
1、一级指针作形参：当在被调用函数内需要修改调用函数内的数据时传递地址
2、传递数组：
返回值 函数名(char buf[]);//buf是指针变量
3、结构体作形参：（实参传递形参：值传递）
缺点:不能修改调用函数内的结构体内容
（通过名字或者地址）
结构体指针作形参：修改指向内容
3、变量的作用域，生命周期：
1、变量作用域：能被引用的区间
全局：在函数外定义的变量
作用域：从定义开始，到本文件程序。
局部：在函数内定义的变量
作用域：在函数内
2、变量的生命周期：
动态区：auto变量（只能在函数内定义）
当函数被调用时，空间被申请。当函数运算结束时，空间被释放。
静态区：static变量或全局变量
堆 区：alloc/malooc等申请 free释放
栈：是一种算法思想（先进后出 FILO => first,into,last,out ）
应用：撤消，浏览上一页，恢复
算法：#口
栈顶：能被操作的一端（能进栈/出栈）
栈底：不能被操作的一端（不能进栈/出栈）
操作：每次操作“只能”取/进一个数据
顺序（数组：）栈：数据的容器是一个块数组
功能：
1、初始化栈:initStack
2、进栈： push
注：栈不能为满
3、出栈： pop
4、栈元素的个数：stackLength
5、次栈栈顶元素的:
6、清空栈：ClearStack
7、判断栈为空：IsEmpty
8、判断栈为满 ：IsFull
通过二级指针修改一级指针 :
#include<stdio.h>
void main()
{
//定义变量：按类型来分配空间
int b=200;
//引用变量：引用变量的内容
printf("b=%d\n",b);
//修改一个变量的内容：变量名 空间地址
b=100;
printf("b=%d\n",b);
//定义一个指针变量：存放普通变量的地址 (int* )
int* a=&b;
//通过一级指针修改b的内容（通过a间接修改b的内容）
//a=199; 不能成功的修改b的内容 只会修改a的内容
*a=199;
printf("b=%d\n",b);
//二级指针：存放一级指针变量的地址
printf("%x\n",&a);
//int*c =&a; //警告：一级指针只能存储普通的地址
int* c=a;
printf("%x %x %x\n",&b,a,c);
int** ppa=&a;
printf("sizeof(ppa)=%d\n",sizeof(ppa));
printf("%x\n",ppa);//a的地址
//应用：1通过ppa修改b的值 (需要b的地址)
printf("*ppa=%x **ppa=%d\n",*ppa,**ppa);//ppa引用ppa的内容（a的空间的地址） *ppa==(*&a)引用a的内容
**ppa=1999;
printf("b=%d\n",b);
// *2通过二级指针修改一级指针的内容：通过ppa修改a(a->b)的内容(a->y)
int y=2018;
// ppa=&y; //error:只会修改ppa的内容
*ppa=&y;
printf("*a==%d\n",*a);
//定义变量：按类型分配空间
//引用变量：引用b的内容或者地址的内容 *地址 b
// 地址->成员 内容.成员
}
二级指针与结构体的关系 :
修改结构体的内容 , 通过 strcpy(( **pp ).name , " lili" ); 来修改.
#include<stdio.h>
#include<string.h>
//结构体：
struct people
{
int id;
char name[10];
};
void main()
{
//定义变量：按类型分配空间
struct people lf={1001,"lifei"};
//引用变量的属性： 内容.属性
printf("%s\n",lf.name);
//一级指针变量：类型* 变量名;
struct people* p=&lf;
printf("%x\n",p);//引用变量：引用变量的内容 p的内容为lf的地址
printf("%s\n",p->name);
//二级指针：
struct people** pp=&p;
printf("%s %s\n", (*pp)->name, (**pp).name);
//通过pp修改自己的名字：
strcpy((**pp).name,"lili");
printf("%s\n",lf.name);
}通过指针交换局部变量的a , b 的值 , 还有通过指针改变改变数组的字符.
#include<stdio.h>
//交换函数：
void swap(int* x,int* y)
{
int temp=*x;
*x=*y;
*y=temp;
printf("main: x=%d,y=%d\n",*x,*y);
}
//数组作形参：它是一个指针变量
void fun(/*char* pb*/char pb[])
{
*(pb+0)='H';//引用内容
}
void main()
{
char buf[100]="hello world";
//调用函数：
printf("main::sizeof(buf)=%d\n",sizeof(buf));
fun(buf);//实参 buf名字：首地址
printf("%s\n",buf);
/*
int a=1,b=2;
swap(&a,&b);
printf("main: a=%d,b=%d\n",a,b);
*/
}
习题 :
通过指针 , 转换字符串成为整型 atoi
#include<stdio.h>
//将某数组转换为整形
int change(char pb[]/*char* pb*/)
{
//1-49 2-48
int result=0;
while(*pb>='0' && *pb<='9')
{
result*=10;
result+=(*pb-'0'); //ASCII ‘0’---48
pb++;//指向下一个元素
}
return result;
}
void main()
{
char buf[100]="123"; // 123a4--->123 a123->0 12a3->12
printf("%d %d\n",change(buf),atoi(buf));
}习题 :
(两种方法)通过指针实现 , 比较两个字符串大小：strcmp(s1,s2);
#include<stdio.h>
/*
* 功能:比较两个字符串大小
* 返回值: 1> 0 == -1 <
* 函数名: strcmp_if(char str1[],char str2[])
*/
short strcmp_if(char str1[],char str2[])
{
int result=0,i=0;
while(0==(result=*(str1+i)-*(str2+i)) && *(str1+i)!='\0') //str1!='\0'&&*str2!='\0'
{
i++;
};
if(result>0)
{
printf("1>2");
}
else if(result<0)
{
printf("1<2");
}
else
{
printf("相等");
}
/* short result=0;
while(0==(result=*str1-*str2)&&*str1!='\0')
{
str1++;
str2++;
}
return result;*/
}
void main()
{
char buf1[10]="21333";
char buf2[10]="1234";
strcmp_if(buf1,buf2);
/* int a=100;
int result=strcmp_if(buf1,buf2);
if(result>0)
{
}
else if(result==0)
else
*/
}习题 :
通过指针来实现 , 复制字符串：
#include<stdio.h>
void strcpy_lf(char str1[],char str2[])
{
/*
int i=0;
while('\0'!=(*(str1+i)=*(str2+i)))i++;
printf("%s",str1);
*/
/*第三种
* int i=0;
* while((*str1=*str2)!='\0')
* {
* str1++;
* str2++;
* }
*/
int i=0;
while(*(str1+i)!='\0');
for(i=0;*(str2+i)!='\0';i++)
{
*(str1+i)=*(str2+i);
}
printf("%s",str1);
}
void main()
{
char buf1[10]="21333";
char buf2[10]="1234";
strcpy_lf(buf1,buf2);
}栈 :
#include<stdio.h>
struct stack
{
int buf[6];
int top;
};
void initStack(struct stack* ps);
void initStack(struct stack* ps)
{
if(NULL!=ps)
{
ps->top=-1;
}
}
short full(struct stack* p)
{
if(p->top==6-1)
return 0;
else
return 1;
}
short empty(struct stack* p)
{
if(p->top==-1)
return 0;
else
return 1;
}
short push(struct stack* p,int data)
{
if(0==full(p))
return 0;
else
p->buf[++p->top]=data;
return 1;
}
short pop(struct stack* p,int* pdata)
{
if(0==empty(p))
return 0;
else
*pdata=p->buf[p->top--];
return 1;
}
short geshu(struct stack* p)
{
return p->top;
}
short qk(struct stack* p)
{
p->top=-1;
}
void main()
{
struct stack c;
initStack(&c);
int opt;
//int a=0;
while(1)
{
printf("出栈0,进栈1,长度2,清空3:");
scanf("%d",&opt);
if(opt==1)
{
int data;
printf("请输入进栈数:");
scanf("%d",&data);
if(1==push(&c,data))
{
printf("进栈seucces\n");
//a++;
}
else
printf("进栈defeat\n");
}
else if(opt==0)
{
int pdata;
printf("请输入出栈数:");
scanf("%d",&pdata);
if(0==pop(&c,&pdata))
printf("出栈defeat\n");
else
{
printf("出栈seucces\n");
//a--;
}
}
else if(opt==2)
{
printf("元素的个数有:%d\n",geshu(&c)+1);
}
else if(opt==3)
{
qk(&c);
printf("以清空元素");
}
}
}
扫一扫
1997
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
