学习日志以及个人总结（13） 指针！

指针

定义
访问内存地址 操控硬件

指针：

指针+基本数据据类

指针+数组

指针+函数

指针+指针

1.指针：就是地址-----就是内存的单元的编号

2.指针变量

语法：

基类型*  指针变量名；

基类型-------数据类型//基础数据类型 //数组类  //基类型表示指针变量  指向的目标的数据类型

* --------表示此时定义的白变量是一个指针类型的变量

指针变量名------标识符命名规则+见名知意

int *p；//表示定义了一个指针类型的变量

int *p = &a;   //指针变量 p 指向 了 int型变量a    

p变量的数据类型 int *   //指针类型 

&b --地址值 ---类型? 
      float 
      b有一块内存空间 -- 放的是float类型的数据 
      &b ---得到了一块 存放着 float类型数据的 空间的地址 

指针访问变量.

间接访问 通过地址访问到的 

指针的运算
* 指针运算符
* 单目运算 
 运算数必须是指针类型的值(地址)
  *p 过程
 1.首先拿出p指针变量中的值(地址) 到内存中定位 
 2.从定位处开始，偏移出sizeof(基类型)大小的一块空间 
 3.把这块空间当做一个 基类型的 变量来看  

想实现:
被调修改主调 
1.想修改谁，就把谁的地址传过去 
2.必须要做*运算(间接访问)，实现修改 

练习：
   求两个数的和 --函数 

   int add(int a,int b)
   {
      return a + b; //只能带出一个结果 
   }

#include <stdio.h>
 
void Sum(int a,int b,int *sum)   //  指针求和函数
{
    *sum=*a + *b;
 
    return ;
}
 
int main (void)
{
    int a=2;
    int b=3;
    int sum=0;
    Sum(&a,&b,&sum);
    printf("sum=%d\n",sum);
 
    return 0;
}

练习：
    找出两个数中最大值 最小值 

#include <stdio.h>
 
void compure(int a,int b,int *max,int *min)    //比较函数
{
	if (a>b)
	{
		*max=a;
		*min=b;
	}else
	{
		*max=b;
		*min=a;
	}
}
 
int main(void)
{
	int a=0;
	int b=0;
    int max=0;
	int min=0;
	scanf("%d%d",&a,&b);
	compure(a,b,&max,&min);
 
	printf("MAX=%d\n",max);
	printf("MIN=%d\n",min);
}

练习:
    main函数中有两个数据
    交换a b的值

#include <stdio.h>
 
void jiaohuan(int *a,int *b)     //换位函数
{
	int c=*a;
	*a=*b;
	*b=c;
}
 
 
int main(void)
{
	int a=0;
	int b=0;
 
	printf("a=");
	scanf("%d",&a);
	printf("b=");
	scanf("%d",&b);
 
	jiaohuan(&a,&b);
 
	printf("a=%d \nb=%d\n",a,b);
 
	return 0;

指针 + 数组 

一维整型数组 

int a[5];   //a首元素的地址 
              //a[0]  -- int型 
             //&a[0] -- int * 

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

a[i] <=> *(a+i) //指针运算

练习:
     找最大值 ，指针的方式访问  

#include <stdio.h>
 
int Max(int *p,int len)     // 擂台法求最大值函数
{
	int i=0;
    int t=*p;
	for (i=1;i<len;++i)
	{
		if (*(p+i)>t)
		{
			t=*(p+i);
		}
	}
	return t;
}
 
 
int main (void)
{
	int a[10]={6,5,12,3,4,98,10};
    
	int *p=a;
	int q=Max(a,10);
 
	printf("Max=%d\n",q);
 
	return 0;
}

指针小总结

1.指针概念
  a.指针 --- 地址 ---内存单元编号  //值 
  b.指针 --- 数据类型 ---指针类型  //类型 
  
  不同语境:
  
  定义一个指针?       //指针类型的变量 
  打印某个变量的指针? //指针 --地址   
     
2.指针变量的定义
  基类型 * 变量名
  
  a.基类型 
    数据类型
    基本数据类型 
    数组类型 
    指针类型
  b. *   //定义时候的 * 表示定义的是一个 指针类型的变量 
  c. 变量名 

eg:
  int a,b,*p,*q; //p和q都是指针类型的变量 *是修饰指针变量名的  
  
  int *p,q; //p是指针变量 q int型变量

  注意:
  1.指针变量的 大小 64位(8字节) 32位(4字节)
  2.指针类型 --- 存储的是 地址 这种特殊的数据 
  
  指针变量的给值:
  int *p;  //野指针 --- 随机值 ---被当做了地址   
           //避免野指针 -- 一般初始化为NULL 
  *p     的执行顺序
  step1: 拿p中地址值 到内存中定位 
  step2: 从定位处开始，偏移基类型大小的一块空间sizeof(基类型)
  step3: 被当做了基类型变量来看 

  *p 整体就是一个基类型的变量   
  
  
3.核心用途(80%)
  被调修改主调 
  
  修改：
  1.修改谁，就传谁的地址 
  2.*p(间接访问)运算 
  
  
4.指针 + 一维整型数组  
  指针 操作 一维整型数组 

  int a[10];

  int *p = a; 

  //1.数组本身的特点 (连续性，单一性，有序性)
  //2.p+1   --- 偏移了一个积累性 

  通过指针访问到数组元素:
  *(p+i) <=> int型的变量   <=> a[i] <=>p[i]<=> *(a + i) 
5.指针运算 

 &
 * 
 p+1
 p++ 
 p-1
 p-- 
 
 关系运算 
   > >= < <= == != 
   p>q
 指针运算 ：指针互相不可做加法 +
           指针同类型互相可以做减法-
           非同类型 不可以
 p-q  
     前提: 同一类型的指针 
     表示之间差了几个基类型 
 p+q  //指针不能做加法运算 
 
 迭代
                     b
                    e     
 1 2 3 4 5 6 7 8 9 10
 
mid = begin + (e-b+1)/2;

int puts(const char *s); 
const char * s;
const int a; //只读变量 
int a = 10;
const int *p = &a; //表示 基类型 为只读 
p --- 指针变量 --本身的类型 int * 
a --- int型变量 --本身类型 int 
   
p = &a; 

const int *p = &a; 
int const *p = &a; //就近原则 -- 离谁近，就限定谁的  

int *const p = &a;  //限定p为只读 
const int * const p = &a;  //p不能被修改，指向的目标类型不能被修改 
                          //(是不能通过*p) 
   
   
   
    int puts(const char *s)
    {
    }//const char *s --在函数里面 不能通过*s修改到外面的数据 
    
    好处：
    1.可以接收 字符数组名   //char *
      也可以接收 字符串常量 //const char *
      提高了参数的适用性 
    2.避免了 可能出现的修改的操作 
      可以将 运行时的错误，提前到 编译时发现 
      
    const char * p 可以用来保存字符串常量的地址 
    

快速排序

   

const可以修饰任何一个变量名，使其变为只读类型的变量，在指针中，常有这两种用法：

int *const p = &a;  const int *p = &a;我们可以通过就近原则去区分const修饰的是什么，前一个const修饰的是p，使指针变量p为只读类型，后一个限定的是指针指向的基类型，不能通过*p去修改指针指向的值。。但是要注意的是，c语言中的const有一定的局限性，const int *p=&a,虽然不能用*p去修改，但可以通过a=1；对原数赋值进行值的修改。

好处：
    1.可以接收 字符数组名   //char *
      也可以接收 字符串常量 //const char *
      提高了参数的适用性 
    2.避免了 可能出现的修改的操作 
      可以将 运行时的错误，提前到 编译时发现