什么是 字符指针? 数组指针? 函数指针? 函数指针数组?

在指针的类型中我们知道有⼀种指针类型为字符指针 char* ;

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

int main()
{
 const char* pstr = "hello world.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗？ 
 printf("%s\n", pstr);
 return 0;
}

#include <stdio.h>
int main()
{
 char str1[] = "hello world.";
 char str2[] = "hello world.";
 const char *str3 = "hello world.";
 const char *str4 = "hello world.";
 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;
}

int *p1[10];
int (*p2)[10];

int arr[10] = {0};
&arr;//得到的就是数组的地址

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

int (*p) [10] = &arr;
 | | |
 | | |
 | | p指向数组的元素个数
 | p是数组指针变量名
 p指向的数组的元素类型

#include <stdio.h>
void test(int a[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 ", a[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}};
 test(arr, 3, 5);
 return 0;
}

#include <stdio.h>
void test(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));//*(p+i)解引用表示二维数组里面的一个元素,即一维数组,+j表示向后加一个int*大小的地址,解引用即一维数组里面的一个元素
 		}
	 printf("\n");
	 }
}
int main()
{
 int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
 test(arr, 3, 5);
 return 0;
}

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("test: %p\n", test);
 printf("&test: %p\n", &test);
 return 0;
}

test: 005913CA
&test: 005913CA

void test()
{
 printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
 return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

int (*pf3) (int x, int y)
 | | ------------ 
 | | |
 | | pf3指向函数的参数类型和个数的交代
 | 函数指针变量名
 pf3指向函数的返回类型
 
 int (*) (int x, int y) //pf3函数指针变量的类型 

#include <stdio.h>
int Add(int x, int y)
{
 return x+y;
}
int main()
{
 int(*pf3)(int, int) = Add;
 
 printf("%d\n", (*pf3)(2, 3));
 printf("%d\n", pf3(3, 5));
 return 0;
}

5
8

int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];

设计循环使其可以旋1次，然后让他执行n次是一个最简单的思路：
void leftRound(char * src, int time)
{
	int i, j, tmp;
  int len = strlen(src);
  time %= len; //长度为5的情况下，旋转6、11、16...次相当于1次，7、12、17...次相当于2次，以此类推。
	for (i = 0; i < time; i++) //执行k次的单次平移
	{
		tmp = src[0];
		for(j = 0; j < len - 1; j++) //单次平移
		{
			src[j] = src[j + 1];
		}
		src[j] = tmp;
	}
}
改进一：
这个思路当然可以，但是一次一次转毕竟太麻烦，就不能一次到位么？
当然可以，我们可以选择拼接法，一次到位：
void leftRound(char * src, int time)
{
	int len = strlen(src);
	int pos = time % len; //断开位置的下标
	char tmp[256] = { 0 }; //更准确的话可以选择malloc len + 1个字节的空间来做这个tmp
	
	strcpy(tmp, src + pos); //先将后面的全部拷过来
	strncat(tmp, src, pos); //然后将前面几个接上
	strcpy(src, tmp); //最后拷回去
}
改进二：
这个方法要用到一个数组形成的辅助空间，让人觉得有点不爽，还可以有更好的选择，例如ABCDEFG，左旋3次后变成DEFGABC，有一个特殊的操作方式：
先将要左旋的前三个家伙逆序（CBADEFG），然后将后半段也逆序（CBAGFED），最后整体逆序（DEFGABC）即可。这样只需要做数值交换即可，可以写一个函数帮我们完成局部逆序，代码如下：
void reverse_part(char *str, int start, int end) //将字符串从start到end这一段逆序
{
	int i, j;
	char tmp;

	for (i = start, j = end; i < j; i++, j--)
	{
		tmp = str[i];
		str[i] = str[j];
		str[j] = tmp;
	}
}

void leftRound(char * src, int time)
{
	int len = strlen(src);
	int pos = time % len;
	reverse_part(src, 0, pos - 1); //逆序前段
	reverse_part(src, pos, len - 1); //逆序后段
	reverse_part(src, 0, len - 1); //整体逆序
}