=============
指针
=============
【认识指针】
【地址】内存被划分成一字节一字节的小单元，这些小单元都有自己的编号。这些编号 就是地址。地址就一个常量。
【指针】指针是存储地址的变量。
int a; a是整型变量，a中存储的是整数；
int * p;p是指针，p中存储的是地址。
【指针的定义】pointer p q r s t
指向类型 * 变量名
指向类型——指针是存储地址的变量，指针中存储的哪种类型的变量的地址，就是指针 的指向类型是什么。
【例如】
int a;
int * p = &a; //将int型变量的地址赋值给指针变量p,我们就说指针p指向了a。
变量名——指针就是一个变量，变量名就是标识符。
【课堂练习】
1、定义一个指向字符变量的指针； char * p; char* p char *p
2、定义一个指向long类型变量的指针；long * q;
3、定义一个指向double类型变量的指针； double * r;
【思考】char * p 与long * q所占的字节数一样吗？一样，因为指针中存放的是内存单 元编号。
【注】在32位系统下，指针占4字节，在64位系统下面指针占8字节。
【与指针有关的运算符】
【*】 指针运算符（或取内容运算符）取指针所指变量的内容。
【&】取地址运算符 取变量的地址
【与指针有关的表达式】
【注】* & ++ — 优先级是一样的 右结合
int a = 1; int * p = &a;
1、&p
2、&a
3、p++
4、(p)++
&*p
对指针变量p进行取内容运算得到a,然后对变量a进行取地址运算 &a
变量a的地址
*&a
对变量a取地址得到指针p,对指针p取内容得到变量a
1
*p++
p++—>(p++)—>a,指针指向了变量a的下一个地址，指针的指向发生改变
1
(*p)++
(*p)++ —>a++ a的加1
1
【为什么要使用指针？】
【答】为了跨栈访问。
【课堂练习】
1、自定义函数，交换变量a与b的值；
2、自定义函数，在函数将数组a值与数组b的值对应相加，结果保留在数组c中。
int a[10],int b[10],int c[10];
【指针与数组】
共性：
指针+1—》加上指针所指类型的字节数。
int *p p++ 4个字节
char * q q++ 1个字节
数组名+1 —》加上数组元素的字节数
【见代码 数组与指针】
【结论】
1、数组名代表着数组首元素的地址；
2、数组名作为实参，形参：指向数组首元素的指针 数组元素类型 * 变量名
3、当指针指向数组的首元素时，该指针可以跟数组名一样用下标法遍历数组。
【指针数组与指向数组的指针】
* [] []优先级高于*
【如何辨别与指针相关的妖魔鬼怪？】
1、先找到变量名，
2、然后观察左右两边的运算符，() [] *
3、根据优先级去确定这到底是个什么鬼；优先级最高的运算符如果是，说明这是一个 指针；优先级最高的是[],说明这是一个数组；优先级最高的是（），说明这是一个 函数的声明。
4、如果是数组，我们要看数组元素是什么类型，遮住数组名与数组的大小剩余部分就 是数组元素的类型；
如果是指针，我们要看指针指向什么类型，遮住变量名与剩余部分就所指向的类 型。
如果是函数，我们要看函数的返回值类型与形参列表。函数名前半部分都是返回值 类型，函数名后面都是形参列表；
int *p[10]; p的左边是*右边是[],[]的优先级高，所以这是一个数组，数组元素的类型（遮住数组名与数组的大小剩余部分就是数组元素的类型int *p[10]）int *,是指针int类 型的指针
int (*p)[10]; 这是一个指针，指向一个数组，数组的类型是int [10];
【指向数组的指针与指向数组元素的指针】
int (*p)[10]; 指向数组的指针
int * p; 指向数组元素的指针
【不同】指向数组的指针+1，加上整个数组的字节数；
指向数组元素的指针+1，加上数组元素的字节数。
【二维数组传参】
【练习】自定义函数，在函数打印二维数组主对角线上所有的元素。
【指向指针的指针】二级指针
int * * p;
【指向函数的指针】
函数返回值类型（*指针名）（形参列表）
指针与数组
#include <stdio.h>
void sort(float * p,int n);
int main(int argc, const char * argv[]) {
long a = 10;
long * p = &a;
printf("%p\n",p);
printf("%p\n",p+1);
//指针+1 加上所指类型的字节数
long arr[5] = {1,2,3,4,5};
//数组名代表着数组首元素的地址
printf("%p\n",arr);
printf("%p\n",&arr[0]);
printf("%p\n",arr+1);
//数组名+1 加上数组元素的字节数
//所以【数组名+i】 就可以得到数组中第i个数组元素的地址（下标从0开始）
//*(arr+i)可以得到数组元素a[i]
//*(arr+i) == a[i]
//[]数组下标运算符完成的功能：数组名+i得到地址，然后取*
// long * r = arr;
// *(arr+i) == a[i];
// *(r+i) == r[i];
//【结论】数组名代表着数组首元素的地址，当指针变量p指向数组的首元素，我们也可通过指针p，利用下标运算符去访问数组元素。
//【例】
float arr2[5] = {8.9,5.6,3.3,1.5,2.0};
float *s = arr2;
for (int i = 0; i<5; i++) {
printf("%.2f ",s[i]);
}
//自定函数，给上面的数组2进行排序。从小到大。
// void sort(float *p,int n);
sort(arr2, 5);
printf("\n");
for (int i = 0; i<5; i++) {
printf("%.2f ",arr2[i]);
}
return 0;
}
//void sort(float p[],int n)
void sort(float * p,int n){
for (int i=0; i<n-1; i++) {
for (int j=0; j<n-1-i; j++) {
if (p[j]>p[j+1]) {
float temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
}
}
}
指针与数组
#include <stdio.h>
int main(int argc, const char * argv[]) {
int a[5] = {1,2,3,4,5};
//指向数组首元素的指针
//数组名代表着数组首元素的地址
int * p = a;
//指向数组的指针
//存储数组的地址
int (*q)[5] = &a;
printf("数组首元素的地址:%p\n",p);
printf("数组首元素的地址+1:%p\n",p+1);
printf("数组的地址:%p\n",q);
printf("数组的地址+1:%p\n",q+1);
return 0;
}
二维数组
#include <stdio.h>
int main(int argc, const char * argv[]) {
int a[5] = {1,2,3,4,5};
//指向数组首元素的指针
//数组名代表着数组首元素的地址
int * p = a;
//指向数组的指针
//存储数组的地址
int (*q)[5] = &a;
printf("数组首元素的地址:%p\n",p);
printf("数组首元素的地址+1:%p\n",p+1);
printf("数组的地址:%p\n",q);
printf("数组的地址+1:%p\n",q+1);
return 0;
}
指针跨栈访问
指针跨栈访问.png
运算符优先级
运算符优先级.png
练习
1.编写函数，求任意长整形数组的平均数， 返回。
int avg(int * a, int n);
2.编写函数，求任意长整型数组中第二大的数。
Δ3.编写函数，传入一个字符数组，找出数组中最长的单词（只由字母构成），返回最长单词起点的下标/索引。
int indexOfLongestWord(const char * a, int n);
4.编写函数，传入一个字符数组，返回数组中第一个出现的字母，如果字符中没有字母，返回0.
//返回值是char
Δ5.编写函数，传入一个字符数组，无需返回值，将数组中字符压缩后打印。
传入:“helloworld”
打印:h1e1l3o2w1r1d1
6.编写函数，传入两个浮点数字和一个字符，字符传入‘+’ ‘-’’*’’/’.
返回计算结果，如果被除数是0，返回-9999999.
double math(double a, double b, char sign);
7.编写三个函数，第一个，用scanf给数组赋值
void scanArray(int * arr, int n);
//arr是数组名，n是数组元素个数。
第二个给数组排序
void sortArray(int * arr, int n);
第三个打印数组
void printArray(int * arr, int n);
//然后使用三个函数，完成输入10个数字，排序后输出的程序。
scanf(“%d”, &a);
