学习C指针-编程知识

指针基本介绍

计算机中的每个内存都有地址

整型分配4字节，字符分配1字节，浮点数分配4字节

指针是一个变量，它存放着另外一个变量的地址

int a;
int *p;
p = &a;//
a = 5;
printf(p)  //get a address
print &a   //get a address
print &p   //get p address
print *p   //得到指针所指向的地址的值p = address*p = value at address

当指针变量前面没有加*号进行操作，是在对地址进行操作，

*p则是对指针所指向的地址操作

指针代码示例

#include<stdio.h>
#include<stdlib.h>
int main()
{int a = 10;int *p = &a;//p = &a;//&a = address of a//int* p 意外着指向整型的指针然后写出变量名printf("Address of p is %d\n",p);printf("Value at p is %d\n",*p);printf("%d\n",p);printf("%d\n",*p);//*p = value at address pointed by pprintf("%d\n",&a);printf("a = %d\n",a);*p = 12;//使用指针对所指向的地址值进行修改printf("a = %d\n",a);int b = 20;*p = b;printf("Address of p is %d\n",p);printf("Value at p is %d\n",*p);system("pause");return 0;
}

#include <stdio.h>
#include <stdlib.h>int main() {int a = 10;int *p;p = &a;//Pointer arithmeticprintf("Address p is %d\n",p);printf("value at address p is %d\n",*p);printf("size of integer is %d bytes\n",sizeof(int));printf("Address p+1 is %d\n",p+1); //增加4字节以得到下一个整型的地址system("pause");return 0;
}

指针的类型，算术运算，void指针

指针是强类型的

我们需要一个特定类型的指针变量来存放特定类型变量的地址

byte3	byte2	byte1	byte0
00000000	00000000	00000100	00000001
203	202	201	200
最左边为符号位		2的10次方	2的一次

剩下的31个位用来存储值

#include <stdio.h>
#include <stdlib.h>int main() {int a = 1025;int *p;p = &a;//Pointer arithmeticprintf("size of integer is %d bytes\n",sizeof(int));printf("Address = %d,value = %d\n",p,*p);char *po;po = (char*)p;printf("size of char is %d bytes\n",sizeof(char));printf("Address = %d,value = %d\n",po,*po);printf("Address = %d,value = %d\n",po+1,*(po+1));system("pause");return 0;
}

通用指针类型，不针对某个特定的数据类型，这种指针类型被称为void类型的指针

void *p

指向指针的指针（pointer to pointer）

#include <stdio.h>
#include <stdlib.h>int main() {int x = 5;int *p = &x;*p = 6;int **q = &p;int ***r = &q;printf("%d\n",*p);//指针p所指向的内存地址的值printf("%d\n",*q);//指针q所指向的指针p的地址printf("%d\n",*(*q));//指针q所指向的指针q的地址，指针p所指向的地址值printf("%d\n",*(*r));printf("%d\n",*(*(*r)));//变量x是整型，为了得到x的地址，需要int* 类型的指针//为了存储p地址，需要一个指向int*类型的指针，为此再加一个*，表示这个指针指向的是int*//可以无限套娃system("pause");return 0;
}

函数传值vs传引用

当我们在函数里面声明一个变量，我们把它叫做局部变量，我们只能在声明了变量的地方使用这个变量

#include<stdio.h>
#include<stdlib.h>void Increment(int a)
{a = a + 1;printf("Address of variable a in increment = %d\n",&a);
}int main()
{int a;a = 10;Increment(a);printf("Address of variable a in main = %d\n",&a);system("pause");return 0;
}

main函数的a与自增函数的a的地址不一样

应用程序所使用的内存如下表格

内存
Heap
Stack
Static/Global
Code(Text)

第一部分（Code）：用来存储程序的指令，计算机需要把指令加载到内存，就像上面程序中的自增语句

第二部分：分配给静态或者全局变量

如果我们不是在函数中声明变量，那么它将会是一个全局变量（Global），作为一个全局变量，在程序的任何地方都可以访问和修改。

局部变量只能在特定的函数或者特定的代码块进行访问和修改。

第三部分：局部变量都放在stack部分

第四部分：堆

内存中的四个部分，一二三是固定的，应用程序在运行时可以要求在堆区为它分配跟多的内存

当我们在主函数中调用其它函数，这个参数被称为实参，被调函数中的参数被称为形参，调用时，实参被映射到形参

传引用

#include<stdio.h>
#include<stdlib.h>void Increment(int *p)
{*p = (*p) + 1;
}int main()
{int a;a = 10;Increment(&a);printf("a = %d\n",a);system("pause");return 0;
}

指针和数组

#include<stdio.h>
#include<stdlib.h>int main()
{int A[] = {2,4,5,8,1};printf("%d\n",A);printf("%d\n",&A[0]);printf("%d\n",A[0]);printf("%d\n",*A);system("pause");return 0;
}

#include<stdio.h>
#include<stdlib.h>int main()
{int A[] = {2,4,5,8,1};int i;for(i = 0;i < 5;i++){printf("Address = %d\n",&A[i]);printf("Address = %d\n",A+i);printf("Value = %d\n",A[i]);printf("value = %d\n",*(A+i));}system("pause");return 0;
}

数组作为函数参数

#include<stdio.h>
#include<stdlib.h>int SumOfElements(int A[],int size)
{int i,sum = 0;for(i = 0;i < size;i++){sum+= A[i];}return sum; 
}int main()
{int A[] = {1,2,3,4,5};int size = sizeof(A)/sizeof(A[0]);//用数组A的大小除以A[0]的大小，这样就会得到数组中元素的个数int total = SumOfElements(A,size);printf("Sum of elements = %d\n",total);system("pause");return 0;
}

#include<stdio.h>
#include<stdlib.h>int SumOfElements(int A[])//A是一个整型指针，而在main函数中A是一个数组
{int i,sum = 0;int size = sizeof(A)/sizeof(A[0]);printf("SOE - Size of A = %d,size of A[0] = %d\n",sizeof(A),sizeof(A[0]));//'sizeof' on array function parameter 'A' will return size of 'int*' //当编译器看到数组作为函数参数的时候，它不会拷贝整个数组，这里我们不是拷贝变量的值，而仅仅是拷贝变量的地址for(i = 0;i < size;i++){sum+= A[i];}return sum; 
}int main()
{int A[] = {1,2,3,4,5};//用数组A的大小除以A[0]的大小，这样就会得到数组中元素的个数int total = SumOfElements(A);printf("Sum of elements = %d\n",total);printf("Main - Size of A = %d,size of A[0] = %d\n",sizeof(A),sizeof(A[0]));system("pause");return 0;
}

指针和字符数组

NULL字符的ASCII的值是0，因为C里面的字符串必须以NULL结束

#include<stdio.h>
#include<stdlib.h>int main()
{char C[5];C[0] = 'J';C[1] = 'O';C[2] = 'H';C[3] = 'N';C[4] = '\0';printf("%s",C);getchar();return 0;
}

strlen函数不会把null算入在内

当把字符数组赋值给字符指针，实际上是把字符数组的首地址告诉指针

#include<stdio.h>
void print(char* C)
{int i = 0;while(C[i] != '\0'){printf("%c",C[i]);i++;}printf("\n");
}
int main()
{char C[20] = "Hello";print(C);getchar();return 0;
}

指针和二维数组

指针和多维数组

多维数组本质上是数组的数组

数组基本上可以理解为同类型事物的集合，多维数组基本上可以理解为数组的集合

当仅使用数组名的时候，它会返回数组首元素的指针

print B //400

print *B //400

print B[0] //400

print &B[0][0] //400

B返回一个指向一维数组的指针，而*B返回一个指向整型的指针

当我们只是打印地址的时候，一维数组B[0]和B[0]的首元素的起始地址是一样的，所以会打印相同的地址

arr[2][3][4],相当于一个三维数组有两个数组，这两个二维数组里面各自有三个数组，这三个数组各自里面再有四个数组

解引用就是当前变量存取的值，如果*p是指向数组，则值就是首地址，如果是指向数据，则就是值。

#include<stdio.h>
#include<stdlib.h>
int main()
{int C[3][2][2]={{{2,5},{7,9}},{{3,4},{6,1}},{{0,8},{11,13}}};printf("%d %d %d %d",C,*C,C[0],&C[0][0]);printf("%d\n",*(C[0][0]+1));system("pause");return 0;
}