C语言学习笔记第十章指针

合集下载

C语言程序设计_谭浩强_第二版_CH10

}
第十章指针 10.3 数组的指针和指向数组的指针变量 10.3.2 通过指针引用数组元素例10.5输出数组中的全部元素。 ②通过数组名计算数组中元素的地址，找出元素的值。
main() {
int a[10],i; for(i=0;i<10;i++){scanf(“%d”,&a[i]);} print(“\n”); for(i=0;i<10;i++){printf(“%d”,*(a+i));} print(“\n”);
}
运行结果为： 100,10 100,10
第十章指针 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用例10.1 通过指针变量访问整型变量
pointer_1 &a
a 100 *pointer_1
pointer_2 &b
b 10 *pointer_2
第十章指针 10.2 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用例10.3 通过指针变量访问整型变量
pointer_1 &a
a 5 *pointer_1
pointer_2 &b
b 9 *pointer_2
第十章指针 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用例10.3 通过指针变量访问整型变量
b 5 *pointer_2
&b
第十章指针 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用例10.3 通过指针变量访问整型变量
pointer_1 &a
a 9 *pointer_1

C语言指针的长度和类型详解

C语言指针的长度和类型详解C语言指针的长度和类型详解指针是C语言的精髓，以下是店铺搜索整理的关于C语言指针的长度和类型详解，对于初学者深入理解C语言程序设计有很好的参考价值，有需要的朋友可以参考一下!想了解更多相关信息请持续关注我们店铺!一般来说，如果考虑应用程序的兼容性和可移植性，指针的长度就是一个问题，在大部分现代平台上，数据指针的长度通常是一样的，与指针类型无关，尽管C标准没有规定所有类型指针的长度相同，但是通常实际情况就是这样。

但是函数指针长度可能与数据指针的长度不同。

指针的长度取决于使用的机器和编译器，例如：在现代windows 上，指针是32位或是64位长测试代码如下：#include<stdio.h>#include<math.h>#include<stdlib.h>#include<stddef.h>struct p{int n;float f;};int main(){struct p *sptr;printf("sizeof *char: %d ", sizeof(char*));printf("sizeof *int: %d ", sizeof(int*));printf("sizeof *float: %d ", sizeof(float*));printf("sizeof *double: %d ", sizeof(double*));printf("sizeof *struct: %d ", sizeof(sptr));return 0;}运行结果如下图所示：指针相关的预定义类型：① size_t：用于安全地表示长度② ptrdiff_t：用于处理指针算术运算③ intptr_t：用于存储指针地址④ uintptr_t：用于存储指针地址分述如下：一、size_t类型size_t 类型是标准C库中定义的，应为unsigned int，在64位系统中为long unsigned int。

C语言——指针

4. 结论：若要使变量的值通过函数调用而发生改变，则形参必须是指针型，实参为地址量（&<变量名>）
或指针型。
另：全局变量和数组名作为参数也可改变变量的值.
总结
若要使n个变量的值通过函数调用而发生改变，则
在主调函数中设n个变量，用n个指针变量指向它们。将这些指针变量作为实参，将其地址传递给被调函
p1 p &a p2 &b p1 &b p2 &a
a 5
b 9
a 5 b 9
}
5,9 9,5
三、指针变量作为函数参数前面讲过：数值型变量作为函数实参形参数据值的改变不会影响实参。但当用地址(指针变量)作参数时，作用为传址，与数组名类似。要求：形参、实参均为地址量。
单向传递
形参，于是，
例：实现10.2 swap(int *p1, int *p2) { int temp; temp=p1; p1=p2；p2= temp; } #include <stdio.h> void main( ) { int a, b;
它代表的是地址＋1个单位
重要概念：指针变量也有各种类型(如上面所示)，但指针变量的值只能是整型值。
二、指针变量的引用方式 *指针变量名----表示所指变量的值。指针变量名----表示所指向变量的指针(地址)。
两个运算符号：
&: 取地址运算符。 &i *: 指针运算符，取其指向的内容（所指变量的值）。 *p
9,0,10
10,9,0
§10.3 数组与指针
一个变量的地址为该变量的指针。当用一个变量来存放地址(指针)时，该变量称为指针变量。
一个数组元素相当于一个简单变量。于是，亦可用一个指针变量来指向数组元素。

c语言 ●第10章指针-1

a[1] a[2]
…
19
2.定义时同时赋值
int a[10];
int *p=a; c规定： /* 相当于int *p=&a[0] */
若有 int a[10];
int *p=a; 则 p+1：指向下一个数组元素。
…
p+i：其指向下移i个元素。
20
说明：若有 int a[10]; int *p=a; (1) p+i *(p+i) = &a[i] a[i]= a+i *(a+i) (2)数组的指针变量也可带下标 a[i] ，p[i]， *(a+i)，*(p+i) 是等价的。 (3)a与p的区别：a代表数组a的首地址，是常量。 p=a; p也代表数组a的首地址，是变量。如：p++; 是正确的，而 a++; 是错误的。 (4)引用数组元素有三种方法：下标法： a[i]或p[i] 地址法：＊(a+i) 效率低指针法：＊(p+i) *p++ 效率高
13
讨论：若将被调函数swap( )改为： swap(int *p1,int *p2) ｛int *p; *p=*p1; *p1=*p2; *p2=*p; /*中间变量是指针变量所指的对象*/ ｝ p无确定的地址(地址是随机的)，可能指向任何单元，有可能破坏系统(乱放枪)。加上int c;p=&c;就没有问题了。
3 6 9 …
i j k
2004
3010
2000
i_pointer
3
二.对内存单位的访问存数—写取数—读对内存单位的访问，是通过地址进行的。如： printf(“%d”,i)；读再如：scanf(“%d”,&i); 写直接访问：按变量的地址直接读写变量的值。如：k=i+j; (1)从2000开始的内存单元中取出i的值3. (2)从2002开始的内存单元中取出j的值6. (3)相加后，送入2004开始的内存单元。间接访问：将变量a的地址存入另一变量b中，访问a时，先找b,取出a的地址，再按此地址访问a。

谭浩强版C语言的第十章《指针》答案

谭浩强版C语言的第十章《指针》答案第十章《指针》答案如下inc/testPtr.h#include <string.h>#include <ctype.h>#include <math.h>#include <assert.h>#define SIZE 1024int a2i(char *start, char *end){int size = 0, ret = 0;long base = 0;size = end - start + 1;base = (long)pow(10, size - 1);while(size-- > 0){ret += (*start++ - '0') * base;base /= 10;}return ret;}int extraNum(char *str, int arr[]){int ite = 0, counter = 0;char *start = NULL, *end = NULL;while(*str != '\0'){if(isdigit(*str)){start = end = str;while( isdigit(*end) && *end != '\0'){++end;}arr[ite++] = a2i(start, end-1);str = end;}else{str++;}}return ite;}int sortStr(char *arr[], int size){int ite1 = 0, ite2 = 0, minPos = 0;char *tmp;for(ite1 = 0; ite1 < size - 1; ite1++){minPos = ite1;for(ite2 = ite1 + 1; ite2 < size; ++ite2 ){if( strcmp(arr[ite2], arr[minPos]) < 0 ){minPos = ite2;}}if(minPos != ite1){tmp = arr[minPos];arr[minPos] = arr[ite1];arr[ite1] = tmp;}}return 0;}int sort(int arr[], int size){int minPos = 0, ite1 = 0, ite2 = 0, tmp = 0;for(ite1 = 0; ite1 < size - 1; ite1++){minPos = ite1;for(ite2 = ite1 + 1; ite2 < size; ite2++){if( arr[ite2] < arr[minPos] ){minPos = ite2;}}if(minPos != ite1){tmp = arr[ite1];arr[ite1] = arr[minPos];arr[minPos] = tmp;}}return 0;}int sortPtr(int arr[], int size){int minPos = 0, ite1 = 0, ite2 = 0, tmp = 0;for(ite1 = 0; ite1 < size - 1; ite1++){minPos = ite1;for(ite2 = ite1 + 1; ite2 < size; ite2++){if( *(arr + ite2) < *(arr + minPos) ){minPos = ite2;}}if(minPos != ite1){tmp = *(arr + ite1);*(arr + ite1) = *(arr + minPos);*(arr + minPos) = tmp;}}return 0;}int getMultiArr(int arr[][5], int n){int i = 0, j = 0, min = 0, tmp = 0, size = 5 * n;int *p = NULL, pos[size];/* copy */p = (int *)malloc(size * sizeof(int));assert(p != NULL);memcpy(p, arr, size * sizeof(int));/* sort */for(i = 0; i < size - 1; i++){min = i;for(j = i + 1; j < size; j++){if( *(p + j) < *(p + min)){min = j;}}if(min != i){tmp = *(p + min);*(p + min) = *(p + i);*(p + i) = tmp;}}/* move */for(i = 0; i < n; i++){for(j = 0; j < 5; j++){if( *p == arr[i][j] ){tmp = arr[i][j];arr[i][j] = arr[0][0];arr[0][0] = tmp;continue;}if( *(p + 1) == arr[i][j] ){tmp = arr[i][j];arr[i][j] = arr[0][4];arr[0][4] = tmp;continue;}if( *(p + 2) == arr[i][j] ){tmp = arr[i][j];arr[i][j] = arr[n - 1][0];arr[n - 1][0] = tmp;continue;}if( *(p + 3) == arr[i][j] ){tmp = arr[i][j];arr[i][j] = arr[n - 1][4];arr[n - 1][4] = tmp;continue;}if( *(p + size - 1) == arr[i][j] ){tmp = arr[i][j];arr[i][j] = arr[n/2][2];arr[n/2][2] = tmp;continue;}}}free(p);p = NULL;return 0;}int statStr(char *str){int upper = 0, lower = 0, space = 0, num = 0, other = 0;while(*str != '\0'){if(isdigit(*str)){num++;}else if (isupper(*str)){upper++;}else if (islower(*str)){lower++;}else if (isspace(*str)){space++;}else{other++;}str++;}assert(3 == upper);assert(5 == lower);assert(10 == num);assert(2 == space);assert(6 == other);return 0;}int average(int(*stu)[6], int classNum, int stuNum){int i = 0, ave = 0;for(i = 0; i < stuNum; i++){ave += (*(stu + i))[classNum];}ave /= stuNum;return ave;}int searchStu(int(*stu)[6], int stuNum){int counter = 0, i = 0, j = 1, stuCounter = 0;for (i = 0; i < stuNum; i++){counter =0;for(j = 1; j < 6; j++){if( (*(stu + i))[j] < 60 ){counter++;}}if(counter >= 2){stuCounter++;}}return stuCounter;}int moveInt(int arr[], int n, int m){int i = 0, *p = NULL;p = (int*)malloc(n * sizeof(int));assert(p != NULL);memcpy(p + m, arr, (n - m) * sizeof(int));memcpy(p, arr + n -m , m * sizeof(int));memcpy(arr, p, n * sizeof(int));free(p);p = NULL;return 0;}int myStrcmp(char *p1, char*p2){int ret = 0;while((*p1 != '\0') && (*p2 != '\0') && ( *p1 == *p2 ) ) {p1++;p2++;}if(*p1 == '\0'){ret = -1;}else if (*p2 == '\0'){ret = 1;}else{ret = (*p1 - *p2) > 0 ? 1 : -1;}return ret;}int revArr(int a[], int size){int tmp = 0, *start = NULL, *end = NULL;start = a;end = start + size - 1;size = size / 2;while(size >= 0){tmp = *(start + size);*(start + size) = *(end - size);*(end - size) = tmp;size--;}return 0;}char *getMonth(char *month[], int which) {assert(which <= 12);return ( *(month + which - 1));}int getStr(char *dest, char* src, int m) {int len = 0;len = strlen(src) + 1 - m;src = src + m - 1;memcpy(dest, src, len * sizeof(char));return 0;}int removePer3(int arr[], int size){int i = 0;for(i = 0; i < size; i++){if(((arr[i]) % 3) == 0){arr[i] = 0;}}return 0;}int getMinMax(int a[], int size){int i = 0, min = 0, max = 0, tmp = 0;min = max = 0;for(i = 0; i < size; i++){if (a[i] <= a[min]){min = i;}if(a[i] >= a[max]){max = i;}}tmp = a[0];a[0] = a[min];a[min] = tmp;tmp = a[size - 1];a[size - 1] = a[max];a[max] = tmp;}int test_10_1(){int ite = 0, iRet = 0, arr[5] = {121, 234, 456456, 543, 23};iRet = sortPtr(arr, 5);assert (23 == arr[0]);assert (121 == arr[1]);assert (234 == arr[2]);assert (543 == arr[3]);assert (456456 == arr[4]);printf("\r\nTest_10_1 Passed!");return 0;}int test_10_2(){int ite = 0, iRet = 0;char *arr[10] = { "In the IBM Rational ClearCase environment", \"An auditable history of source files and software builds is maintained in your organization", \"The efforts of your team can be coordinated into a definable"};iRet = sortStr(arr, 3);assert( strcmp(arr[0], "An auditable history of source files and software builds is maintained in your organization") == 0 );assert( strcmp(arr[1], "In the IBM Rational ClearCase environment") == 0);assert( strcmp(arr[2], "The efforts of your team can be coordinated into a definable") == 0);printf("\r\nTest_10_2 Passed!");return 0;}int test_10_3(){int ret = 0, a[10] = {7,2,3,9,1,0,7,6,5,0};ret = getMinMax(a, 10);assert(a[0] == 0);assert(a[9] == 9);printf("\r\nTest_10_3 Passed!");return 0;}int test_10_4(){int ret = 0, arr[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};ret = moveInt(arr, 9, 3);assert(6 == arr[0]);assert(7 == arr[1]);assert(8 == arr[2]);assert(0 == arr[3]);assert(1 == arr[4]);assert(2 == arr[5]);assert(3 == arr[6]);assert(4 == arr[7]);assert(5 == arr[8]);printf("\r\nTest_10_4 Passed!");return 0;}int test_10_5(){int ret = 0, i = 0, a[12] = {1,2,3,4,5,6,7,8,9,10,11,12};ret = removePer3(a, 12);assert(a[2] == 0);assert(a[5] == 0);assert(a[8] == 0);assert(a[11] == 0);printf("\r\nTest_10_5 Passed!");return 0;}int test_10_7(){int ret = 0;char s2[100] = {0}, *s1 = "hello world!";getStr(s2, s1, 7);assert( strcmp(s2, "world!") == 0);printf("\r\nTest_10_7 Passed!");return 0;}int test_10_8(){int ret = 0;char *str = "a123xABC ??#$%^ 302tab5876";ret = statStr(str);if(ret == 0){printf("\r\nTest_10_8 Passed!");}return 0;}int test_10_10(){int i = 0, j = 0, ret = 0;int arr[5][5] = { \{16, 17, 18, 19, 20}, \{11, 12, 13, 14, 15}, \{1, 2, 3, 4, 5}, \{21, 22, 23, 24, 25}, \{6, 7, 8, 9, 10}, \};ret = getMultiArr(arr, 5);assert(1 == arr[0][0] );assert(2 == arr[0][4] );assert(3 == arr[4][0] );assert(4 == arr[4][4] );assert(25 == arr[2][2] );printf("\r\nTest_10_10 Passed!");return 0;}int test_10_11(){int ite = 0, iRet = 0;char *arr[10] = { "In the", \"An aud", \"The ef", \"Proces", \"Sets o", \"Unifie", \"Out-of", \"Practi", \"Ration", \"Explor" \};iRet = sortStr(arr, 10);assert( strcmp(arr[0], "An aud") == 0 );assert( strcmp(arr[1], "Explor") == 0);assert( strcmp(arr[2], "In the") == 0);assert( strcmp(arr[3], "Out-of") == 0);assert( strcmp(arr[4], "Practi") == 0);assert( strcmp(arr[5], "Proces") == 0);assert( strcmp(arr[6], "Ration") == 0);assert( strcmp(arr[7], "Sets o") == 0);assert( strcmp(arr[8], "The ef") == 0);assert( strcmp(arr[9], "Unifie") == 0);printf("\r\nTest_10_11 Passed!");return 0;}int test_10_12(){int ite = 0, iRet = 0;char *arr[10] = { "In the IBM Rational ClearCase environment", \"An auditable history of source files and software builds is maintained in your organization", \"The efforts of your team can be coordinated into a definable", \"Process by using one of the following", \"Sets of Rational ClearCase features", \"Unified Change Management (UCM),", \"Out-of-the-box process that supports best", \"Practices for change management as described in the IBM", \"Rational Unified Process. Project managers can configure", \"Explorer. For more information about Rational ClearCase"};iRet = sortStr(arr, 10);assert( strcmp(arr[0], "An auditable history of source files and software builds is maintained in your organization") == 0 );assert( strcmp(arr[1], "Explorer. For more information about Rational ClearCase") == 0);assert( strcmp(arr[2], "In the IBM Rational ClearCase environment") == 0);assert( strcmp(arr[3], "Out-of-the-box process that supports best") == 0);assert( strcmp(arr[4], "Practices for change management as described in the IBM") == 0);assert( strcmp(arr[5], "Process by using one of the following") == 0);assert( strcmp(arr[6], "Rational Unified Process. Project managers can configure") == 0);assert( strcmp(arr[7], "Sets of Rational ClearCase features") == 0);assert( strcmp(arr[8], "The efforts of your team can be coordinated into a definable") == 0);assert( strcmp(arr[9], "Unified Change Management (UCM),") == 0);printf("\r\nTest_10_12 Passed!");return 0;}int test_10_14(){int ret = 0, a[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};ret = revArr(a, 11);assert(10 == a[0]);assert(9 == a[1]);assert(8 == a[2]);assert(7 == a[3]);assert(6 == a[4]);assert(5 == a[5]);assert(4 == a[6]);assert(3 == a[7]);assert(2 == a[8]);assert(1 == a[9]);assert(0 == a[10]);printf("\r\nTest_10_14 Passed!");return 0;}int test_10_15(){int ave = 0, ret = 0;int student[4][6] = { \{1, 100, 90, 80, 70, 97}, \{2, 34, 45, 56, 78, 97}, \{3, 76, 34, 68, 84, 12}, \{4, 90, 90, 90, 75, 28} \};ave = average(student, 1, 4);ret = searchStu(student, 4);assert(75 == ave);assert(2 == ret);printf("\r\nTest_10_15 Passed!");return 0;}int test_10_16(){int iRet = 0, ite = 0, arr[SIZE] = {0};char *str = "a123x456 17960? 302tab5876";iRet = extraNum(str, arr);assert(123 == arr[0]);assert(456 == arr[1]);assert(17960 == arr[2]);assert(302 == arr[3]);assert(5876 == arr[4]);printf("\r\nTest_10_16 Passed!");return 0;}int test_10_17(){int ret = 0;char *s1 = "abcd", *s2 = "abCd";ret = myStrcmp(s1, s2);assert(ret == 1);char *s3 = "aBcd", *s4 = "abCd";ret = myStrcmp(s3, s4);assert(ret == -1);char *s5 = "abcde", *s6 = "abcd";ret = myStrcmp(s5, s6);assert(ret == 1);char *s7 = "abcd", *s8 = "abcde";ret = myStrcmp(s7, s8);assert(ret == -1);char *s9 = "abcd", *s10 = "abCde";ret = myStrcmp(s9, s10);assert(ret == 1);printf("\r\nTest_10_17 Passed!");return 0;}int test_10_18(){int which = 0;char *month[12] = { \"January", \"February", \"March", \"April", \"May", \"June", \"July", \"August", \"September", \"October", \"November", \"December" \};which = 11;assert( strcmp("November", getMonth(month, which)) == 0 );which = 7;assert( strcmp("July", getMonth(month, which)) == 0 );printf("\r\nTest_10_18 Passed!");return 0;}int test_10_20(){int ite = 0, iRet = 0;char *arr[5] = { "In the IBM Rational ClearCase environment", \"An auditable history of source files and software builds is maintained in your organization", \"The efforts of your team can be coordinated into a definable", \"Process by using one of the following", \"Sets of Rational ClearCase features" \};iRet = sortStr(arr, 5);assert( strcmp(arr[0], "An auditable history of source files and software builds is maintained in your organization") == 0 );assert( strcmp(arr[1], "In the IBM Rational ClearCase environment") == 0);assert( strcmp(arr[2], "Process by using one of the following") == 0);assert( strcmp(arr[3], "Sets of Rational ClearCase features") == 0);assert( strcmp(arr[4], "The efforts of your team can be coordinated into a definable") == 0);printf("\r\nTest_10_20 Passed!");return 0;}int test_10_21(){int ite = 0, iRet = 0, arr[5] = {121, 234, 456456, 543, 23};iRet = sort(arr, 5);assert (23 == arr[0]);assert (121 == arr[1]);assert (234 == arr[2]);assert (543 == arr[3]);assert (456456 == arr[4]);printf("\r\nTest_10_21 Passed!");return 0;}int testPtr(){int iRet = 0;#if 0#endifiRet += test_10_1();iRet += test_10_2();iRet += test_10_3();iRet += test_10_4();iRet += test_10_5();iRet += test_10_7();iRet += test_10_8();iRet += test_10_10();iRet += test_10_11();iRet += test_10_12();iRet += test_10_14();iRet += test_10_15();iRet += test_10_16();iRet += test_10_17();iRet += test_10_18();iRet += test_10_20();iRet += test_10_21();return iRet;}src/#include <stdio.h>#include <stdlib.h>#include <assert.h>#include "../inc/testFile.h" #include "../inc/testBits.h" #include "../inc/testPtr.h"int main(){int iRet = 0;#if 0iRet += testFile();assert(iRet == 0);iRet += testBits();assert(iRet == 0);#endifiRet += testPtr();assert(iRet == 0);return 0;}。

c语言第10章指针

3.间接引用指针
间接引用指针时，可获得由该指针变量所指向的变量内容。
例如，int i=10,*ip=&i;
ip
i
cout<<*ip<<endl;
0000:F384 0000:F384 210
运行结果为：10 即指针ip所指向的变量i的内容。
*放在定义过的指针变量之前，称为间接引用操作符； *放在指针变量定义中时，称为指针定义符。非指针变量不能用间接引用操作符，*只能作用于地址。
例如， double d=1.23,*dp; char c,*cp;
在&和cp*=作&d用; 下，对变量d和dp有如下6种操作：其d，中d，dpp，=*&d*是cd; ，非*法dp的，；&&d指，dp针&是只d指p能。针指的向地与址其即同二类级型指的针量。另外，指针除了可指向所有基本类型的变量外，指针也可指向常量、数组、数组元素、函数、指针以及文件等。
int ii=n1t0;b, a[10]; int *inpt=&*pi;1,//*初p2始; 化为整型变量的地址，但 *ip=p&1=i;&//是b;错误的
注意：p2不=p要1将; “//可in以t *将ip=一&个i;”已与赋“值*i的p=指&i针;”混赋淆给。另一个相同类型的指针前者是p2定=&义a语[5句];，*是指针定义符，系统为指针变量ip分配一个空间，并2、用i数的地组址的值地初址始值化；可后用者该是数执组行语的句数，组左名右表两边示类。型例不如匹：配。指例3、针如变，ip函n=d*d量t数bodob;up在u的b=b[3使ll6ee].地8[用*d;4d=址]前/p2,/!(;.，*5值;p一)由[定4该]要; 函被数$赋$$以的d$:p一$名$个$字$地来址表值$$$，示$:否$。$$则$例是如很#6某#：危.#8变险量的。没有被do赋ub值le的s指in针(d变ou量bdlep的x值);是一个随机地址，把6.8赋给内存中的随机位do置ub，le很(可*p能f)破( 坏); 了另一个变量，甚至修改了栈中的函数返回地址，pf造=s成in计; 算机死机或进入死循环。

c语言指针教学中的知识点分析与总结

c语言指针教学中的知识点分析与总结c语言指针教学中的知识点分析与总结本文对c语言指针的教学进行了探讨和总结。

要想真正的掌握c 语言的指针，首先必须要对它有全面深刻的认识。

因为它是c语言的基础，只有将指针的知识学好，才能够更好地学习后续的课程。

下面小编给大家介绍一下关于c语言指针的知识。

一、 c语言中指针的定义指针是一种特殊的数据类型，也称为引用类型。

所谓指针就是指向一个地址的变量，例如： int a[10];二、变量指针及指针变量1.1 c语言中的变量。

变量是存储在计算机中的二进制数值，当我们需要使用时，必须创建一个变量并赋予它相应的值，然后将变量的地址传递给外部的一个或多个对象，这样外部对象通过访问内部变量来使用其中存储的信息，而且可以保证外部对象不会越界。

1.2指针变量是变量的一种特殊形式，指针变量在内存中占有一块区域，可以指向一个地址，这个地址的值是这个变量所代表的值，这样方便变量间的传递。

例如： char *a[10];2.1指针操作符2.2指针数组，它的作用和一维数组相同，即具有一维数组的特点，也具有二维数组的特点，三者最明显的区别就是二维数组中元素个数是固定的，而一维数组中元素个数是可变的。

2.3指针的运算规则。

在指针变量的操作中，要遵循以下运算规则：原地址→指针地址。

例如： char * a[10]; 2.4 c语言中的const指针常量是一种特殊的指针常量， const不是一种变量的标准类型，它专门用于指向一个const指针。

2.3指针的运算规则。

在指针变量的操作中，要遵循以下运算规则：原地址→指针地址。

例如： char *a[10];2.4指针的定义与使用：所谓指针就是指向一个地址的变量，例如： int a[10]; 2.4指针的定义与使用： pointer， pointer-pointer，and-and-and。

所以，当我们在一个字符串中出现pointer，pointer-pointer， and-and-and的时候，就表示它指向一个地址。

C语言指针详解

C语言指针详解1 程序如何运行当我们打开电脑中的任何一个程序运行时，我们的操作系统会将该程序存在硬盘的所有数据装载到内存中，然后有CPU 进行读取内存中的数据并进行计算，并将计算的结果返回给我们的操作系统，然后操作系统将相应的动作交付给相应的硬件来完成。

如：将声音数据交给声卡，最后有音响输出来，将图像交给显卡最后有显示器输出……但是还会有一部分数据会返回给内存，以供程序下面的语句继续使用。

我们都知道内存的容量有很大，如：4G，8G, 16G，有时候我们会打开很多的程序，所有的程序的数据都存放到我们的内存中，那么CPU是如何正确的读取我们的不同程序的数据并加以计算的哪？2 内存的假设设计为了让我们的CPU 可以很好的读取内存中的数据，内存必须做优化设计，于是给内存设定了集合设计，将我们的内存分成很多大小相同的方格（盒子），所有的数据将放入这些小盒子中，将不同的程序的数据放入到不同的小盒子中，这样就出现的模块化的内存，当我执行程序的一个命令时，CPU就会从相应的盒子读数据然后计算，由于我们硬件所能访问或计算的最小单位是字节，所以内存中的这样的一个小盒子的大小就给他规定一个字节。

3 地址和指针一般我们声明一块内存空间的时候，会给他取一个名字，为的是我们在编写程序的时候方便使用空间中存放的值，但是CPU 读数据的时候会忽视这个名字，因为CPU无法理解这样的数据，CPU 只能执行0,1代码，那么CPU是如何知道从什么地方读取数据，又到什么地方地址数据的读取的那，所以必须对内存做2次设计，就是将内存中分成的很多小盒子下面标注一些顺序的序号，例如：从第一个盒子开始，标注1,2,3,4,5,6,7，……每一个数字对应一个盒子，但是真正的内存如中不是使用这些十进制数字的，而是使用16进制整数表示的，如0x16ffee。

这些我们标记的数字就叫做内存中的地址。

由于这些地址和盒子是对应的关系，所以只要知道了地址，就可以得到对应盒子中存放的数据了，形象的说，我们说这个地址指向对应的盒子，在C语言中可以通过地址得到对应盒子的数据是*地址。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

2、指针变量量的赋值：&取地址
如：int *p;int i;p=&i;
ﬂoat a,*p;p=&a;
说明：赋予指针变量量地址的变量量类型应与指针变量量基类型一一致。不不同类型地址字节不不同
3、指针变量量的定义初始化：如char c=‘F’,*t=&c;或者int a,*p=&a;
int a,*p;*p=a;这是错误用用法
表示形式 a[1]+2…*(a+1)+2…&a[1][2] *(a[1]+2)…*(*(a+1)+2)…a[1][2] a[0]…*(a+0)…*a a[1]…*(a+1) *a+1 含义 1行行行2列列元素a[1][2]的地址 1行行行2列列元素a[1][2]的值 0行行行0列列元素地址 1行行行0列列元素地址 0行行行1列列元素地址
4、空指针：int *p=NULL;或int *p=0;
说明：（1）指针变量量初始化时等号右边不不能是直接给出的具体地址，地址是0除外
（2）空指针无无具体的内存单元，不不能被引用用，也没有存地址（实际为了了后期使用用）
5、指针变量量的引用用：&取地址 *取内容
如：&a为a的地址，*p为指针变量量p指向存储单元的内容
{int i,s=0;for(i=0;i<n;i+=2)s+=b[i];return s;}
main(){int a[]={1,2,3,4,5},s;s=fun(a,5);printf(“%d”,s);}
输出结果：9
四、二二维数组与指针
1、二二维数组的地址：如int a[3][4],a是二二维数组名，即二二维数组的首首地址，第0行行行的地址
main()
{int a=3,b=5;fun(&a,&b)；printf(“%d,%d\n”,a,b);
输出结果：3,5
三、指针变量量与一一维数组
1、数组元素指针的定义和定义初始化
（1）int a[10];int *p;p=&a[0];
（2）int a[10],*p；p=a;
（3）int a[10],*p=&a[0];
2、数组指针：int(*p)[4];…定义一一个指针变量量
如int a[3][4];int (*p)[4];p=a;
*(*(p+1)+2)等价于a[1][2]
六、函数指针与指针函数
1、函数指针：int(*p)()；
说明：p是返回为整型函数的指针。
2、指针函数：int *p()
说明：p是返回值为整型地址的函数。
说明：*与自自增自自减运算符同级且自自右向左结合
3、用用数组名做函数参数
情况（1）：数组元素作实参，形参是变量量……值传递
情况（2）：数组元素地址作实参，形参是指针变量量……地址传递
情况（3）：数组名作实参，形参是指针变量量……地址传递
例例题：int fun（int b[],int n）//相当于int fun（int *b，int n）
{*x+=*y；
*y+=*x;}
main()
{int a=3,b=5；fun(&a，&b)；
printf(“%d,%d”,a,b);}
输出结果：8,13
说明：指针类型的形参接收实参的地址
例例题2:void fun（int *x,int *y）
{int t；t=*x;*x=*y;*y=t;}
（4）int a[10],*p=a;
即a为第0个元素a[0]的地址，a等价于&a[0]，a是一一个地址常量量，通常习惯叫做数组首首元素地址
数组名就是首首元素地址
2、通过地址引用用数组元素
例例题1:int a[]={2,14,26,38,40},*p,*q;p=a;q=p+1;
printf(“%d,%d,%d,%d\n”,*p,*(p+2),*p+2,*q+4);
int m,s;p=&a[0][0];
m=(*p)*(*(p+2))*(*(p+4));
s=p[1]+p[3]+p[5];
m的值为15，s的值为12。
五、指针数组与数组指针
1、指针数组：一一组存放地址数据的数组，类型名 *数组名[数组⻓长度]。
如int *p[3];里里里边有p[0],p[1],p[2]三个内存单元可存int型指针
printf(“%d,%d”,p[3],q[3]);
输出结果：
2,26,4,18
38,40
（说明：[]即变址运算符，
例例题2:int a[]={5,10,15,20,25},*b=a;
printf(“%d ”,*p++);printf(“%d,%d”,*++p,++*p);
输出结果：5 15,16
例例题：int a[2][3]={1,2,3,4,5,6}；
*(*(a+1)+2)=6
*(*a+1)=2
*(a[0]+2)=3
*(a[1]+1)=5
2、指向二二维数组的指针变量量：二二维数组在内存中先行行行后列列存储
0 0 1 1 4 1 2 5 2 3 6
例例题：int a[2][3]={1,2,3,4,5,6};int *p；
例例题1:int a=3,b,*p;p=&a;b=*p+2;
printf(“%d,%d\n”,a,b);
输出结果：3,5
例例题2:int a=3,b=5,c,*p,*q;p=&a;q=&b；
c=*p**q;printf(“%d”,c);
输出结果：15
6、指针变量量作为函数参数
例例题：void fun(int *x，int*y)……双向传递
main()
{int a=3,b=5;fun(&a，&b);printf(“%d,%d\n”,a,b);
输出结果：5,3
说明：交换算法最好使用用int t交换，若是*t则可能*t指向是重要内容
例例题3:void fun(int *x，int *y)
{int *t;t=x;x=y;y=t;}
一一、地址与指针
1、指针：一一个变量量的地址称为该变量量的指针
2、指针变量量：专⻔门存储地址的变量量
3、访问变量量的方方式：直接访问和间接访问
2000<—地址 a<—标识符 5 p 2000 5 *p a
2000
二二、指针变量量
1、指针变量量的定义：基类型 *指针变量量名；
如：ﬂoat *pointer;char *p;int *q