1.指针
1.什么是指针,指针的作用作用
- 什么情况下定义的参数是指针：这个函数会不会改变传递过来的数据本身，需要改变外部的值，就将这个变量定义为指针变量。如果希望在函数之间传递数据>1，此时为多个数据，给调用者此时需要用到指针
- 指针作用：通过指针间接访问某个内存
#include <stdio.h>
void test(int *pa,int *pb){
(*pa)++;
(*pb)++;
}
int main(){
int a = 10;
int b = 20;
test(&a,&b);
printf("a:%d b:%d",a,b);
return 0;
}
运行结果：a:10 b:20
- 什么是指针：指针变量是一个变量，只能存1地址，指针变量占据8个字节的内存空间（指针变量本身占据内存空间），无论是什么类型的指针int a = 110;(普通变量) int *pa;(指针变量存的是地址均占据八个字节
- int *a;//整型指针指向整数 int a1[10];
- int *a[10] = {};//数组里放的是一个整型指针
- int (*test)(int a) ;//函数指针
1.定义的时候表明是一个指针 （定义一个指针变量）int temp = 10;//普通变量
temp = 20;//直接访问(变量本身temp本占据内存空间，存值的时候才会有内存空间的分配)-
int *p = &temp;//定义一个指针变量，分配的是temp的地址
*p = 10;//取地址的值*p = 20;间接访问（指针变量）*p = *0X100 = 20
&取地址 注意
//申明一个变量（没有分配内存空间）
int tt;
//此时才有内存空间的分配 tt->0X100
tt = 200;
在定义一个变量时为了立刻分配对应内存空间，应该在定义的时候就初始化
int tt = 20;
2.指针的类型
去掉*和变量名（剩下的为指针的类型）
int *p;//整型指针
指针变量只能指向同种数据类型的地址
int main(){
int a = 20;
int b = 30;
<1>.常量指针
不能改变指针指向的变量的值,可以改变指针的指向
int const *pa = &a; //const
// *p = 80;//错误 因为有const不能改变指针指向的变量的值
pa = &b;//正确 可以改变指针的指向
<2>.指针常量（数组）
可以改变指针指向的变量的值,不能改变指针的指向
int *const pb = &a;
*pb = 50;//正确 可以改变指针指向的变量的值
pb = &b;//错误 不能改变指针的指向
<3>.指向常量的常量指针
不能改变指针指向变量的值,不能改变指针的指向
int const * const pc = &a;
*pc = 50;//错误 不能改变指针指向变量的值
pc = &b;//错误 不能改变指针的指向
3.指针的值：指针存储的是地址
指向的内存空间的首地址
4.指针指向的值(区域)
指向一个普通变量：（一级指针）
int a = 20;
int *pa = &a;
*pa为指针指向的变量
指向一个地址：（二级指针）
int a = 20;
int *pa = &a;
int **pb = &pa;
int ***pc = &pb;
普通指针变量 int *pa;
常量指针
5.指针的运算
6.指针和数组
7.指针和函数
#include <stdio.h>
int main(){
//1.数组名就是数字的首地址
int num[] = {1,2,3,4,5,6,7,8,9};
printf("%p\n",num);
printf("%p\n",&num[0]);
return 0;
}
2.实现计算器功能（实现计算，使用函数进行封装）
1.程序的入口函数（main函数）
2.将不同的功能模块用不同的.h .cpp来封装
- .h头文件 函数声明（不能实现）
- .cpp .c 实现文件 （函数的具体实现）
main.cpp（为了让阅读者知道我这里面写的是入口函数）
#include <stdio.h>
//1.程序的入口函数（main函数）
//2.将不同的功能模块用不同的.h .cpp来封装
//.h头文件 函数声明（不能实现）
//.cpp .c 实现文件 （函数的具体实现）
//3.导入头文件进行使用
#include "Calculate.h"
int main(){
int result = add(1,1);
printf("1 + 1 = %d\n", result);
printf("1 + 1 = %d\n", add(1,1));
printf("2 - 1 = %d\n", minus(2,1));
printf("2 * 2 = %d\n", multiply(2,2));
printf("2 / 2 = %d\n", devide(2,2));
return 0;
}
Calculate.h(函数声明)
#include <stdio.h>
//头文件里面的声明函数
//加法
int add(int a,int b);
//减法
int minus(int a,int b);
//乘法
int multiply(int a,int b);
//除法
int devide(int a,int b);
Calcuate.cpp(实现文件）
//实现文件
//1.先导入需要实现的头文件
//2.实现这个头文件里面的所有方法
#include "Calculate.h"
//加法
int add(int a,int b){
return a+b;
}
//减法
int minus(int a,int b){
return a-b;
}
//乘法
int multiply(int a,int b){
return a*b;
}
//除法
int devide(int a,int b){
if(b == 0){
return 0;
}else{
return a/b;
}
}
输出结果：
1 + 1 = 2
1 + 1 = 2
2 - 1 = 1
2 * 2 = 4
2 / 2 = 1
数组和指针关系
共同点
数组也可以用指针方式访问
*num = 20;
#include <stdio.h>
int main(){
//num[0] = 20;
//num[1] = 30;
int num[9] = {1,2,3,4,5,6,7,8,9};
int *p = num;
printf("%p\n",num);
printf("%p\n",&num[0]);
printf("%d\n",sizeof(num));
int a = (*p)++;//1
int b = *(p++);//2
printf("--%d %d",a,b);
//*num++ = 20;
//指针里边如果不确定的情况下尽量加圆括号，用来分清结合方式
//*num++ = 20;
return 0;
}
输出结果：
000000000062FDE0
000000000062FDE0
36
--1 2
数组是一个指针常量，数组的指向不能改变==不能对数组进行运算
区别
-
数组是一片连续的内存空间，指针只能存一个值
sizeof(num) = 5*4 = 20，sizeof(num)计算整个数组的内存空间
sizeof(p) = 8
数组本身就有内存可直接存东西
指针变量只有指针分配的内存空间不能存东西只能存地址，必须再进行分配，指针只是一个用来存地址变量-
数组名就是数字的首地址,数组名本生没有分配内存空间
字符串"abc”== 字符数组
char name[100] = {};
//注意不能直接使用字符指针来接收字符串
//字符指针只为这个变量分配8个自己内存空间
//这个空间只能用来存地址，不能存具体数据
char *name;
接收终端输入的字符串，在main函数中输出
#include <stdio.h>
void test3(char *p){
//helloworld\0
//scanf("%s", p);
int i = 0;
while(1){
//从终端接收一个字符
char c = getchar();
//判断是否结束 \n
if(c == '\n'){
//需要在数组里面添加一个\0
p[i] = '\0';
break;
}
//保存数据
p[i] = c;
//索引值++
i++;
}
}
int main(){
//字符串"abc” == 字符数组
char name[100] = {};
//注意不能直接使用字符指针来接收字符串
//字符指针只为这个变量分配8个自己内存空间
//这个空间只能用来存地址 不能存具体的数据
//char *name;
test3(name);
//字符数和字符串 使用%s
printf("%s\n", name);
return 0;
}
