指针进阶1

字符指针

一般使用：

int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}

另一种用法：

int main()
{
const char* pstr = "hello bit.";//这里将“hello bit.”首字符地址放在了pstr中
printf("%s\n", pstr);
return 0;
}

有一道面试题:

#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if(str1 ==str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if(str3 ==str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}

输出结果为：

解析：C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候,他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块

指针数组

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

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

数组指针

整形指针： int * pint; 能够指向整形数据的指针
浮点型指针： float * pf; 能够指向浮点型数据的指针
数组指针：int (*p2)[10];能够指向数组的指针

	double* a[5];
	double* (*pa)[5] = &a;//指针数组的数组指针

一道程序有：

int main()
{
	int arr[10] = { 0 };
	int* p1 = arr;
	int (*p2)[10]=&arr;
	printf("%p\n", p1);
	printf("%p\n", p1+1);
	printf("%p\n", p2);
	printf("%p\n", p2+1);
	return 0;
}

打印结果为：

&arr和arr，虽然值是一样的，但是意义应该不一样的。实际上： arr是数组首元素的地址,&arr 表示的是数组的地址。所以p1+1跳过4个字节,p2+1跳过整个数组，40个字节。

数组指针的使用

#include <stdio.h>
void print1(int arr[3][5],int r,int c)
{
	int i = 0;
	int j = 0;
	for (i=0;i<r;i++)
	{
		for (j=0;j<c;j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void print2(int (*p)[5],int r,int c)
{
	int i = 0;
	int j = 0;
	for (i=0;i<r;i++)
	{
		for (j=0;j<c;j++)
		{
			printf("%d ", * (*(p + i) + j));
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	//print1(arr,3,5);
	print2(arr,3,5);//arr表示数组首元素地址——int a[5]={1,2,3,4,5};
	return 0;
}

补充：int (*parr3[10])[5]
parr3是一个存储数组指针的数组
该数组能够存放10个数组指针
每个数组指针能够指向一个数组，数组5个元素，每个元素是int类型

数组参数、指针参数

一维数组传参

#include <stdio.h>
void test(int arr[])//ok
{}
void test(int arr[10])//ok
{}
void test(int *arr)//ok
{}
void test2(int *arr[20])//ok
{}
void test2(int **arr)//ok
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}

二维数组传参

void test(int arr[3][5])//ok
{}
void test(int arr[][])//不ok，行可以省略，列不能省略
{}
void test(int arr[][5])//ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//不ok
{}
void test(int* arr[5])//不ok
{}
void test(int (*arr)[5])//ok
{}
void test(int **arr)//不ok
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}