在C語言中，任何一個變量，都有兩層含義:

(1) 代表該變量的存儲單元的地址；變量的地址 左值 lvalue

(2) 代表該變量的值；右值 rvalue

對于一個變量的訪問，只有兩種情況:

一是把一個值寫到變量的地址中去 (lvalue)

二是從變量的地址中取變量的值 (rvalue)

對象的訪問方式

直接訪問 : 通過對象名去訪問

如:

			int a;
			a = 1024;
			b = a; 

注：直接訪問 受到作用域的限制

間接訪問 :

通過對象的地址去訪問，指針訪問。

只要你知道了對象的地址，就可以在任何地方去訪問它。

不受作用域的限制。

什么是指針

存儲單元(如: memory 內(nèi)存)的地址:

分配給每個對象的內(nèi)存單元都有一個編號，這個編號就是我們所說

存儲單元的地址。并且存儲單元按照字節(jié)來編號。

在C語言中，指針的概念與地址差不多的，你可以直接認(rèn)為指針就是一個地址。

一個變量的地址，我們也稱為變量的“指針”

& 取地執(zhí)符

單目運算符， “取xxx對象的地址”

通過一個對象的指針去訪問它，首先要解決對象的指針(地址) 的保存問題。

需要定義另外的一個變量去保存它的地址，這種變量我們稱為指針變量。

指針變量

指針變量也是一個變量，也是用來保存數(shù)據(jù)，只不過指針變量保存的數(shù)據(jù)是其他對象的地址。

指針變量的定義:

指向的對象的類型 * 指針變量名;

“指向的對象的類型” ：

指針變量指向的對象的類型，而不是指針的類型。

如：

int *p;
int a=10;
p=&a;//p保存了對象a的地址 
	//  p 指向 a 

與指針相關(guān)的運算符

& : 取地址符

int a;

&a : 表示取對象a的地址

對象a的地址，其實就是對象a的指針。

* : 指向運算符  ，單目運算符 

*地址(*指針): 地址對應(yīng)的那個變量(對象)。

如

int a=10;
int *p=&a;
int b=*&a;//b=10，int b=a

所以*(&a) <=> a

*& 可以直接約掉 (編譯原理狀態(tài)機(jī)的詞法分析)

指針變量作為函數(shù)參數(shù)

傳遞的還是值!! 只不過這個“實參的值”可能是某個對象的地址!

C語言中，函數(shù)參數(shù)的傳遞只能是"值傳遞"

形參 = 實參的值

野指針:

void XXX2(int * m, int * n) 
		{
			int * t;//定義了一個指針變量t, 但是t沒有被賦值
					//t沒有賦值，但是不代表它沒有值，相反它會有一個相對應(yīng)的
					//不知道這個值是多少 undefine 
			*t = *m; //操作野指針，可能導(dǎo)致 段錯誤(對一個未知的空間進(jìn)行寫操作)
			*m = *n; 
			*n = *t; //操作野指針，可能導(dǎo)致 段錯誤(對一個未知的空間進(jìn)行讀操作)		

*t 放置到 ‘=’ 符號的左邊，代表t指向?qū)ο蟮淖笾?/p>

對t的指向的對象進(jìn)行寫的操作

*t 放置到 ‘=’ 符號的右邊，代表t指向?qū)ο蟮挠抑?/p>

對t的指向的對象進(jìn)行read的操作

所以t是一個“野指針”，我們也不知道 t指向的內(nèi)存空間是否可讀可寫，

如果不可讀或者不可寫，那么后續(xù)對*t操作，就會導(dǎo)致內(nèi)存的非法訪問 => 段錯誤!!

空指針:

NULL 0

在計算機(jī)中地址為0的存儲空間是不存在的

如果一個指針的值，指向空(NULL)的指針，稱之為空指針。

int *p=NULL;
*p=1024;//操作空指針
int b=*p;//操作空指針

我們?nèi)ナ褂每罩羔?，一定?造成內(nèi)存的非法訪問 => 段錯誤

數(shù)組與指針

數(shù)組元素與普通變量是一樣的，數(shù)組元素也有自己的地址。

數(shù)組元素也有左值和右值，并且數(shù)組元素間的地址是相鄰的。

數(shù)組名可以代表首元素的地址。

a => &a[0], 數(shù)組名a當(dāng)做指針來看

如

int a[]={1,2,3};
int *p=a;//a是數(shù)組名當(dāng)指針來看，==&a[0]

指針作加減的問題:

能不能通過指針p去訪問a[1]?

p=p+1;//&a[0]+1==&a[1]

p + i (p是一個指針，i是一個整數(shù)值)

注：不是簡單地加減數(shù)值，而是加減i個指針指向單元的長度。

p + 1 => 往后面挪了一個int單元的長度 ，&a[1]

			int a[10]; 
			int * p = a; // p = &a[0]
			a[1] <=> *&a[1] <=> *(&a[0] + 1) <=> *(a + 1) <=> a[1] 
			a[1] <=> *&a[1] <=> *(&a[0] + 1) <=> *(p + 1) <=> p[1]

數(shù)組名a，在代碼中有兩層含義:

int a[10];

(1) 數(shù)組名代表整個數(shù)組

&a : 取整個數(shù)組a的地址。

&a + 1 : 往后面挪了1個(int[10])單元長度。

(2) 在合適情況下面，數(shù)組名可以當(dāng)作指針來看

a <=> &a[0]

a + 1 : 當(dāng)作指針來看

=> &a[0] + 1

=> &a[1]

多維數(shù)組與指針

在C語言中，所有的數(shù)組其實都是一維數(shù)組!

int a[3][4]; //int[4] a[3]; 

        表達(dá)式         表達(dá)式的含義                              表達(dá)式的值 
          a             數(shù)組名: 
                          (1) 當(dāng)作指針 &a[0]                     取整個一維數(shù)組a[0]的地址 
                          (2) 當(dāng)作整個數(shù)組來看       
          a[0]             數(shù)組名: 
                           (1) 當(dāng)作指針 &a[0][0]                  取數(shù)組元素a[0][0]的地址 
                           (2) 當(dāng)作整個一維數(shù)組a[0]來看 
          a[0][0]       數(shù)組元素a[0][0]                           a[0][0] (左值/右值)

 a + 1          a是數(shù)組名,在此處當(dāng)作指針 ==&a[0]+1==&a[1]
 a[0] + 1       a[0] 是數(shù)組名，在此處當(dāng)作指針 ==&a[0][0]+1==&a[0][1]
a[0][0] + 1       a[0][0]是二維數(shù)組a中的一個int類型的元素 ==a[0][0]+1
a[1] + 2         a[1]是數(shù)組名，此處當(dāng)作指針 ==&a[1][0]+2==&a[1][2]
*(a + 1) + 2    a是數(shù)組名，在此處當(dāng)作指針 ==*(&a[0]+1)+2==*(&a[1])+2==a[1]+2==&a[1][2]

指針常量 和 常量指針

他們都是指針，只不過他們之間的屬性有一點區(qū)別。

指針常量:

指針本身不能改變(指針的指向不能變)，但是

它所指向的內(nèi)存空間里面的內(nèi)容是可以改變的。

最具有代表性例子，數(shù)組名!

定義方式:

指向?qū)ο蟮念愋?* const 指針變量名;

				int a , b;
				int * const p = &a; 
				p = &b ; //error 

常量指針:

是一個指向常量的地址。指針指向的對象是常量，

那么指針本身的指向是可以改變的，但是這個指針指向

內(nèi)存空間中的內(nèi)容是不能夠改變。

最具有代表性例子，字符串

char * p = "abcde"; //"abcde" <=> &'a' 

定義方式:

const 類型 * 變量名;

or

類型 const * 變量名;

指針數(shù)組 與 數(shù)組指針

(1) 指針數(shù)組

指針數(shù)組是一個數(shù)組，只不過它里面的每一個元素都是指針罷了!

定義數(shù)組:

數(shù)組元素類型 數(shù)組名[元素個數(shù)];

“數(shù)組元素類型” : C語言中任意合法的類型都可以。

int * p[4]; //定義了一個指針數(shù)組，數(shù)組名為p，里面含有4個int*類型的指針。

(2) 數(shù)組指針

數(shù)組指針是一個指針，只不過這個指針是用來指向一個數(shù)組罷了!!

int (*p)[4] ; //定義了一個數(shù)組指針，指針變量名為p，用來指向一個含有4個int類型元素的數(shù)組的。 

如

int a[3][4];
int (*p)[4];
p = a; //&a[0]
*(*p + 1) // *(a[0]+1)==*(&a[0][1])==a[0][1]
*(*(p + 2)) // *(*(&a[2]))==*(&a[2][0])==a[2][0]
*(*(p+3) + 3)// *(*(&a[0]+3)+3)==*(*(&a[3])+3)==*(&a[3][0]+3)==a[3][3]

字符串與指針

字符串就是一串字符。在C語言中，沒有字符串這個類型。

C語言字符串是通過 char *(字符指針)來實現(xiàn)。

C語言中的字符串，是用""引起來的一串字符來表示，并且字符串后面默認(rèn)會加一個\0,\0(ASCII為0的那個字符)字符串結(jié)束的標(biāo)志。

如

            "abc"  //字符串 
            "\n"   //字符串 
            ""     //字符串 => 空串 
            '\123' //字符
            '\n'   //字符 

注：

我們只需要保存字符串的首字符地址就可以了，從首字符地址開始找到第一個\0，前面的這些字符就是字符串里面的字符。

在C語言中的字符串(如: “ssssssabcd”)是保存在一個叫做 .rodata(只讀數(shù)據(jù))的內(nèi)存區(qū)域，字符串代表是這個內(nèi)存空間的首地址。

"ssssssabcd" => 表達(dá)式的值  => &'s'
			char *p="12345" ==&'1'
				int *p=&'1';	
				p+1=&'2';

字符數(shù)組:

			char s[5] = {'a', 'b', 'c', 'd', 'e'}; 
			//字符數(shù)組，與普通數(shù)組是一樣的，保存在一個.data/?？臻g 
			//數(shù)組區(qū)域是可讀可寫的 
			sizeof(s) == 5 
			strlen(s) >= 5 //沒有'\0' 長度不確定

			char s[] = {"abcde"}; //自動生成'\0'
			<=> char s[] = {'a', 'b', 'c', 'd', 'e', '\0'}; 
			//s字符數(shù)組，與普通數(shù)組是一樣的，保存在一個.data/?？臻g 
			//數(shù)組區(qū)域是可讀可寫的
			sizeof(s) == 6	 
			strlen(s) == 5

			char s[] = {"abcde"};
			s[1] = 'B'; //OK 
			char ch = s[1]; //OK 
			*(s + 1) = 'B'; //OK 
			ch = *(s + 1); //OK 
			s = s + 1; //ERROR 
						//s是數(shù)組名，數(shù)組名當(dāng)作指針，指針常量 
						//s的指向 是不能夠改變的，但是s指向的內(nèi)存空間
						//里面的內(nèi)容是可變的
			printf("%s\n", s); //abcde   %s : char* 地址
			//把后面的那個地址當(dāng)作是一個字符串的首地址，一個一個字符進(jìn)行輸出，直到遇到\0才會結(jié)束!			
					

函數(shù)指針

函數(shù)也有地址 ，那么咱們可以定義一個指針，去存放一個函數(shù)的地址,像這樣的指針,稱為函數(shù)指針。

函數(shù)指針如何定義

int *  abc(int a, float b)
			{
			}

描述函數(shù)abc的類型: int (int , float ) ： 是一個返回值為int類型，帶有一個Int類型和float類型的參數(shù)的函數(shù)類型

指向函數(shù)的返回值的類型 (*指針變量名) (指向函數(shù)的形參類型列表);

int (* p)(int, int) ; 

定義了一個指針變量p,p是一個函數(shù)指針，是用來指向一個返回值為int類型，并且?guī)в袃蓚€int類型參數(shù)的函數(shù)的。

函數(shù)指針如何賦值

&函數(shù)名

or

函數(shù)名 : 在C語言中，函數(shù)名本身就可以代表函數(shù)的地址

通過函數(shù)指針去調(diào)用指向的函數(shù)，有如下兩種方案:

p為函數(shù)的指針。

(1) (*p)(實參列表)

(2) p(實參列表)

int *p=abc//函數(shù)名
p(a,b);//調(diào)用函數(shù)

二級指針 與 多級指針

int a,b;

可以定義一個指針變量p1，來保存變量a的地址:

int *p1=&a;
b=*p1=*&a=a;//通過指針p1訪問a變量

可以定義一個指針變量p2，來保存變量p1的地址:

int *p2=&p1
int b=**p2=*p1=a//通過指針p2訪問a變量

p2保存的是一個一級指針p1的地址，所以說，

p2指向一個一級指針，p2就是一個二級指針

可以定義一個指針變量p3，來保存變量p2的地址:

int *p3=&p2;
int b=***p3=**p2=*p1=a;

p3保存的是一個二級指針p2的地址，所以說，

p3指向一個二級指針，p3就是一個三級指針

到此這篇關(guān)于C語言簡析指針用途的文章就介紹到這了,更多相關(guān)C語言指針內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論