指针--进阶

指针：

1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间；

2.指针的大小是固定的4/8个字节（32位/64位机器）；

3.指针是有类型，指针的类型决定了指针的加减整数的步长、指针解引用操作时的权限；

4.指针的运算

字符指针：

指针不仅可以指向一个字符，也可以指向一个字符串，但指向的是首字符得地址传递给指针。

#include <stdio.h>
int main()
{
   
	char ch = 'q';
	char* pch = &ch;
	*pch = 'w';
	printf("%c\n", ch);

	char* ps = "hello world";  //把首字母h的首地址传递给ps
	char arr[] = "hello world";
	printf("%c\n", *ps);
	printf("%s\n", ps);
	printf("%s\n", arr); 

	return 0;

char* ps = "hello world";----hello world.  是常量字符串不能被改变---const（常量）

char* str1="hello world.";
char* str2="hello world.";

此时str1与str2相同，比较的是地址，并不是里面的内容。

指针数组：存放指针的数组（地址）

int* arr[3];//存放整形指针的数组

	int a[6] = {
    1,2,3,4,5,6 };
	int b[6] = {
    11,12,13,14,15,16 };
	int c[6] = {
    21,22,23,24,25,26 };

	int* arr[] = {
    a,b,c };


	for (int i = 0; i < 3; i++)
	{
   
		for (int j = 0; j < 6; j++) //i j 的类型也是很重要的
		{
   
			printf("%d ", *(arr[i]+j));  
			printf("%d ", arr[i][j]);//像是模拟了一个二维数组，但实际不是，二维数组是连续存放的

		}
		printf("\n");
		//printf("%d\n",*(arr[i]));  //只能打印首位元素
	}

int* arr1[3]; 整形指针的数组

char* arr2[3]; 一级字符指针指针的数组

char** arr3[3]; 二级字符指针指针的数组

	float f = 9.0f;
	int* p = (int*)&f;
	printf("%d ", *p);  //什么类型存进去，什么类型取出来

回顾知识：

1.指针类型决定了：指针解引用的权限有多大----可以访问几个字节

2.指针类型决定了：指针走一步能走多远（步长）–地址变了几个

数组指针

整型指针-----指向整形的指针；

字符指针-----指向字符的指针；

数组指针-----指向数组的指针；

数组指针：

parr是一个数组指针（指向数组的指针）----存放的是数组的地址

	int arr[3] = {
    1,2,3 };

	int(*parr)[3] = &arr;  //取出的是数组的指针

	double* d[5]; //指针数组，存放指针的数组

	double* (*pd)[5] = &d;   //pd是一个数组指针

数组名VS&数组名

数组名是首元素的地址，除了两种特殊情况【&数组名和sizeof（数组名）】

&数组名：才是取出了数组的地址

虽然两者都是首字符的地址，但是意义却不一样

举例说明：

	int arr[10] = {
    0 }; 

	int* p1 = arr;  //P1是整型指针，加1会跳过四个字节，会跳过一个整型

	int(*p2)[10] = &arr;  //P2是数组指针，加1会跳过一个数组（跳过一个指向对象类型的距离）

数组指针的使用：

例 int (*pa1)[10]=&arr 中pa是数组指针，指向的是一个具有是个元素，且元素为int型的数组。

对pa进行解引用操作—*pa1:指向的是整个数组，相当于首元素的地址，也就是int* pa2=arr中的 pa2, 如果要打印整个数组中的元素，代码如下：

	int arr[10] = {
    1,2,3,4,5,6,7,8,9,10 }; 

	int* p1 = arr;

	int(*p2)[10] = &arr;

	int i = 0;
	for (i; i < 10; i++)
	{
   
		printf("%d ", *((*p2) + i));
	}

	return 0;

二维数组的第一行是其首元素；

另外一种方式实现：

void print2(int(*pARR)[5], int  r, int c)  //int(*parr)[5]:指向一维数组的指针，该一维数组是
{
   
	int i = 0; 
	int j = 0;
	for (i = 0; i < r; i++)
	{
   
		for (j = 0; j < c; j++)
		{
   
			printf("%d ", *(*(pARR + i) + j));  //*(pARR+i)其实是每一行的数组名，也就是那一行首元素的地址
			//printf("%d ",pARR[i][j]);   //这个是为什么呢

		}
		printf("\n");
	}
}

int* pa[10]:是一个整型指针的数组

int (*pa1)[10]:是一个数组指针，指向的是一个数组

int(*pa3[10])[5]: pa3是一个数组（含有十个元素），存放的是数组指针，每个数组指针指向一个数组，该数组含有五个元素，元素类型为int型。

数组参数与指针参数

写程序时，总会遇到把数组或者指针传递给函数的情况；

一维数组传参：

//下面有两个数组
int arr1[3]={
   1,2,3};  //整型数组

int* arr2[3]={
   xx,xx,xx};  //整型指针数组

//数组传参

test1(arr1);
void test1(int arrr[m])   //写不写都可以，因为没有意义，传递的只是数组的首元素的地址-----int 是 数组的类型，这个不能忘

test2(arr2);
void test2(int* arrr[])  //别忘了数组元素的类型

//指针传参

test3(arr1);
void test3(int* arrr)  // 传递的是指针，首元素的地址，那么需要找一个指针来接收、首元素类型是整型，整形指针来接收
test4(arr2);
void test(int** arrr) //首元素是整形指针类型，需要创建一个存放整型指针的指针变量、也就是二级指针

二维数组传参：

//下面有两个数组
int arr3[3][5]={
   };  //整型数组

int* arr4[3][5]={
   xx,xx,xx};  //整型指针数组---没有讲这个，无非就是每个元素是一个指针罢了

//数组传参

test1(arr3);
void test1(int arrr[m][n] )   //m可以省略，但是n不可以省略

//指针传参
test2(arr3);
void test2(int(*arrr)[5])  //别忘了二维数组元素的类型，传递的是首元素的地址，首元素的是第一行，应该传递的是第一行的地址

sizeof（）计算的结果是无符号整型

当无符号整型和有符号整型比较的时候，无符号整型会被解读为有符号整型。

例子：求SN=a+aa+aaa+aaaa+aaaaa的值，a是一个数字

//求SN=a+aa+aaa+aaaa+aaaaa的值，a是一个数字

	int a = 0, b=0;
	printf("请输入a：\n");

	scanf("%d %d", &a,&b);

	int i = 0;
	int sum = 0;
	int temp = 0;
	for (i = 0; i < b; i++)
	{
   
		temp = temp * 10 + a;

		sum = sum + temp;
	}
	printf("%d", sum);

	return 0;
}

例子–水仙花数：【1-10000】之间的水仙花数

int i = 1;
	for (i = 1; i < 10000; i++)
	{
   
		int sum = 0;
		int  temp = i;
		int  n = 1;
		//判断有几位数
		while (temp / 10)
		{
   
			n++;
			temp /= 10;
		}
		//判断每一位的n次方之和
		temp = i;
		
		while (temp)
		{
   
			sum += pow(temp % 10, n);
			temp /= 10;
		}
		if (sum == i)
		{
   
			printf("%d ", i);
		}

	}
	return 0;

指针-指针得到的是两个指针之间元素的个数；

整形指针解引用操作访问4个字节；

.的优先级比*的优先级更高。就比如【*p.a】

编程----字符串逆序：

char arr[] = "helloworld!";  //将数组内容变化为逆序后的情况

	int sz1 = sizeof(arr) / sizeof(arr[0]);  //求出来数组元素的个数

	int sz = strlen(arr);



	char* start = arr;  //数组名就是首元素名

	char* end = start + sz - 1;  //这是个数组所以他的下标应该减1
	
	char temp = 0;

	while (start < end)
	{
   
		temp = *start;
		*start = *end;
		*end = temp;

		start++;
		end--;
	}

	printf("%s\n", arr);
	printf("%d\n", sz1);  //12
	printf("%d\n", sz);   //11

	return 0;
//如果将数组名传递给函数的话，可以用strlen函数来求解字符串长度的值

//sizeof会带上\0的值，所以会大一个值；

//可以加一个assert断言，防止出错什么的

【注】万万不可以写成：char* arr = "hello" 这种形式，常量不能被修改；

arr 是一个指向字符串常量（hello）的字符指针，存放的是 h 的首字符的地址，常量不可以被修改；

而 arr[] 则是定义了一个数组，初始化为“hello”，里面内容可以修改；

不可以用 sizeof 来求字符串的长度，是用来求数组元素的个数；【求字符串长度时：两者关系是：sizeof=strlen+1】

编程题----打印菱形-----切记面向结果编程

//打印菱形算法--最好的方法是：

		int line = 0;

		scanf("%d", &m);

		scanf("%d", &line);  //line是中间那一行
		//打印上半部分
		int i = 0;
		for (i = 0; i < line; i++)
		{
   
			int j = 0;
			for (j = 0; j < line - 1 - i; j++)   //可以控制不同的那个行数打印空格\考虑考虑数学关系比较简单的
			{
   
				printf(" ");
			}

			for (j = 0; j < 2 * i + 1; j++)
				/*int m = 1;
				for(m=1;m<=2*(i+1)-1;m++)*/
			{
   
				printf("*");
			}
			printf("\n");
		}
		for (i = 0; i < line - 1; i++)
		{
   
			//实现下面一部分
			int j = 0;

			//打印空格
			for (j = 0; j <= i; j++)  //相当于一个新的
			{
   
				printf(" ");
			}
			for (j = 0; j < 2 * (line - 1 - i) - 1; j++)  //相当于一个新的
			{
   
				printf("*");
			}
			printf("\n");
		}
	

【猪】最关键的是：找到数学规律

编程题----喝汽水问题【1瓶汽水1块钱，两个空瓶可以换一瓶汽水，20块可以喝多少】

【PRO】给任意钱可以喝多少

int money = 0;
	printf("请输入你有多少钱-->");
	scanf("%d", &money);
	int count = 0;
	count = money / 1;
	int empty = count;   
	while (empty / 2)
	{
   
		if (empty % 2 == 0)
		{
   
			count += (empty / 2);
			empty /= 2;
		}
		else
		{
   
			count += ((empty - 1) / 2);
			empty = ((empty + 1) / 2);
		}
	}
	/*
	while(empty>=2)
	{
		count+=empty/2;
		empty=empty/2+empty%2;
	}
	
	*/
	printf("\n你能喝%d瓶汽水，还剩%d个空瓶子\n", count, empty);


	
	return 0;

编程题&#x