C语言指针整理2

例题：编写程序把一个数组中的所有内容前后颠倒.比如数组中原有内容是1 2 3 4 5；颠倒后内容是5 4 3 2 1；要求使用指针编写程序；

//颠倒数组内容
#include<stdio.h>
void main()
{
        int arr[] = {1,2,3,4,5},num = 0;
        int *p_start  = arr,*p_end = arr + 4;
        while(p_start < p_end)
       {
             int tmp = *p_start;
             *p_start = *p_end;
             *p_end = tmp;
              p_start++;
              p_end--;
       }
        for(num = 0;num <= 4;num++)
       {
             printf("%d ",arr[num]);
       }
       printf("\n");
}

//在函数里实现数组内容的前后颠倒1
#include<stdio.h>
void reverse(int arr[],int size) 
{
         int *p_start = arr,*p_end = arr + size -1;
         while(p_start < p_end)
        {
              int tmp = *p_start;
              *p_start = *p_end;
              *p_end = tmp;
                p_start++;
                p_end--;
        }
}
void main()
{
          int arr[] = {1,2,3,4,5},num = 0;
          reverse(arr,5);
          for(num = 0;num <= 4;num++)
         {
                printf("%d ",arr[num]);
         }
          printf("\n");
}

注:让被调用函数使用调用函数的数组,可通过数组作形参的方法.

实现跨函数使用存储区方法；数组作形参(本质由指针实现)、使用静态局部变量；

//被调用函数使用调用函数存储区,使用指针类型形参
#include<stdio.h>
void reverse(int *p_num,int size)   //被调用函数
{
         int *p_start = p_num,*p_end = p_num + size -1;
         while(p_start < p_end)
        {
              int tmp = *p_start;
              *p_start = *p_end;
              *p_end = tmp;
                p_start++;
                p_end--;
        }
}
void main()   //调用函数
{
          int arr[] = {1,2,3,4,5},num = 0;
          reverse(arr,5);
          for(num = 0;num <= 4;num++)
         {
                printf("%d ",arr[num]);
         }
          printf("\n");
}

//跨函数使用静态局部变量
//调用函数使用被调用函数静态局部变量,使用指针类型的返回值

#include<stdio.h>
int *func(void)
{
       static int num;     //static 静态
       printf("num是%d\n",num);
       return &num;
}
void main()
{
       int *p_num = func();
       *p_num = 10;
       func();
}

总结:实现跨函数使用存储区均需要通过指针才能实现.

注:跨函数使用存储区必须遵守生命周期的规则,生命周期不允许情况是不能跨函数使用存储区的.

练习:编写函数把主函数中的两个变量内容交换.

//交换存储区内容练习
#include<stdio.h>
void swap(int *p_num,int *p_num1)
{
      int tmp = *p_num;
      *p_num = *p_num1;
      *p_num1 = tmp;
}
int main()
{
      int num = 3,num1 = 7;
      swap(&num,&num1);     //swap 交换
      printf("num是%d,num1是%d\n",num,num1);
      return 0;
}

声明指针变量的时候可以使用const关键字

如果const关键字写在类型名称前就表示:

不可以通过这个指针对捆绑存储区进行赋值,

但是可以对指针本身的存储区进行赋值.

#include<stdio.h>
void main()
{ 
        int num = 0;
        const int *p_num = &num;
        //*p_num = 10;  //通过指针作赋值操作,
        //错误，不可以通过这个指针对捆绑存储区进行赋值。
        num = 10;  //没有通过指针赋值
        printf("请输入一个数字:");
        scanf("%d",p_num);  //通过指针,但不是作赋值操作
        printf("*p_num是%d\n",*p_num);
        p_num = NULL;  //指针本身存储区可以赋值
}

当跨函数使用存储区的时候,如果存储区的拥有者不希望别的函数修改自己的存储区,
就应该采用上述办法在声明指针的时候加const关键字.
注:当跨函数使用存储区的时候,尽量在指针声明前使用上述方法增加const关键字.

#include<stdio.h>
//const int *p_num,加const就不会修改数组里面的数
void print(const int *p_num,int size)
{
        int num = 0;
        for(num = 0;num <= size - 1;num++)
       {
             printf("%d ",*(p_num + num));
       }
        printf("\n");
}
void main()
{
       int arr[] = {1,2,3,4,5};
       print(arr,5);
}

如果声明指针时把const关键字加在指针变量名称前,
就表示不可以对指针本身的存储区做赋值,但是可以对捆绑存储区做赋值.

#include<stdio.h>
void main()
{
      int num = 10;
      int *const p_num = &num;
      *p_num = 100;
      //p_num = NULL;   //错误
      scanf("%d",p_num);   //这样是可以的
      printf("%d\n",num);
}