数组和指针的关系；const指针

1.数组和指针的关系：
    数组用来存放数据
    指针用来操作数组中的数据 

    int a[5];
    int *p = NULL;

    p = &a[0];
    p = a;

    a == &a[0];
    a == int *
    
    注意：
        1.数组的数组名a是指向数组第一个元素的指针常量 
        2.数组元素的访问形式：
            a[n] == *(a+n) == *(p+n) == p[n]
        3.C语言中所有指针均可以使用[]访问空间
            指针[n] == *(指针 + n)
    
2.一维数组作为函数参数：
    int a[5] = {1, 2, 3, 4, 5};

    int fun(int array[5]);
    int fun(int array[], int len);
    int fun(int *array, int len);           //最常使用

    练习：封装3个函数实现从终端接收5个数，对数组排序，对数组输出
        int InputArray(int *parray, int len);
        int BubbleSort(int *parray, int len);
        int OuputArray(int *parray, int len);

#include <stdio.h>

int InputArray(int *parray, int len)
{
    int i = 0;

    for (i = 0; i < len; i++)
    {
        scanf("%d", &parray[i]);
    }

    return 0;
}

int BubbleSort(int *parray, int len)
{
    int j = 0;
    int i = 0;
    int temp = 0;

    for (j = 0; j < len-1; j++)
    {
        for (i = 0; i < len-1-j; i++)
        {
            if (parray[i] > parray[i+1])
            {
                temp = parray[i];
                parray[i] = parray[i+1];
                parray[i+1] = temp;
            }
        }
    }

    return 0;
}

int OutputArray(int *parray, int len)
{
    int i = 0;

    for (i = 0; i < len; i++)
    {
        printf("%d ", parray[i]);
    }
    printf("\n");

    return 0;
}

int main(void)
{
    int a[5] = {0};

    InputArray(a, 5);
    BubbleSort(a, 5);
    OutputArray(a, 5);

    return 0;
}

3.一维字符型数组和指针的关系
    数组的数组名是指向数组第一个元素的指针 

    char str[32] = {"hello world"};
    char *p = NULL;

    p = &str[0];
    p = str;

    字符串遍历操作:
        while (*p != '\0')
        {
            p++;
        }

练习:从终端接收一个字符串,统计该字符串的长度（使用指针操作）

#include <stdio.h>

int MyStrlen(char *pstr)
{
	int len = 0;

	while (*pstr != '\0')
	{
		len++;
		pstr++;
	}

	return len;
}

int main(void)
{
	char str[32] = {0};
	int ret = 0;

	gets(str);
	
	ret = MyStrlen(str);

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

	return 0;
}

4.字符型数组和字符串作为函数参数：
    int fun(char *pstr);

练习：从终端接收一个字符串,编写一个函数统计该字符串中大写、小写、数字和空格的个数
    int GetCount(char *pstr, int *pdaxie, int *pxiaoxie, int *pshuzi, int *pkongge);

#include <stdio.h>

int GetCount(char *pstr, int *pdaxie, int *pxiaoxie, int *pshuzi, int *pkongge)
{
	int daxie = 0;
	int xiaoxie = 0;
	int shuzi = 0;
	int kongge = 0;

	while (*pstr != '\0')
	{	
		if (*pstr >= 'a' && *pstr <= 'z')
		{
			xiaoxie++;
		}
		else if (*pstr >= 'A' && *pstr <= 'Z')
		{
			daxie++;
		}
		else if (*pstr >= '0' && *pstr <= '9')
		{
			shuzi++;
		}
		else if (' ' == *pstr)
		{
			kongge++;
		}
		pstr++;
	}
	
	*pdaxie = daxie;
	*pxiaoxie = xiaoxie;
	*pshuzi = shuzi;
	*pkongge = kongge;

	return 0;
}

int main(void)
{
	char str[256] = {0};
	int daxiecnt = 0;
	int xiaoxiecnt = 0;
	int shuzicnt = 0;
	int konggecnt = 0;

	gets(str);

	GetCount(str, &daxiecnt, &xiaoxiecnt, &shuzicnt, &konggecnt);

	printf("大写:%d\n", daxiecnt);
	printf("小写:%d\n", xiaoxiecnt);
	printf("数字:%d\n", shuzicnt);
	printf("空格:%d\n", konggecnt);

	return 0;
}

练习:封装一个函数,传入一个字符串,对字符串实现倒置
    int Reverse(char *pstr);

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

int Reverse(char *pstr)
{
	char *phead = NULL;
	char *ptail = NULL;
	char temp = 0;

	phead = pstr;
	ptail = pstr + strlen(pstr) - 1;
	
	while (phead < ptail)
	{
		temp = *phead;
		*phead = *ptail;
		*ptail = temp;
		phead++;
		ptail--;
	}

	return 0;
}

int main(void)
{
	char str[32] = {0};

	gets(str);

	Reverse(str);

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

	return 0;
}

练习：封装一个函数，传入一个字符串，将其拷贝到另一个空间中 
    int MyStrcpy(char *pdst, char *psrc);    

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

int MyStrcpy(char *pdst, const char *psrc)
{
	while (*psrc != '\0')
	{
		*pdst = *psrc;
		pdst++;
		psrc++;
	}
	*pdst = '\0';

	return 0;
}

int main(void)
{
	char src[32] = {0};
	char dst[32] = {0};

	gets(src);

	MyStrcpy(dst, src);

	printf("dst = %s\n", dst);

	return 0;
}

4.const指针:
    const == readonly    只读（只能读不能改）

    1.int const *p;
    2.const int *p;
    3.int *const p;
    4.const int *const p;
    5.int const *const p;

    1和2是等价的
    const修饰*p, 指针变量p可以修改指向的空间,但不能利用该指针修改指向空间中的值
    主要用于：
        1.字符串在函数中传参时,只想让函数体内使用字符串,而不允许通过指针改变字符串的值使用const
        2.定义指向字符串常量的指针,最好加const 
           const char *p = "hello world";

#include <stdio.h>

int main(void)
{
	char str[32] = {"hello world"};
	const char *pstr = "how are you";
	
	pstr = "hello world";			//对
	*pstr = 'H';					//错
	
	str = "how are you";			//错
	*str = 'H';						//对


	return 0;
}

    3
    const修饰p, 指针变量p的值不能变, 但可以利用指针修改指向空间中的值, 一定要对指针初始化
    主要用于：
        数组的数组名是永远指向数组第一个元素的指针

    4和5是等价的
    const修饰p和*p, 指针变量p的值不能变,也不能利用*p改变指向空间中的值, 一定要对指针初始化