C語言
第七章指針
7.1 概述
7.1.1 內存
7.1.2 物理存儲器和存儲地址空間
7.1.3 內存地址
7.1.4 指針和指針變量
7.2 指針基礎知識
7.2.1 指針變量的定義和使用
7.2.2 通過指針間接修改變量的值
7.2.3 指針大小
7.2.4 野指針和空指針
7.2.5萬能指針void *
7.2.6 const修飾的指針變量
7.3 指針和數組
7.3.1 數組名
7.3.2 指針操作數組元素
7.3.3 指針加減運算
7.3.4 指針數組
7.4 多級指針
7.5 指針和函數
7.5.1 函數形參改變實參的值
7.5.2 數組名做函數參數
7.5.3 指針做爲函數的返回值
7.6 指針和字符串
7.6.1 字符指針
7.6.2 字符指針做函數參數
7.6.3 const修飾的指針變量
7.6.4 指針數組做爲main函數的形參
7.6.5 項目開發常用字符串應用模型
7.7 指針小結

第七章指針

7.1 概述

7.1.1 內存

內存含義：

存儲器：計算機的組成中，用來存儲程序和數據，輔助CPU進行運算處理的重要部分。
內存：內部存貯器，暫存程序/數據——掉電丟失 SRAM、DRAM、DDR、DDR2、DDR3。
外存：外部存儲器，長時間保存程序/數據—掉電不丟ROM、ERRROM、FLASH（NAND、NOR）、硬盤、光盤。

內存是溝通CPU與硬盤的橋樑：

暫存放CPU中的運算數據
暫存與硬盤等外部存儲器交換的數據

7.1.2 物理存儲器和存儲地址空間

有關內存的兩個概念：物理存儲器和存儲地址空間。

物理存儲器：實際存在的具體存儲器芯片。

主板上裝插的內存條
顯示卡上的顯示RAM芯片
各種適配卡上的RAM芯片和ROM芯片

存儲地址空間：對存儲器編碼的範圍。我們在軟件上常說的內存是指這一層含義。

編碼：對每個物理存儲單元（一個字節）分配一個號碼
尋址：可以根據分配的號碼找到相應的存儲單元，完成數據的讀寫

7.1.3 內存地址

將內存抽象成一個很大的一維字符數組。
編碼就是對內存的每一個字節分配一個32位或64位的編號（與32位或者64位處理器相關）。
這個內存編號我們稱之爲內存地址。

內存中的每一個數據都會分配相應的地址：

char:佔一個字節分配一個地址
int: 佔四個字節分配四個地址
float、struct、函數、數組等

7.1.4 指針和指針變量

內存區的每一個字節都有一個編號，這就是“地址”。
如果在程序中定義了一個變量，在對程序進行編譯或運行時，系統就會給這個變量分配內存單元，並確定它的內存地址(編號)
指針的實質就是內存“地址”。指針就是地址，地址就是指針。
指針是內存單元的編號，指針變量是存放地址的變量。
通常我們敘述時會把指針變量簡稱爲指針，實際他們含義並不一樣。

7.2 指針基礎知識

7.2.1 指針變量的定義和使用

指針也是一種數據類型，指針變量也是一種變量
指針變量指向誰，就把誰的地址賦值給指針變量
“*”操作符操作的是指針變量指向的內存空間

#include <stdio.h>

int main()
{
	int a = 0;
	char b = 100;
	printf("%p, %p\n", &a, &b); //打印a, b的地址

	//int *代表是一種數據類型，int*指針類型，p纔是變量名
	//定義了一個指針類型的變量，可以指向一個int類型變量的地址
	int *p;
	p = &a;//將a的地址賦值給變量p，p也是一個變量，值是一個內存地址編號
	printf("%d\n", *p);//p指向了a的地址，*p就是a的值

	char *p1 = &b;
	printf("%c\n", *p1);//*p1指向了b的地址，*p1就是b的值

	return 0;
}

注意：&可以取得一個變量在內存中的地址。但是，不能取寄存器變量，因爲寄存器變量不在內存裏，而在CPU裏面，所以是沒有地址的。

7.2.2 通過指針間接修改變量的值

	int a = 0;
	int b = 11;
	int *p = &a;

	*p = 100;
	printf("a = %d, *p = %d\n", a, *p);

	p = &b;
	*p = 22;
	printf("b = %d, *p = %d\n", b, *p);

7.2.3 指針大小

使用sizeof()測量指針的大小，得到的總是：4或8
sizeof()測的是指針變量指向存儲地址的大小
在32位平臺，所有的指針（地址）都是32位(4字節)
在64位平臺，所有的指針（地址）都是64位(8字節)

	int *p1;
	int **p2;
	char *p3;
	char **p4;
	printf("sizeof(p1) = %d\n", sizeof(p1));
	printf("sizeof(p2) = %d\n", sizeof(p2));
	printf("sizeof(p3) = %d\n", sizeof(p3));
	printf("sizeof(p4) = %d\n", sizeof(p4));
	printf("sizeof(double *) = %d\n", sizeof(double *));

7.2.4 野指針和空指針

指針變量也是變量，是變量就可以任意賦值，不要越界即可（32位爲4字節，64位爲8字節），但是，任意數值賦值給指針變量沒有意義，因爲這樣的指針就成了野指針，此指針指向的區域是未知(操作系統不允許操作此指針指向的內存區域)。所以，野指針不會直接引發錯誤，操作野指針指向的內存區域纔會出問題。

	int a = 100;
	int *p;
	p = a; //把a的值賦值給指針變量p，p爲野指針， ok，不會有問題，但沒有意義

	p = 0x12345678; //給指針變量p賦值，p爲野指針， ok，不會有問題，但沒有意義

	*p = 1000;  //操作野指針指向未知區域，內存出問題，err

但是，野指針和有效指針變量保存的都是數值，爲了標誌此指針變量沒有指向任何變量(空閒可用)，C語言中，可以把NULL賦值給此指針，這樣就標誌此指針爲空指針，沒有任何指針。

	int *p = NULL;

NULL是一個值爲0的宏常量：

#define NULL    ((void *)0)

7.2.5萬能指針void *

void *指針可以指向任意變量的內存空間：

	void *p = NULL;

	int a = 10;
	p = (void *)&a; //指向變量時，最好轉換爲void *

	//使用指針變量指向的內存時，轉換爲int *
	*( (int *)p ) = 11;
	printf("a = %d\n", a);

7.2.6 const修飾的指針變量

	int a = 100;
	int b = 200;

//指向常量的指針
	//修飾*，指針指向內存區域不能修改，指針指向可以變
	const int *p1 = &a; //等價於int const *p1 = &a;
	//*p1 = 111; //err
	p1 = &b; //ok

//指針常量
	//修飾p1，指針指向不能變，指針指向的內存可以修改
	int * const p2 = &a;
	//p2 = &b; //err
	*p2 = 222; //ok

7.3 指針和數組

7.3.1 數組名

數組名字是數組的首元素地址，但它是一個常量：

	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	printf("a = %p\n", a);
	printf("&a[0] = %p\n", &a[0]);

	//a = 10; //err, 數組名只是常量，不能修改

7.3.2 指針操作數組元素

#include <stdio.h>

int  main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0;
	int n = sizeof(a) / sizeof(a[0]);
	
	for (i = 0; i < n; i++)
	{
		//printf("%d, ", a[i]);
		printf("%d, ", *(a+i));
	}
	printf("\n");

	int *p = a; //定義一個指針變量保存a的地址
	for (i = 0; i < n; i++)
	{
		p[i] = 2 * i;
	}

	for (i = 0; i < n; i++)
	{
		printf("%d, ", *(p + i));
	}
	printf("\n");


	return 0;
}

7.3.3 指針加減運算

1.加法運算

指針計算不是簡單的整數相加
如果是一個int *，+1的結果是增加一個int的大小
如果是一個char *，+1的結果是增加一個char大小

#include <stdio.h>

int main()
{
	int a;
	int *p = &a;
	printf("%d\n", p);
	p += 2;//移動了2個int
	printf("%d\n", p);

	char b = 0;
	char *p1 = &b;
	printf("%d\n", p1);
	p1 += 2;//移動了2個char
	printf("%d\n", p1);

	return 0;
}

通過改變指針指向操作數組元素：

#include <stdio.h>

int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0;
	int n = sizeof(a) / sizeof(a[0]);

	int *p = a;
	for (i = 0; i < n; i++)
	{
		printf("%d, ", *p);
		p++;
	}
	printf("\n");
	
	return 0;
}

2.減法運算
示例1：

#include <stdio.h>

int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int i = 0;
	int n = sizeof(a) / sizeof(a[0]);

	int *p = a+n-1;
	for (i = 0; i < n; i++)
	{
		printf("%d, ", *p);
		p--;
	}
	printf("\n");

	return 0;
}

示例2：

#include <stdio.h>

int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int *p2 = &a[2]; //第2個元素地址
	int *p1 = &a[1]; //第1個元素地址
	printf("p1 = %p, p2 = %p\n", p1, p2);

	int n1 = p2 - p1; //n1 = 1
	int n2 = (int)p2 - (int)p1; //n2 = 4
	printf("n1 = %d, n2 = %d\n", n1, n2);
	
	return 0;
}

7.3.4 指針數組

指針數組，它是數組，數組的每個元素都是指針類型。

#include <stdio.h>

int main()
{
	//指針數組
	int *p[3];
	int a = 1;
	int b = 2;
	int c = 3;
	int i = 0;

	p[0] = &a;
	p[1] = &b;
	p[2] = &c;

	for (i = 0; i < sizeof(p) / sizeof(p[0]); i++ )
	{
		printf("%d, ", *(p[i]));
	}
	printf("\n");
	
	return 0;
}

7.4 多級指針

C語言允許有多級指針存在，在實際的程序中一級指針最常用，其次是二級指針。
二級指針就是指向一個一級指針變量地址的指針。
三級指針基本用不着，但考試會考。

	int a = 10;
	int *p = &a; //一級指針
	*p = 100; //*p就是a

	int **q = &p;
	//*q就是p
	//**q就是a

	int ***t = &q;
	//*t就是q
	//**t就是p
	//***t就是a

7.5 指針和函數

7.5.1 函數形參改變實參的值

#include <stdio.h>

void swap1(int x, int y)
{
	int tmp;
	tmp = x;
	x = y;
	y = tmp;
	printf("x = %d, y = %d\n", x, y);
}

void swap2(int *x, int *y)
{
	int tmp;
	tmp = *x;
	*x = *y;
	*y = tmp;
}

int main()
{
	int a = 3;
	int b = 5;
	swap1(a, b); //值傳遞
	printf("a = %d, b = %d\n", a, b);

	a = 3;
	b = 5;
	swap2(&a, &b); //地址傳遞
	printf("a2 = %d, b2 = %d\n", a, b);

	return 0;
}

7.5.2 數組名做函數參數

數組名做函數參數，函數的形參會退化爲指針：

#include <stdio.h>

//void printArrary(int a[10], int n)
//void printArrary(int a[], int n)
void printArrary(int *a, int n)
{
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d, ", a[i]);
	}
	printf("\n");
}

int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int n = sizeof(a) / sizeof(a[0]);

	//數組名做函數參數
	printArrary(a, n); 
	return 0;
}

7.5.3 指針做爲函數的返回值

#include <stdio.h>

int a = 10;

int *getA()
{
	return &a;
}


int main()
{
	*( getA() ) = 111;
	printf("a = %d\n", a);

	return 0;
}

7.6 指針和字符串

7.6.1 字符指針

#include <stdio.h>

int main()
{
	char str[] = "hello world";
	char *p = str;
	*p = 'm';
	p++;
	*p = 'i';
	printf("%s\n", str);

	p = "mike jiang";
	printf("%s\n", p);

	char *q = "test";
	printf("%s\n", q);

	return 0;
}

7.6.2 字符指針做函數參數

#include <stdio.h>

void mystrcat(char *dest, const char *src)
{
	int len1 = 0;
	int len2 = 0;
	while (dest[len1])
	{
		len1++;
	}
	while (src[len2])
	{
		len2++;
	}

	int i;
	for (i = 0; i < len2; i++)
	{
		dest[len1 + i] = src[i];
	}
}

int main()
{
	char dst[100] = "hello mike";
	char src[] = "123456";
	
	mystrcat(dst, src);
	printf("dst = %s\n", dst);

	return 0;
}

7.6.3 const修飾的指針變量

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
	//const修飾一個變量爲只讀
	const int a = 10;
	//a = 100; //err

	//指針變量， 指針指向的內存， 2個不同概念
	char buf[] = "aklgjdlsgjlkds";

	//從左往右看，跳過類型，看修飾哪個字符
	//如果是*， 說明指針指向的內存不能改變
	//如果是指針變量，說明指針的指向不能改變，指針的值不能修改
	const char *p = buf;
	// 等價於上面 char const *p1 = buf;
	//p[1] = '2'; //err
	p = "agdlsjaglkdsajgl"; //ok

	char * const p2 = buf;
	p2[1] = '3';
	//p2 = "salkjgldsjaglk"; //err

	//p3爲只讀，指向不能變，指向的內存也不能變
	const char * const p3 = buf;

	return 0;
}

7.6.4 指針數組做爲main函數的形參

int main(int argc, char *argv[]);

main函數是操作系統調用的，第一個參數標明argv數組的成員數量，argv數組的每個成員都是char *類型
argv是命令行參數的字符串數組
argc代表命令行參數的數量，程序名字本身算一個參數

#include <stdio.h>

//argc: 傳參數的個數（包含可執行程序）
//argv：指針數組，指向輸入的參數
int main(int argc, char *argv[])
{

	//指針數組，它是數組，每個元素都是指針
	char *a[] = { "aaaaaaa", "bbbbbbbbbb", "ccccccc" };
	int i = 0;

	printf("argc = %d\n", argc);
	for (i = 0; i < argc; i++)
	{
		printf("%s\n", argv[i]);
	}
	return 0;
}

7.6.5 項目開發常用字符串應用模型

1.strstr中的while和do-while模型
利用strstr標準庫函數找出一個字符串中substr出現的個數。

a.while模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
	char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
	int n = 0;

	while ((p = strstr(p, "abcd")) != NULL)
	{
		//能進來，肯定有匹配的子串
		//重新設置起點位置
		p = p + strlen("abcd");
		n++;

		if (*p == 0) //如果到結束符
		{
			break;
		}

	}

	printf("n = %d\n", n);

	return 0;
}

b.do-while模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
	char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
	int n = 0;

	do
	{
		p = strstr(p, "abcd");
		if (p != NULL)
		{
			n++; //累計個數

			//重新設置查找的起點
			p = p + strlen("abcd");

		}
		else //如果沒有匹配的字符串，跳出循環
		{
			break;
		}
	} while (*p != 0); //如果沒有到結尾

	printf("n = %d\n", n);
	return 0;
}

2.兩頭堵模型
求非空字符串元素的個數：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int fun(char *p, int *n)
{
	if (p == NULL || n == NULL)
	{
		return -1;
	}

	int begin = 0;
	int end = strlen(p) - 1;

	//從左邊開始
	//如果當前字符爲空，而且沒有結束
	while (p[begin] == ' ' && p[begin] != 0)
	{
		begin++; //位置從右移動一位
	}

	//從右往左移動
	while (p[end] == ' ' && end > 0)
	{
		end--; //往左移動
	}

	if (end == 0)
	{
		return -2;
	}

	//非空元素個數
	*n = end - begin + 1;

	return 0;
}

int main(void)
{
	char *p = "      abcddsgadsgefg      ";
	int ret = 0;
	int n = 0;

	ret = fun(p, &n);
	if (ret != 0)
	{
		return ret;
	}
	printf("非空字符串元素個數：%d\n", n);

	return 0;
}

3.字符串反轉模型(逆置)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int inverse(char *p)
{
   if (p == NULL)
   {
   	return -1;
   }
   char *str = p;
   int begin = 0;
   int end = strlen(str) - 1;
   char tmp;

   while (begin < end)
   {
   	//交換元素
   	tmp = str[begin];
   	str[begin] = str[end];
   	str[end] = tmp;

   	begin++;  //往右移動位置
   	end--;	    //往左移動位置
   }

   return 0;
}

int main(void)
{
   //char *str = "abcdefg"; //文件常量區，內容不允許修改
   char str[] = "abcdef";

   int ret = inverse(str);
   if (ret != 0)
   {
   	return ret;
   }

   printf("str ========== %s\n", str);
   return 0;
}

7.7 指針小結

定義	說明
int i	定義整形變量
int *p	定義一個指向int的指針變量
int a[10]	定義一個有10個元素的數組，每個元素類型爲int
int *p[10]	定義一個有10個元素的數組，每個元素類型爲int*
int func()	定義一個函數，返回值爲int型
int *func()	定義一個函數，返回值爲int *型
int **p	定義一個指向int的指針的指針，二級指針

【C語言】指針-007

C語言

第七章指針

7.1 概述

7.1.1 內存

7.1.2 物理存儲器和存儲地址空間

7.1.3 內存地址

7.1.4 指針和指針變量

7.2 指針基礎知識

7.2.1 指針變量的定義和使用

7.2.2 通過指針間接修改變量的值

7.2.3 指針大小

7.2.4 野指針和空指針

7.2.5萬能指針void *

7.2.6 const修飾的指針變量

7.3 指針和數組

7.3.1 數組名

7.3.2 指針操作數組元素

7.3.3 指針加減運算

7.3.4 指針數組

7.4 多級指針

7.5 指針和函數

7.5.1 函數形參改變實參的值

7.5.2 數組名做函數參數

7.5.3 指針做爲函數的返回值

7.6 指針和字符串

7.6.1 字符指針

7.6.2 字符指針做函數參數

7.6.3 const修飾的指針變量

7.6.4 指針數組做爲main函數的形參

7.6.5 項目開發常用字符串應用模型

7.7 指針小結

24-5-18 X

【Java】基礎篇之接口、多態-009

【C++】面向對象之C++對C的擴展-002

【C語言】文件操作-010

【C語言】內存管理-008

【C語言】複合類型-009

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

【C語言】 指針-007

C語言

第七章 指針

7.1 概述

7.1.1 內存

7.1.2 物理存儲器和存儲地址空間

7.1.3 內存地址

7.1.4 指針和指針變量

7.2 指針基礎知識

7.2.1 指針變量的定義和使用

7.2.2 通過指針間接修改變量的值

7.2.3 指針大小

7.2.4 野指針和空指針

7.2.5萬能指針void *

7.2.6 const修飾的指針變量

7.3 指針和數組

7.3.1 數組名

7.3.2 指針操作數組元素

7.3.3 指針加減運算

7.3.4 指針數組

7.4 多級指針

7.5 指針和函數

7.5.1 函數形參改變實參的值

7.5.2 數組名做函數參數

7.5.3 指針做爲函數的返回值

7.6 指針和字符串

7.6.1 字符指針

7.6.2 字符指針做函數參數

7.6.3 const修飾的指針變量

7.6.4 指針數組做爲main函數的形參

7.6.5 項目開發常用字符串應用模型

7.7 指針小結

【C語言】指針-007

第七章指針