如果对字符串和二维数组有基本概念可以直接跳去看他们的关系及使用

于4.3 00:08修改，改正了之前文章中错误的观点，修改了一些低级错误
欢迎大家在文章下留言

于21-05-19 22:37再次更新,前几天有个同学问了我这么个问题，我觉得是一个非常好的作为本文的引入的例子

引入

如下图，为什么输出如下，num与&num与&num[0]有什么区别?(图中的地址是16进制)

一.2维数组
1.二维数组的定义

int a[3][3];

在这我们定义了一个二维数组，拥有3行3列共9个int型存储空间大小。

2.二维数组的行地址和各个元素地址的表示

int a[3][4];
a;//代表数组首行地址，一般用a[0][0]的地址表示
&a;//代表整个数组的地址，一般用a[0][0]地址表示
a[i];代表了第i行起始元素的地址(网上说是代表了第i行的地址，但我觉得不是，在讲数组与指针的关系时我会验证给大家看)
&a[i];代表了第i行的地址，一般用a[i][0]的地址表示
a[i]+j;//代表了第i行第j个元素地址,a[i]就是j==0的情况
a[i][j];//代表了第i行第j个元素
&a[i][j];//代表了第i行第j个元素的地址

对于数组a，我们可以将a[3][4]分为两部分理解a[3]和[4]，对于a[3]，我们可以看成是一个一维数组，其元素分别为a[0],a[1],a[2],他们分别表示各行所代表的起始地址，而对于[4]我们可以理解成每行所拥有的元素个数，我们可以通过下面的图进行认识：

二.指针
指针的定义：
变量的指针就是变量的地址。存放变量地址的变量是指针变量。即在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针。

#include <stdio.h>

int main()
{
	int* p;//定义了一个指向整形数据的指针变量 
	char *p;//定义了一个指向字符型数据的指针变量 
	char (*p)[3];//定义了一个数组指针，指向了一个长度为3的一维字符数组 
	char* (*p)[3];//定义了一个数组指针，指向了一个二维数组 
	//注意 char* p[3];不是一个指针，它是一个数组，里面存放了指针，下面我们会详细讲解  
	return 0;
} 

对于指针类型和指针指向数据的类型，我们可以用一种简单的办法快速得出：
1.得出指针的类型：去掉指针变量则就是指针的类型
2.得出指针指向数据的类型：去掉*就是我们得出的数据类型

#include <stdio.h>
int main()
{
	int* p;// 指针类型为int*,数据类型为int 
	char* p;//指针类型为char*,数据类型为char
	char (*p)[3];//指针类型为char (*)[3]，数据类型为char ()[3],表示一个一维数组 
	char* (*p)[3];//指针类型为char* (*)[3],数据类型为char (*)[3]表示一个二维数组 
	return 0;
} 

指针的赋值

int a = 5;
&a;//会返回一个指向a内存的一个指针，注意是一个指针
int* p = &a;//p的类型为int*，&a也返回一个int*的指针，左右两边类型相同

前方高能！！！

指针与二维数组的关系以及使用
1.数组名与指针的关系：

a;//代表数组首行地址，一般用a[0][0]的地址表示
&a;//代表整个数组的地址，一般用a[0][0]地址表示
a[i];代表了第i行起始元素的地址(网上说是代表了第i行的地址，但我觉得不是，在讲数组与指针的关系时我会验证给大家看)
&a[i];代表了第i行的地址，一般用a[i][0]的地址表示
a[i]+j;//代表了第i行第j个元素地址,a[i]就是j==0的情况
a[i][j];//代表了第i行第j个元素
&a[i][j];//代表了第i行第j个元素的地址
*a;//代表数组a首元素地址也就是a[0]或者&a[0][0]
*(a+i);//代表了第i行首元素的地址,*a是i=0的情况
*(a+i)+j;//代表了第i行j个元素的地址
**a;//代表a的首元素的值也就是a[0][0]
*(*(a+i)+j);//代表了第i行第j个元素

#include <stdio.h>
int main()
{	 
	int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
	//输出各行首元素地址 
	printf("i\t&a[i]\ta+i\ta[i]\t&a[i][0]\n");
	for(int i=0;i<3;i++)
	printf("%d\t%d\t%d\t%d\t%d\t%d\n",i,&a[i],a+i,a[i],&a[i][0],*(a+i));
	//输出各行中列元素地址 
	printf("\n输出各行中列元素地址");
	printf("\n\ta[i]+i\t&a[i][i]\n") ;
	for(int i=0; i<3; i++)
	{
		printf("i=%d\t%d\t%d\n",i,a[i]+i,&a[i][i]);
	} 
	return 0;
} 

运行结果：

	//从上图结果我们可以看出
	a+i == &a[i] == a[i] == &a[i][0] == *(a+i)//虽然它们的值相等，但他们的意义不全相等，a+i和&a[i]意义相同都表示行地址，a[i],&a[i][0],*(a+i)意思相同，都表示改行起始元素地址。
	/*这里有个公式可以记一下：*(a+i) == a[i]; 加上个*号会等于指针变量去掉*号右边加个中括号，中括号内的值为指针变量所要增加的值，*(a+i)+j = a[i]+j;
	  对于 *(*(a+i)+j) = a[i][j],我们可以先去掉最外面的*变成(*(a+i))[j],再去掉*为a[i][j]

有了以上的概念，我们就可以对一些现象进行解释和说明，如下代码：

#include <stdio.h>

using namespace std;

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

    int a[3][4];
    printf("%d\n", a);
    printf("a + 1 \t &a + 1 \t a[0] + 1 \t &a[0] + 1\n");
    printf("%d \t %d \t %d \t %d", a + 1, &a + 1, a[0] + 1, &a[0] + 1); 

    return 0;
}

运行结果：

(1)第一行输出6422000表示数组的起始地址为6422000
(2)由于a表示的数组首行地址，因此a+1中的1其实代表了数组中的一行元素的大小，也就是4*4个字节(一行4个int元素，每个int占4个字节)，等于16
(3)由于&a表示的是一个数组，因此&a+1中的1其实代表了整个数组的大小，也就是3*4*4个字节3*4为元素个数最后的4是int表示的4个字节大小)，等于48
(5)由于a[0]代表了第0行第0个元素的地址，因此a[0]+1中的1其实代表了一个元素的大小，也就是1*4，等于4
(5)由于&a[0]代表了第0行的地址，因此&a[0]+1中的1其实代表了一行元素的大小，也就是4*4个字节(同(2))，等于16

数组与指针的结合
1.数组指针与指针数组：
数组指针：是一个指向数组的指针
指针数组：是一个储存指针的数组

数组指针(表示一维数组)

#include <stdio.h>

int main()
{
	int (*p)[3];
	/*定义了一个数组指针，指向了一个数组长度为3的一维数组,注意是指向一个数组，所以赋值给他的地址要是数组类型的地址
	  可以这样理解：一维数组名就是一个指针这里只是用指针的形
	  式代替了数组名 ，注意这里的3要和指向的数组长度相同
	*/ 
	
	int a[3] = {1,2,3};
	p = &a;
	/*
	将数组a地址赋值给p，此时(*p)[i]相当于a[i],注意不能写成p=a，或者p=&a[0]
	因为指针p是指向一个数组,p=a表示p指向首个元素的地址，虽然&a,&a[0],a
	的结果是一样的(这是因为数组一般用其首元素地址表示) 
	*/
	
	printf("数组指针指向一维数组的遍历：\n"); 
	for(int i=0; i<3; i++)
	{
		printf("%d\n",(*p)[i]);
	}
	
	/*这里要用指针遍历输出a不能用*(p+i)方式输出，
	  因为p表示数组a的地址(一般用数组中首个元素地址表示)， 
	  p++表示p要增加3*4个字节长度(3为数组指针指定的长度，4为int所占空间大小)  
	*/ 
	
	printf("--------------------------\n");
	printf("&a=%d\n",&a);//输出a的地址 
	printf("p=%d\n",p);//p指向了数组a，所以输出为a的地址(一般用数组中首个元素地址表示)
	printf("*p=%d\n",*p);//既然p指向了数组a，那么*p则为数组a本身(一般用数组中首个元素地址表示)
	printf("p+1=%d\n",p+1);
	printf("*(p+1)=%d\n",*(p+1));//，运用公式*(p+1) == p[1],可以想象成刚好超过a长度的那个地址，p+1表示p要增加3*4个字节长度(3为数组指针指定的长度，4为int所占空间大小)==*(p+1)
	printf("**p=%d\n",**p);//p指向a，*p表示a本身(一般用数组中首个元素地址表示)，那么**p表示*a,表示数组首元素。
	printf("p[0]=%d\n",p[0]);//p[0] == *p ，*p又是a本身，所以输出a首元素地址
	printf("*p[0]=%d\n",*p[0]);//既然p[0]为数组首元素地址，那加上个*就为a的首元素 
	return 0;
} 

输出结果：

数组指针(表示二维数组)

#include <stdio.h>
int main()
{
	int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
	int (*p)[4];//4要和二维数组的列元素个数相同 
	p = a;//a代表数组首行地址
	printf("a=%d\n",a);
	printf("p=%d\n",p);//p==a，p就为a的首行地址
	printf("*p=%d\n",*p);//*p == *a 为数组首元素地址
	printf("**p=%d\n",**p);//**p == **a 为数组首元素 
	printf("p+1=%d\n",p+1);// p+1 == a+1；为第1行(有第0行)
	
	printf("--------------------\n二维数组的遍历\n");
	for(int i=0; i<3; i++)
	{
		for(int j=0; j<4; j++)
		{
			printf("%d ",*(*(p+i)+j));//通过上面的公式我们可以写成p[i][j] 或者*(p[i]+j)在下面数组的遍历我们都会一一使用
		}
	 } 
	return 0;
}

运行结果：

指针数组
指针数组最明显的一个例子就是字符串数组

#include <stdio.h>
#include <string.h>
int main()
{
	const char *str[5] = {"i","am","a","boy"};//定义了一个长度为5指针数组，每个元素都是const char *类型,都是一个指向字符串的指针 
	for(int i=0; i<4; i++)
	{
		printf("%s\n",str[i]);//str[i]代表字符串的地址，我们可以通过%s和字符串的首地址输出一个字符串
	}
	return 0;
}

运行结果：

二维数组的遍历(用指针)：
法一：

#include <stdio.h>
int main()
{	
	/*让p指向数组的起始元素地址，然后依次使指针加1进行遍历
	  注意是指向起始元素的地址，起始元素的地址
	  虽然上面有很多的值都和起始元素地址相同，但是只有真正代表起始地址的才行 
	*/ 
	int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
	int *p;
 	//p = a;使p指向行地址,报错
	//p = &a[0];//使p指向行地址,报错，侧面也证明了&a[0]指向行地址 
	p = *a;//*a代表数组起始元素地址，可以通过 
	p = a[0]; //a[0]代表数组起始元素地址，可以通过， 
	p = &a[0][0]; //可以通过 
	for(int i=0; i<9; i++)
	{
		printf("%d ",*p++); //还记得我之前说的那个公式吗？这里还可以写出p[i++];
							//可以这样推出*p++ == *(p+i) -> p[i] 
	}						//但要注意我们对指针进行了自增，因此在使用时要减去增加的那部分 
	p = p - 9;
	printf("\n");
	for(int i=0; i<9; i++)
	{
		printf("%d ",p[i]); 
	}
	return 0;
} 

运行结果：

法二：

#include <stdio.h>
int main()
{	
	/*定义一个数组指针
	让指针p指向数组的行地址，然后每次使他的行增加与列增加来遍历 
	*/ 
	int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
	int (*p)[3];
 	p = a;//因为数组名本身为一个指向行地址的指针，因此此可有p == a;而不是*p = a; 
	for(int i=0; i<3; i++)
	{
		for(int j=0; j<3; j++)
		{
			printf("%d ",*(*(p+i)+j));//还记得我之前说的那个公式吗？这里还可以写成p[i][j]或者*(p[i]+j) 
		}
	}
	printf("\n");
	for(int i=0; i<3; i++)
	{
		for(int j=0; j<3; j++)
		{
			printf("%d ",p[i][j]);
		}
	}
	printf("\n");
	for(int i=0; i<3; i++)
	{
		for(int j=0; j<3; j++)
		{
			printf("%d ",*(p[i]+j));
		}
	}
	return 0;
} 

运行结果：

法三：

#include <stdio.h>
int main()
{	
	//定义一个指针数组，数组的每个元素都储存着另一个数组的行的起始元素地址 
	
	int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
	int *p[3];
 	for(int i=0; i<3; i++) p[i] = a[i]; //或者p[i] = &a[i][0]; 或者p[i] = *(a+i); 
 	
	for(int i=0; i<3; i++)
	{
		for(int j=0; j<3; j++)
		printf("%d ",*(p[i]+j));//这里还可以写成*(*(p+i)+j)
	}
	printf("\n");
	for(int i=0; i<3; i++)
	{
		for(int j=0; j<3; j++)
		printf("%d ",*(*(p+i)+j));
	}
	return 0;
} 

输出结果：

法四：

#include <stdio.h>
int main()
{
	/*通过数组名遍历(数组民也是一种指针)，前面我们说过*a代表了数组起始元素的地址
	那我们可以使*a+i来指向第i个元素，再通过*(*a+i) 遍历，这与前面第一个方法是一样的，
	只不过第一个方法用一个指针p代替了起始元素的地址(注意这里是代替，并不是指向，指向的意思是指针内存放的是某个变量的地址) 
	*/ 
	int a[3][3] = {1,2,3,4,5,6,7,8,9};
	for(int i=0; i<9; i++)
	printf("%d ",*(*a+i));
	return 0;
 } 

运行结果：

字符串和字符串数组的输入
这里主要记录下平常自己不怎么不到的方法，加以巩固
法一：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 100
int main()
{
	char str[10][N];
	for(int i=0; i<4; i++)
	{
		gets(str[i]);//gets()以回车键判断是否输入完毕，scanf()以空格判断，str[i]代表了每行的起始地址，相当于每行储存了一个字符串
	}
	for(int i=0; i<4; i++)
	{
		printf("%s ",str[i]);
	}
	
	return 0;
}

运行结果：

法二：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{	
	char *str;
	str = (char*)malloc(sizeof(char)*100);//类似于char str[100]; 
	gets(str);
	printf("len=%d\n",strlen(str));
	printf("%s",str);
	free(str);
	return 0;
}

运行结果：

以后遇到更多的用法我将继续补充。