1、指针变量只能存储地址。指针就一个作用，能够根据地址值访问对应的存储空间。

2、定义指针int *p;

3、给指针赋值 p =#

4、访问并修改指针变量p指向的存储空间*p = 1;

5、不同类型的指针变量所占内存空间的大小都是8个字节。

6、当指针指向一个数组，那么这个指针*(p +i)就是去取出这个数组的第i个值。

指针 + 1 不是里面的值 + 1，而是地址 + 一个指针指向的元素的类型地址长度。

把地址加上i，就代表这个指针指向第i个元素，因为首地址和第i个元素相差“i乘以这个元素类型的字节数”个字节。

int类型是4个字节，这里加1就是加4个字节的地址，获取下一个元素的地址。

如果是char类型，p + 1就是加一个字节的地址。获取下一个元素的地址。

这里不能使*p +i这个代表取出 p指向的存储空间的值在加上数值i

指针还可以像一个数组一样来取值，p指向数组a[10]; p[2] ==a[2];

7、数组名就是这个数组的指针也就是数组第一个元素的指针

数组ages[10];

ages == &ages[0];

8、数组作为函数参数时有两个写法

数组int a[10];

void test(int a[]);

void test(int *a);

调用时

test(a);

所以，在函数中无法用sizeof来判断这个数组多大。因为它在函数中

判断的只是指针a的字节数，永远是8；

9、chara[] = "123";和 char *a = "123";这两个字符串有很大的区别，前面的可以修改值，后面的不可以。

常量区：存放一些常量

堆：对象

栈：局部变量

char a[]是存在栈中的，随便修改。这个称作字符串变量

char *a是存放在常量区，这个是字符串常量。

例如

char *str1 ="abc";

char *str2 = "abc";

printf("%p\n%p\n",str1,str2);

输出结果相同，因为abc存放在常量区，第一次定义了就存放到常量区了，第二次用它还是它。不用在另外在开辟存储空间。

10、存放整型变量的叫整型数组 inta[10];数组里面存放的是整型数据

存放指针的数组叫指针数组char*name[10];数组里存放的是char指针

char *name[5] ={"jack", "rose", "jake"};

name[0]就是取出数组元素0位置的指针，%s输出name[0]就是jack

char *name[2] = {"tom","jack"};指针数组

char name[2][10] ={"tom", "jack"};二维字符串数组

11，经过9，10两项，总结出，如果要进行字符串输入并且储存，要用数组。不能用指针。

12、函数的返回值是指针

char *test()

{

return "haha";

}

调用

char *str = test();

printf("%s",str);

结果为haha

13、指向函数的指针

首先是书写格式

整型指针int *p;

函数返回值 (*p)(形参);  (*p)是固定写法。

p =函数名;    p指向函数的地址。

void test()

{

printf("aa");

}

定义一个指向test的指针

void (*p)();

p = test;

或者

void (*p)() = test;

整型指针 int *p =&a;

指向函数的指针 void (*p)()= test;

取出指针指向控件的值 *p；

调用函数 (*p)();        (*p)相当于先取出这个函数，然后后面的()就是调用了函数。

1.                 #include <stdio.h>
   
2.                
   
3.                 void test(){
   
4.                     printf("调用test函数\n");
   
5.                 }
   
6.                
   
7.                 int  test2(int num1,int num2)
   
8.                 {
   
9.                     return num1 + num2;
   
10.                 }
    
11.                
    
12.                 char *test3()
    
13.                 {
    
14.                     return "调用了test3函数\n";
    
15.                 }
    
16.                
    
17.                
    
18.                 int main()
    
19.                 {
    
20.                     //定义一个指向test函数的指针
    
21.                     void (*p)() = test;
    
22.                     //定义一个指向test2函数的指针
    
23.                     int (*p2)(int, int) = test2;
    
24.                     
    
25.                     //定义一个指向test3的函数的指针
    
26.                     char *(*p3)() = test3;
    
27.                     
    
28.                     //调用test函数的方法1
    
29.                     (*p)();
    
30.                     //调用test函数的方法2
    
31.                     p();
    
32.                     //调用test函数的方法3
    
33.                     test();
    
34.                     
    
35.                     int n1 = 10;
    
36.                     int n2 = 2;
    
37.                     int sum;
    
38.                     int sum2;
    
39.                     int sum3;
    
40.                     //调用test2的方法1
    
41.                     sum = (*p2)(n1,n2);
    
42.                     printf("%d\n",sum);
    
43.                     //调用test2的方法2
    
44.                     sum2 = p2(n1,n2);
    
45.                     printf("%d\n",sum2);
    
46.                     //方法3
    
47.                     sum3 = test2(n1,n2);
    
48.                     
    
49.                     //调用test3方法1
    
50.                     printf("%s",p3());
    
51.                     //调用test3方法2
    
52.                     printf("%s",(*p3)());
    
53.                     //调用test3方法3
    
54.                     printf("%s",test3());
    
55.                     return 0;
    
56.                 }
    

复制代码

学习了，赞一个