指針是什么？

i_pointer=&i;//將i的地址放到i_pointer

指針變量就是地址變量，用來存放地址，指針變量的值是地址（即指針）

專注于為中小企業(yè)提供網(wǎng)站設(shè)計、做網(wǎng)站服務(wù),電腦端+手機端+微信端的三站合一,更高效的管理,為中小企業(yè)濟陽免費做網(wǎng)站提供優(yōu)質(zhì)的服務(wù)。我們立足成都，凝聚了一批互聯(lián)網(wǎng)行業(yè)人才，有力地推動了千余家企業(yè)的穩(wěn)健成長，幫助中小企業(yè)通過網(wǎng)站建設(shè)實現(xiàn)規(guī)模擴充和轉(zhuǎn)變。

指針是一個地址，指針變量是存放地址的變量

指針變量 指針變量的定義

指針變量的一般形式：

類型名 * 指針變量名

int * pointer_1,*pointer_2;

指針變量前面的”*“表示該變量的類型為指針型變量

int型使“指針加1”意味著使地址值加4個字節(jié)，char使“指針加1”意味著使地址加1個字節(jié)

一個變量的指針的含義包括兩個方面，一是以存儲單元編號表示的地址（如編號為2000的字節(jié)），一是它指向的存儲單元的數(shù)據(jù)類型（如int，char，float等）

指針整型數(shù)據(jù)的指針類型表示為“ int* ”，讀作指向int的指針或簡稱int指針

指針變量中只能存放地址（指針），不要將一個整型賦給一個指針變量

*pointer_1=100;//pointer_1是指針變量，100是整數(shù)，不合法

指針變量的引用 給指針變量賦值

p=&a//把a的地址賦給指針變量p

指針變量p的值是變量a的地址，p指向a

引用指針變量指向的變量

p=&a;
printf("%d",*p);

其作用是以整數(shù)形式輸出指針變量p所指向的變量的值，即變量a的值

*p=1;

表示將整數(shù)1賦給p當(dāng)前所指向的變量，如果p指向變量a，則相當(dāng)于把1賦給a，即a=1

引用指針變量的值

printf("%o",p);

作用是以八進制形式輸出指針變量p的值，如果p指向了a，就輸出了a的地址，即&a

&	取地址運算符。&a是變量a的地址
*	指針運算符（或稱“間接訪問”運算符），*p代表指針變量p指向的對象

指針變量做函數(shù)參數(shù)

作用：將一個變量的地址傳送到另一個函數(shù)中

函數(shù)的調(diào)用可以（而且只可以）得到一個返回值（即函數(shù)值），而使用指針變量作參數(shù)，可以得到多個變化了的值，如果不用指針變量是難以做到這一點的

通過指針引用數(shù)組 數(shù)組元素的指針

一個數(shù)組包含若干元素，每個數(shù)組元素都在內(nèi)存中占用存儲單元，它們都有相應(yīng)的地址。所謂數(shù)組元素的指針就是數(shù)組元素的地址

int a[10]={1,3,5,7,9,11,13,15,17,19};//定義a為包含10個整形數(shù)據(jù)的數(shù)組
int *p;//定義p為指向整形變量的指針變量
p=&a[0];//把a[0]元素的地址賦給指針變量p

數(shù)組名代表數(shù)組中首元素（即序號為0的元素）的地址

p=&a[0];//p的值是a[0]的地址
p=a;//p的值是數(shù)組a首元素（即a[0]）的地址

注意：數(shù)組名不代表整個數(shù)組，只代表數(shù)組首元素的地址

在引用數(shù)組元素時指針的運算

在指針指向數(shù)組元素時，可以對指針進行以下運算：

加一個整數(shù)（用+或+=），如p+1

減一個整數(shù)（用-或-=），，如p-1

自加運算，如p++，++p

自減運算，如p- -，- -p

兩個指針相減，如p1-p2（只有p1和p2都是指向同一個數(shù)組中的元素才有意義）

如果指針變量p已指向數(shù)組中的一個元素，則p+1指向同一數(shù)組中的下一個元素，p-1指向同一數(shù)組中的上一個元素

p+1所代表的地址實際是（p+1）*d，d是一個數(shù)組元素所占的字節(jié)數(shù)

若p的值是2000，則p+1的值是2004

通過指針引用數(shù)組元素

下標(biāo)法：如a[i]形式；

指針法：如*（a+1）或 *（p+1），其中a是數(shù)組名，p是指向數(shù)組元素的指針變量，其初值p=a

下標(biāo)法

#includeint main()
{int a[10];
	int i;
	printf("please enter 10 integer numbers:");
	for (i = 0; i< 10; i++)
		scanf("%d", &a[i]);
	for (i = 0; i< 10; i++)
		printf("%d ", a[i]);
	printf("\n");
	return 0;
}

運行結(jié)果：

please enter 10 integer numbers:1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

通過數(shù)組名計算數(shù)組元素地址，找出元素的值

#includeint main()
{int a[10];
	int i;
	printf("please enter 10 integer numbers:");
	for (i = 0; i< 10; i++)
		scanf("%d", &a[i]);//&a[i]表示a[i]元素的地址，也可以改用（a+i）表示，即scanf（"%d",a+i);
	for (i = 0; i< 10; i++)
		printf("%d ", *(a + i));
	printf("\n");
	return 0;
}

運行結(jié)果：

please enter 10 integer numbers:1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

用指針變量指出數(shù)組元素

#includeint main()
{int i,a[10],*p=a;
	printf("please enter ten integer numbers:");
	for (i = 0; i< 10; i++)
		scanf("%d", p++);
	p = a;
	for (i = 0; i< 10; i++)
		printf("%d ", *p++);
	printf("\n");
	return 0;
}

運行結(jié)果：

please enter 10 integer numbers:1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

p++；//p++使p指向下一元素a[1]
*p；//得到下一個元素a[1]的值

*p++；//++和*優(yōu)先級，結(jié)合方向為自右而左，因此它等價于*(p++),先引用p的值，實現(xiàn)*p的運算，然后再使p自增1
*(p++)//先取*p值，然后使p加1
*(++p)//先使p加1，再取*p
++(*p)//表示p所指的元素加1

用數(shù)組名作函數(shù)參數(shù)

int main()
{void fun(int arr[],int n);//對fun函數(shù)的聲明
	int array[10];//定義array數(shù)組
	fun(array,10);//用數(shù)組名作函數(shù)的參數(shù)
	return 0;
}

void fun(int arr[],int n)//定義fun函數(shù) 等價于void fun(int *arr,int n)
{}

array是實參數(shù)組名，arr為形參數(shù)組名

sizeof(數(shù)組名)，計算整個數(shù)組的大小，sizeof內(nèi)部單獨放一個數(shù)組名，數(shù)組名表示整個數(shù)組。

&數(shù)組名，取出的是數(shù)組的地址。&數(shù)組名，數(shù)組名表示整個數(shù)組。

*(arr+i)等價于arr[i]

代表數(shù)組array序號為0的元素

arr[0]
*arr
array[0]

以變量名和數(shù)組名作為函數(shù)參數(shù)的比較

傳遞的信息	變量的值	實參數(shù)組首元素的地址
實參類型	變量名	數(shù)組名
要求形參的類型	變量名	數(shù)組名或指針變量
通過函數(shù)調(diào)用能否該該改變實參的值	不能改變實參變量的值	能改變實參變量的值

void fun(arr[],int n)
{printf("%d\n",*arr);//輸出array[0]的值
	arr=arr+3;//形參數(shù)組名可以被賦值
	printf("%d\n",*arr);//輸出array[3]的值
}

形參和實參都用數(shù)組名

int f(int x[],int n)//形參數(shù)組名x接受了實參數(shù)組首元素a[0]的地址，形參數(shù)組和實參數(shù)組共用一段內(nèi)存單元
{}
int main()
{int a[10];
	f(a,10);
}

實參用數(shù)組名，形參用指針變量

void f(int *x,int n)//形參x為int*型的指針類型
{}
int main()
{int a[10];//實參a為數(shù)組名
	f(a,10);
}
//調(diào)用函數(shù)開始后，形參x指向a[0]，即x=&a[0]，通過x值的改變，可以指向a數(shù)組的任一元素

實參形參都用指針變量

void f(int *x,int n)//形參x是int*型的指針變量
{}
int main()
{int a[10],*p=a;
	f(p,10);//實參p是int*型的指針變量
}
//先使實參指針變量p指向數(shù)組a[0]，p的值是&a[0],然后將p的值傳給指針變量x，x的初始值也是&a[0]
//通過x值的改變可以使x指向數(shù)組a的任一元素

實參為指針變量，形參為數(shù)組名

void f(int x[],int n)//形參為數(shù)組名x,編譯系統(tǒng)把x作為指針變量處理，將a[0]的地址傳給形參x，使x也指向a[0]
{}
int main()
{int a[10],*p=a;
	f(p,10);//實參p為指針變量，他指向a[0]
}
//形參數(shù)組x和a數(shù)組共用同一段內(nèi)存單元
//在函數(shù)執(zhí)行過程中可以使x[i]的值發(fā)生改變，而x[i]就是a[i],這樣main函數(shù)可以使用變化了的數(shù)組元素值

通過指針引用多維數(shù)組 多維數(shù)組元素的地址

指針變量可以指向一維數(shù)組中的元素，也可以指向多維數(shù)組中的元素

定義一個二維數(shù)組a，它有3行4列

int a[3][4]={{1,2,5,7},{9,11,13,15},{17,19,21,23}};

a是二維數(shù)組名，a數(shù)組包含3行，即3行個元素:

a[0];
 a[1];
 a[2];

每一個行元素又是一個一維數(shù)組，它包括4個元素。

例如：a[0]所代表的一維數(shù)組又包含4個元素

a[0][0];
a[0][1];
a[0][2];
a[0][3];

可以認(rèn)為二維數(shù)組是“數(shù)組的數(shù)組”，即二維數(shù)組a是由3個一維數(shù)組所組成的

從二維數(shù)組的角度來看，a代表二維數(shù)組首元素的地址，現(xiàn)在的首元素是一個由4個整型元所組成的一維數(shù)組，因此a所代表的是首行（序號為0的行）的首地址。a+1代表序號為1的行的首地址。如果二維數(shù)組的首行的地址是2000，一個整型數(shù)據(jù)占4個字節(jié)，則a+1的值應(yīng)該是2000+4*4=2016（因為第0行有4個整型數(shù)據(jù)），a+1指向a[1]，或者說，a+1的值是a[1]的首地址，a[2]代表a[2]的首地址，他的值是2032

a[0]是一維數(shù)組名，該一維數(shù)組中序號為1的元素的地址用a[0]+1來表示

a[0]+1中的1代表1個列元素的字節(jié)數(shù)，即4個字節(jié)，a[0]的值是2000，a[0]+1的值是2004，

a[0]+0  ==  a[0][0]
a[0]+1  ==  a[0][1]
a[0]+2  ==  a[0][2]
a[0]+3  ==  a[0][3]

a[0] [3]元素的地址

&a[0][0];
&a[0][1];
&a[0][2];
&a[0][3];

a[0] [1]的值用地址法的表示方法

*(a[0]+1)是a[0][1]的值
*a(*(a+0)+1)或*(*a+1)是a[0][1]的值

*(a[i]+j)或*(*(a+i)+j)是a[i][j]的值
*(a+i)和a[i]是等價的

a[i]從形式上看是a數(shù)組中序號為i的元素，如果a是一維數(shù)組名，則a[i]表示a數(shù)組序號為i的元素的存儲單元。a[i]是有物理地址的，是占存儲單元的。但如果a是二維數(shù)組，則a[i]是一維數(shù)組名，它只是一個地址，并不代表某一元素的值（如同一維數(shù)組名只是一個指針變量一樣）。a，a+i， a[i], *(a+i),(a+i)+j, a[i]+j;都是地址，而*(a[i]+j)和 *( * (a+i)+j)是二維數(shù)組元素a[i] [j]的值

二維數(shù)組a的有關(guān)指針

表示形式	含義	地址
a	二維數(shù)組名，指向一維數(shù)組a[0]，即0行地址	2000
a[0], *(a+0), *a	0行0列元素地址	2000
a+1，&a[1]	一行首地址	2016
a[1]， *(a+1)	1行0列元素a[1] [0]的地址	2016
a[1]+2，*(a+1)+2，&a[1] [2]	1行2列元素a[1] [2]的地址	2024
*（a[1]+2）， *（ *（a+1）+2），a[1] [2]	1行2列元素a[1] [2]的值	元素為13

[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-tSLC5meh-1669523540368)(C:\Users\LENOVO\Desktop\Untitled.png)]

• 二維數(shù)組名是指向行的，因此a+1中的1代表一行全部元素所占的字節(jié)數(shù)（16個字節(jié)）
• 一維數(shù)組名是指向列元素的，a[0]+1中的1代表一個a元素所占的字節(jié)數(shù)（4個字節(jié)）
• 在指向行的指針前面加一個*就是 *a和 *(a+1)，他們就成為指向列的指針，分別指向a組0行0列元素和1行0列的元素。
• 在指向列的指針前面加&，就成為指向行的指針，例如a[0]是指向0行0列元素的指針，在它前面加一個&，得到&a[0]與& *a等價，也就是與a等價，它指向二維數(shù)組的0行

//輸出二維數(shù)組的有關(guān)數(shù)據(jù)(地址和值)
#includeint main()
{int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23 };
	printf("第一個：%d %d\n", a, *a);						//0行首地址和0行0列元素地址
	printf("第二個：%d %d\n", a[0], *(a + 0));				//0行0列的元素地址
	printf("第三個：%d %d\n", &a[0], &a[0][0]);				//0行首地址，0行0列元素地址
	printf("第四個：%d %d\n", a[1], a + 1);					//1行0列元素地址和1行首地址
	printf("第五個：%d %d\n", &a[1][0], *(a + 1) + 0);		//1行0列元素地址
	printf("第六個：%d %d\n", a[2], *(a + 2));				//2行0列首地址
	printf("第七個：%d %d\n", &a[2], a + 2);				//2行首地址
	printf("第八個：%d %d\n", a[1][0], *(*(a + 1) + 0));    //1行0列元素的值
	printf("第九個：%d %d\n", *a[2], *(*(a + 2) + 0));      //2行0列元素的值
	return 0;
}

運行結(jié)果：

第一個：-1068368920 -1068368920
第二個：-1068368920 -1068368920
第三個：-1068368920 -1068368920
第四個：-1068368904 -1068368904
第五個：-1068368904 -1068368904
第六個：-1068368888 -1068368888
第七個：-1068368888 -1068368888
第八個：9 9
第九個：17 17

指向多維數(shù)組元素的指針變量 指出數(shù)組元素的指針變量

//有一個3*4的二維數(shù)組，要求用指向元素的指針變量輸出二維數(shù)組各元素的值
#includeint main()
{int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12 };
	int* p;										//p是int*型指針變量
	p = a[0];
	for (p = a[0]; p< a[0] + 12; p++)			//使p依次指向下一個元素
	{if ((p - a[0])% 4 == 0)					//p移動4次換行
			printf("\n");
		printf("%4d", *p);						//輸出p指向的元素的值
	}
	printf("\n");
	return 0;
}

運行結(jié)果：

1   2   3   4
   5   6   7   8
   9  10  11  12

計算a[i] [j]在數(shù)組中的相對位置的計算公式
i ? m + j i*m+j i?m+j
其中m為二維數(shù)組的列數(shù)（二維數(shù)組大小為n*m）

上述3*4的二維數(shù)組，它的2行3列元素a[2] [3]對a[0] [0]的相對位移量為2 * 4+3=11元素

如果一個元素占4個字節(jié)，則a[2] [3]對a[0] [0]的地址差為 11*4=44字節(jié)

若開始時指針變量p指向a[0] [0]，a[i] [j]的地址為“&a[0] [0]+(i*m+j)”或p+（i * m+j）

a[2] [3]的地址是（p+2*4+3），即（p+11）,a[2] [3]的值為 *（p+11)

指向m個元素組成的一維數(shù)組的指針變量

p先指向a[0] (即便p=&a[0])，則p+1不是指向a[0] [1]，而是指向a[1]，p的增值以一維數(shù)組的長度為單位

//輸出二維數(shù)組任一行任一列元素的值
#includeint main()
{int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12 };			//定義二維數(shù)組a并初始化
	int(*p)[4], i, j;										//指針變量p指向包含4個整型元素的一維數(shù)組
	p = a;													//p指向二維數(shù)組的0行
	printf("please enter row and colum:");
	scanf("%d,%d,", &i, &j);								//輸入要求輸出的元素的行列號
	printf("a[%d,%d]=%d\n", i, j, *(*(p + i) + j));			//輸出a[i][j]的值
	return 0;
}

運行結(jié)果：

please enter row and colum:1,2
a[1,2]=7

int（*p）[4]表示定義p為一個指針變量，它指向包括4個整型元素的一維數(shù)組

int a[4];    //(a有四個元素，每個元素為整形)
int (*p)[4];    //(*p)有四個元素，每個元素為整型，也就是p所指的對象是有4個整型元素的數(shù)組，即p是指向一維數(shù)組的，不能指向一維數(shù)組中的某一元素，p的值就是該一維數(shù)組的起始地址

#includeint main()
{int a[4] = {1,3,5,7 };		//定義一維數(shù)組a，包括4個元素
	int(*p)[4];					//定義指向包含4個元素的一維數(shù)組的指針變量
	p = &a;						//p指向一維數(shù)組
	printf("%d\n", (*p)[3]);	//輸出a[3]，輸出整型7
	return 0;
}

用指向數(shù)組的指針作函數(shù)參數(shù)

一維數(shù)組名可以作為函數(shù)參數(shù)，多維數(shù)組名也可以作函數(shù)參數(shù)。用指針變量作形參，以接受實參數(shù)組名傳遞來的地址

有兩種方法：用指向變量的指針變量和用指向一維數(shù)組的指針變量

注意：實參和形參如果是指針類型，應(yīng)當(dāng)注意它們的類型必須一致

不應(yīng)把int*型的指針（即元素的地址）傳給int（ *）[4]型（指向一維數(shù)組）的指針變量，反之亦然。

通過指針引用字符串 字符串的引用方式

用字符數(shù)組存放一個字符串，可以通過數(shù)組名和下標(biāo)引用字符串中的一個字符，也可以通過數(shù)組名和格式聲明“%s”輸出該字符串

//例如：
#includeint main()
{char string[] = "I love china!";		//定義字符數(shù)組string
	printf("%s\n", string);					//用%s格式聲明輸出string，可以輸出整個字符串
	printf("%c\n", string[7]);				//用%c格式輸出一個字符數(shù)組元素
	return 0;
}

運行結(jié)果：

I love china!
c

用字符指針變量指向一個字符串變量變量，通過字符指針變量引用字符串常量

//例如：
#includeint main()
{char* string = "i love china!";		//定義字符指針變量string并初始化，
    									//它只能指向一個字符類型數(shù)據(jù)，而不能同時指向多個字符數(shù)據(jù)
	printf("%s\n", string);				//輸出字符串
	//上一句等價于下面兩句
	//char *string；
	//string="i love china!";
	return 0;
}

運行結(jié)果：

i love china!

可以通過指針變量進行再賦值

string="i am a student.";//把字符串“i am a student."的第一個字符的地址賦給指針變量名string，此后string就指向"i am a student"

通過字符數(shù)組名或字符指針變量可以輸出一個字符串

字符串中字符的存取

//將字符a串復(fù)制為字符串b，然后輸出字符b
//下標(biāo)方法
#includeint main()
{char a[] = "i am a student.", b[20];	//定義字符數(shù)組
	int i;
	for (i = 0; *(a + i) != '\0'; i++)
		*(b + i) = *(a + i);				//將a[i]的值賦給b[i]
	*(b + i) = '\0';						//將b數(shù)組的有效數(shù)組之后加'\0'
	printf("string a is:%s\n", a);			//輸出a數(shù)組中全部有效字符
	printf("string b is:");
	for (i = 0; b[i] != '\0'; i++)
		printf("%c", b[i]);					//逐個輸出b數(shù)組中全部有效字符
	printf("\n");
	return 0;
}

//指針方法
#includeint main()
{char a[] = "i am a student.", b[20], * p1, * p2;
	p1 = a, p2 = b;							//p1,p2分別指向a數(shù)組和b數(shù)組中的第一個元素
	for (; *p1 != '\0'; p1++, p2++)			//p1,p2每次自加1
		*p2 = *p1;							//將p1所指向的元素的值賦給p2所指的元素
	*p2 = '\0';								//在復(fù)制完全部有效字符后加'\0'
	printf("string a is: %s\n", a);			//輸出a數(shù)組中的字符
	printf("string b is: %s\n", b);			//輸出b數(shù)組中的字符
	return 0;
}

運行結(jié)果

string a is: i am a student.
string b is: i am a student.

字符指針作函數(shù)參數(shù)

//用字符數(shù)組名作為函數(shù)參數(shù)
#includeint main()
{void copy_string(char from[], char to[]);
	char a[] = "i am a teachar.";
	char b[] = "you are a student.";
	printf("string a=%s\nstring b=%s\n", a, b);
	printf("copy string a to string b:\n");
	copy_string(a, b);
	printf("\nstring a=%s\nstring b=%s\n", a, b);
	return 0;
}
void copy_string(char from[], char to[])
{int i = 0;
	while (from[i] != '\0')
	{to[i] = from[i];
		i++;
	}
	to[i] = '\0';
}

//用字符型指針變量作實參
#includeint main()
{void copy_string(char from[], char to[]);		//函數(shù)聲明
	char a[] = "i am a teachar.";					//定義字符數(shù)組a并初始化
	char b[] = "you are a student.";				//定義字符數(shù)組b并初始化
	char* from = a;									//from指向a數(shù)組首元素
	char* to = b;									//to指向b數(shù)組首元素
	printf("string a=%s\nstring b=%s\n",a, b);
	printf("\ncopy string a to string b:\n");
	copy_string(from, to);							//實參為字符指針變量
	printf("string a=%s\nstring b=%s\n", a, b);
	return 0;
}
void copy_string(char from[], char to[])			//形參為字符數(shù)組
{int i = 0;
	while (from[i] != '\0')
	{to[i] = from[i];
			i++;
	}
	to[i] = '\0';
}

//用字符指針變量作形參和實參
#includeint main()
{void copy_string(char* from, char* to);
	char* a = "i am a teacher.";				//a是char*型指針變量
	char b[] = "you are a student.";			//b是字符串?dāng)?shù)組
	char* p = b;								//使指針變量p指向b數(shù)組首元素
	printf("string a=%s\nsrting b=%s\n", a, b);	//輸出a串和b串
	printf("\ncopy string a to srting b:\n");
	copy_string(a, p);							//調(diào)用copy_string函數(shù)，實參為指針變量
	printf("string a=%s\nstring b=%s\n",a, b);	//輸出改變后的a串和b串
	return 0;
}
void copy_string(char* from, char* to)			//定義函數(shù)，形參為字符指針變量
{//多種寫法
    //1.
	//for (; *from != '\0'; from++,to++)
	//{//	*to = *from;
	//}
    
    //2.
    //while ((*to = *from) != '\0')
	//{//	to++;
	//	from++;
	//}
    
    //3.
    //while ((*to++ = *from++) != '\0');
    
    //4.
    //while (*from != '\0')
	//	*to++ = *from++;
	//*to = '\0';
	//*to = '\0';
    
    //5.
    //while (*from)
	//{//	*to++ = *from++;
	//	*to = '\0';
	//}
    
    //6.
    //while (*to++ = *from++);
    
    //7.
    //while ((*to++ = *from++) != '\0');
    
    //8.
    //for (; *to++ = *from++;);
    
}

運行結(jié)果：

string a=i am a teachar.
string b=you are a student.

copy string a to string b:
string a=i am a teachar.
string b=i am a teachar.

調(diào)用函數(shù)時實參和形參的對應(yīng)關(guān)系

實參	形參	實參	形參
字符數(shù)組名	字符數(shù)組名	字符指針變量	字符指針變量
字符數(shù)組名	字符指針變量	字符指針變量	字符數(shù)組名

使用字符指針變量和字符數(shù)組的比較 字符數(shù)組和字符指針變量的區(qū)別

• 字符數(shù)組由若干個元素組成，每個元素中放一個字符，而字符指針變量中存放的是地址（字符串第一個字符的地址），絕不是將字符串放在字符指針變量中
• 賦值方式?？梢詫ψ址羔樧兞抠x值，但不能對數(shù)組名賦值

char* a;			//a為字符指針變量
a = "i love you";	//將字符串首元素地址賦給指針變量，合法，
					//但是賦給a的不是字符串，而是字符串第一個元素的地址

不能用以下辦法對字符數(shù)組名賦值

char str[14];
str[1] = 'I';			//對字符數(shù)組元素賦值，合法
str = "i love china";	//數(shù)組名是地址，是常量，不能被賦值，非法

• 初始化的含義，對字符指針變量賦初值

char* a = "i love you";//定義字符指針變量a，并把字符串第一個元素的地址賦給a
//等價于
char* a;				//定義字符串指針變量a
a = "i love you";		//把字符串第一個元素的地址賦給a
//不等價于
char str[14];			//定義字符串?dāng)?shù)組str
str[] = "i love you";	//企圖把字符串賦給數(shù)組中的各元素，錯誤
//數(shù)組可以在定義時對各元素賦初值，但不能用賦值語句對字符數(shù)組中全部元素整體賦值

• 存儲單元的內(nèi)容，編譯時為字符數(shù)組分配若干存儲單元，以存放各元素的值，而對字符指針變量，只分配一個存儲單元（Visual C++指針變量分配4個字節(jié)）

指針變量的值是可以改變的，而數(shù)組名代表一個固定的值（數(shù)組首元素的地址），不能改變

//改變指針變量的值
#includeint main()
{char* a = "i love china!";
	a = a + 7;			//改變指針變量的值，即改變指針變量的指向
	printf("%s\n", a);	//輸出從a指向的字符開始的字符串
	return 0;
}

運行結(jié)果：

china!

字符數(shù)組各元素的值是可以改變的（可以對它們再賦值），但字符指針變量指向的字符串常量中的內(nèi)容是不可以被取代的（不能對他們再賦值）

char a[] = "house";		//字符數(shù)組a初始化
char* b = "house";		//字符指針變量b指向字符串常量的第一個元素
a[2] = 'r';				//合法，r取代a數(shù)組元素a[2]的原值a
b[2] = 'r';				//非法，字符串常量不能改變

引用數(shù)組元素。對字符數(shù)組可以用下標(biāo)法（用數(shù)組名和下標(biāo)）引用一個數(shù)組元素（如a[5])，也可以用地址法（如*（a+5））引用數(shù)組元素a[5]。如果定義了字符種指針變量p，并使它指數(shù)組a的首元素，則可以用指針變量帶下標(biāo)的形式引用數(shù)組元素（如p[5]）,同樣，可以用地址法（如 *（p+5）引用數(shù)組元素a[5]

若字符指針變量p指向字符串常量，就可以用指針變量帶下標(biāo)的形式引用所指的字串中的字符

char *a="i love china";		//定義指針變量a，指向字符串常量
//a[5]的值是a所指向的字符串中的第六個字符(序號為5),即字母'e'

用指針變量指向一個格式字符串，可以用它代替printf函數(shù)中的格式字符串

char *format;
format="a=%d,b=%f\n";
printf(format,a,b);		//使format指向一個字符串
//相當(dāng)于
printf("a=%d,b=%f\n"a,b);v

因此只要改變指針變量format所指向的字符串，就可以改變輸入輸出的格式，這種printf函數(shù)稱為可變格式輸出函數(shù)

//字符數(shù)組實現(xiàn)
char format[]="a=%d,b=%f\n";
printf(format,a,b);

返回指針值的函數(shù)

定義返回值的函數(shù)的一般形式為：
類型名 * 函數(shù)名 （參數(shù)表列）

//例如：
//有a個學(xué)生，每個學(xué)生有b門課程的成績，要求在用戶輸入學(xué)生序號以后，能輸出該學(xué)生的全部成績，用指針函數(shù)來實現(xiàn)
#includeint main()
{float score[3][4] = {{60,70,80,90},{56,89,67,88},{34,78,90,66} };//定義數(shù)組，存放成績
	float* search(float(*pointer)[4], int n);							//函數(shù)聲明
	float* p;
	int i, k;
	printf("enter the number of student:");
	scanf("%d", &k);													//輸入要找的學(xué)生的序號
	printf("the score of No.%d are:\n", k);
	p = search(score,k);											//調(diào)用search函數(shù)，返回score[k][0]的地址
	for (i = 0; i< 4; i++)
		printf("%5.2f\t", *(p + i));								//輸出score[k][0]~score[k][3]的值
	printf("\n");

	return 0;
}
float* search(float(*pointer)[4], int n)							//形參pointer是指向一維數(shù)組的指針變量
{float* pt;
	pt = *(pointer + n);												//pt的值是&score[k][0]
	return (pt);
}

運行結(jié)果：

enter the number of student:1
the score of No.1 are:
56.00   89.00   67.00   88.00

返回指針值的函數(shù)

定義返回值的函數(shù)的一般形式為：
類型名 * 函數(shù)名 （參數(shù)表列）

//例如：
//有a個學(xué)生，每個學(xué)生有b門課程的成績，要求在用戶輸入學(xué)生序號以后，能輸出該學(xué)生的全部成績，用指針函數(shù)來實現(xiàn)
#includeint main()
{float score[3][4] = {{60,70,80,90},{56,89,67,88},{34,78,90,66} };//定義數(shù)組，存放成績
	float* search(float(*pointer)[4], int n);							//函數(shù)聲明
	float* p;
	int i, k;
	printf("enter the number of student:");
	scanf("%d", &k);													//輸入要找的學(xué)生的序號
	printf("the score of No.%d are:\n", k);
	p = search(score,k);											//調(diào)用search函數(shù)，返回score[k][0]的地址
	for (i = 0; i< 4; i++)
		printf("%5.2f\t", *(p + i));								//輸出score[k][0]~score[k][3]的值
	printf("\n");

	return 0;
}
float* search(float(*pointer)[4], int n)							//形參pointer是指向一維數(shù)組的指針變量
{float* pt;
	pt = *(pointer + n);												//pt的值是&score[k][0]
	return (pt);
}

運行結(jié)果：

enter the number of student:1
the score of No.1 are:
56.00   89.00   67.00   88.00

你是否還在尋找穩(wěn)定的海外服務(wù)器提供商？創(chuàng)新互聯(lián)www.cdcxhl.cn海外機房具備T級流量清洗系統(tǒng)配攻擊溯源，準(zhǔn)確流量調(diào)度確保服務(wù)器高可用性，企業(yè)級服務(wù)器適合批量采購，新人活動首月15元起，快前往官網(wǎng)查看詳情吧

當(dāng)前標(biāo)題：專升本C語言——第八章-創(chuàng)新互聯(lián)
當(dāng)前URL：http://weahome.cn/article/dihios.html