指针：

指针的重要性：

• 表示一些复杂的数据结构。
• 快速传输数据
• 使函数返回一个以上的值
• 能直接访问硬件
• 能够方便地处理字符串
• 是理解面向对象语言引用的基础

指针的定义

地址

-----内存单元的编号

-----从零开始的非负整数

-----范围：4G【0--4G-1】

指针

-----指针就是地址，地址就是指针。

-----指针变量就是存放地址的变量。

-----指针和指针变量是两个不同的概念。

-----但是注意，通常在叙述时会把指针变量简化为指针，实际上他们的含义不同。

-----指针的本质就是一个操作受限的非负整数。

指针的分类

1. 基本类型指针[重点]

#include <stdio.h>

int main(void)

{

int * p;//p是变量的名称，int * 表示p变量存放的是int类型变量的地址

//int *p;不表示定义了一个名字叫做*p的变量

//int *p;应该理解为：p是变量名，p变量的数据类型是int *类型

// 所谓int *类型就是存放int变量地址的类型

int i = 3;

int j;

p = &i;//正确

/*

1.p保存了i的地址，因此p指向i

2.p不是i，i不是p，更准确地说,修改i的值不改变p的值，修改p的值不改变i的值。

3.如果一个指针变量指向了某个普通变量，则

*指针变量 就完全等同于 普通变量。

例子：

如果p是一个指针变量，并且p存放了普通变量i的地址

则p指向了普通变量i

*p 就完全等同于 i

或者说:在所有出现*p的地方都可以替换为i

在所有出现i的地方都可以替换为*p

*p 就是以p的内容为地址的变量

*/

j = *p;

printf("i=%d j=%d",i,j);

return 0;

}

---------指针热身---------

#include <stdio.h>

int main(void)
{
    int * p;//p是变量的名称，int* 表示p变量存放的是int类型变量的地址
    int i = 3;

    //p = i;//错误,因为类型不一致，p只能存放int类型变量的地址，不能存放int变量的值
    //p = 5;//错误
    p = &i;//正确

    return 0;
}

-------经典指针程序：互换两数的值-------

#include <stdio.h>

void change_1(int ,int);
void change_2(int *,int *);
void change_3(int *,int *);

int main(void)
{
    int a =3;
    int b =5;
    
    change_3(&a,&b);
    
    printf("a=%d  b=%d",a,b);
    return 0;
}

//可以完成互换的功能
void change_3(int *p,int *q)
{
    int t;//如果要互换*p和*q的值，则必须定义成int，不能定义成int *,否则语法出错

    t = *p;//p是 int *,*p是int
    *p = *q;
    *q = t;
    return;
}

//该函数不能互换a,b的值
void change_2(int *p,int *q)
{
    int *t;

    t = p;
    p = q;
    q = t;
    return;
}

//该函数不能互换a,b的值
void change_1(int a,int b)
{
    int t;

    t = a;
    a = b;
    b = t;
    return;
}

附注：

*的含义：

1.乘法

2.定义指针变量

int *p;//定义了一个名字叫p的变量，int *表示p只能存放int变量的地址

3.指针运算符

该运算符放在已经定义好的指针变量的前面

如果p是一个已经定义好的指针运算

则*p表示以p的内容为地址的变量

如何通过被调函数修改主调函数的值

1. 实参必须为该普通变量的地址
2. 形参必须为指针变量
3. 在被调函数中通过
   *形参名 =.....
   的方式就可以修改主调函数相关变量的值

2. 指针和数组

• 指针和一维数组

  这里有一个链接讲得比较详细：www.cnblogs.com/fengxing999…

  • 数组名 一维数组 数组名是个指针常量 它存放的是一维数组第一个元素的地址

    #include <stdio.h>
    
    
    int main(void)
    {
        int a[5];//a是数组名 5是数组元素的个数 元素就是变量
        int b[5];
    
        printf("%#X\n",&a);
        printf("%#X\n",&a[0]);
        return 0;
    }
    /*输出结果为
    
    0X8C3FF680
    0X8C3FF680
    
    */
    

  • 下标和指针的关系

  如果p是一个指针变量，则：p[i]永远等价于*(p+1)

  • 确定一个一维数组需要两个参数

    

    结果：

    

    

    • 数组第一个元素的地址

    • 数组的长度

  • 指针变量的运算 指针变量不能相加 不能相乘 也不能除 如果两个指针变量指向的是同一块连续空间中的不同存储关元 则这两个变量才可以相减

  • 一个指针变量一共占几个字节（一个变量的地址是用该变量的首字节的地址来表示的）

    预备知识：

    s i z e o f ( 数 据 )

    功能 : 返回值就是该数据类型所占的字节数。

    例子 ：sizeof(int) = 4 ,sizeof(char) = 1 ,sizeof(double) = 8

    s i z e o f ( 变 量 名 )

    功能：返回值是该函数所占的字节数

    • 假设p指向char类型变量(1个字节)

      假设q指向int类型变量(4个字节)

      假设r指向double类型变量(8个字节)

      p q r 本身所占的字节数是一样的

• 指针和二维数组

3. 指针和函数

4. 指针和结构

5. 多级指针

举例：

代码：

#include<stdio.h>
#include <malloc.h> //不能省

int main(void)
{
    int i=10;
    int *  p = &i;//p
    int ** q = &p;
    int ***r = &q; 

    //r=&p; //error 因为r是int ***类型，r只能存放int **类型变量的地址
    //此处可以借助if(***r= *p)等来理解。
    printf("i = %d\n",***r);
    
    return 0;
}

代码：

#include<stdio.h>
#include <malloc.h> //不能省

void f(int ** q)
{
    **q = 100;
    //*q就是p
}
int main(void)
{

    int i=10;
    int *  p = &i;//p是int *类型，&p是int **类型 
    printf("%d\n",*p);
    f(&p);
    printf("%d",*p);
    return 0;
}

动态内容分配

传统数组的缺点

1. 数组长度必须事先制定，且只能是长整数，不能是变量

例子：

   int a[5];//OK
   int len = 5; int a[len];//error         

2. 传统形式的数组，该数组的内存程序员无法手动释放

在一个函数运行期间，系统为该数组分配的存储空间会一直存在，直到该函数函数运行完毕时，数组的空间才会被系统释放。

3. 数组的长度一旦定义就不能再改变 数组的长度不能在函数运行的过程中，动态地扩充或缩小。

4. A函数定义的数组，在A函数运行期间可以被其他函数使用，但A函数运行完毕后，A函数中的数组将无法被其他函数使用 传统方式定义的数组不能跨函数使用

为什么需要动态分配内存

动态数组很好地解决了传统数组（静态数组）的四个缺陷

(该函数没有实际意义) 代码：

/*
malloc是memory(内存)allocate(分配)的缩写
*/
#include<stdio.h>
#include <malloc.h> //不能省

int main(void)
{
    int i =5;//分配了4个字节 静态分配
    int * p = (int *)malloc(4);
    /*
        1. 要使用malloc函数，必需添加malloc.H这个头文件
        2. malloc函数只有一个形参，并且形参是整型
        3. 4表示请求系统为本程序分配四个字节
        4. malloc函数只能返回第一个字节的地址
        5. 12行分配了8个字节,p变量占4个字节，p所指向的内存占4个字节
        6. p本身所占的内存是静态分配的，p所指向的内存是动态分配的
    */
   *p = 5;//*p代表的就是一个int变量，只不过*p这个整形变量的内存分配方式和9行的i变量的分配方式不同。
   free (p);//free (p)表示把p所指向的内存释放掉，p本身的内存是静态的，不能由程序员手动释放，p本身的内存只能在p变量所在的函数运行终止时由系统自动释放
   printf("同志们好！");

    return 0;
}

代码2：

#include<stdio.h>
#include <malloc.h> //不能省
void f(int*q)
{
    // *p = 200;
    //  q = 200;
    //**q = 200;
    *q = 200;
   // free(q);//把q所指向的内存释放 本语句必须注释掉，否则会出错。
}
int main(void)
{
    int *p = (int *)malloc(sizeof(int));//sizeof(int)返回值是int所占的字节数
    *p = 10;

    printf("%d\n",*p);
    f(p);//p是int *类型
    printf("%d\n",*p);
    return 0;
}

动态内存分配举例_动态内存的构造

代码如下：

#include<stdio.h>
#include <malloc.h> //不能省

int main(void)
{
    int a[5];//如果int占4个字节的话，则本数组总共包含有20个字节，每4个字节被当作了一个int变量来使用
    int len;
    int * pArr;
    int i;

    //动态地构造一维数组
    printf("请输入你要存放的元素的个数：");
    scanf("%d", &len);
    pArr = (int *)malloc(4*len);//本行动态的构造了一个一维数组类似于 int pArr[len];该一维数组的数组名是 pArr ,该一维数组长度是 len 。
    //对一维数组进行操作如：对动态一维数组进行赋值
    for(i=0; i<len;++i)
        scanf("%d",&pArr[i]);
    //对动态一维数组进行输出：
    printf("一维数组的内容是：\n");
    for(i=0; i<len;++i)
        printf("%d\n",pArr[i]);

    free(pArr);//释放掉动态分配的数组

    return 0;
}

静态内存和动态内存的比较

静态内存由系统自动分配，由系统自动释放

静态内存是在栈分配的，

动态内存是由程序员手动分配，手动释放

动态内存是在堆分配的

跨函数使用内存的问题

静态内存跨函数使用

代码如下：

#include<stdio.h>

void f(int ** q)//q是个指针变量，无论q是什么类型的指针变量，都只占四个字节
{
    int i = 5;
    //*q 等价于p q和**q都不等价于p
    //*q = i;//error因为*q = i;等价于 p = i;
    *q = &i; 
}

int main(void)
{
    int *p ;
    
    f(&p);//该语句执行完毕，i，**q的内存都被释放掉
    printf("%d",*p);//本语句语法没有问题，但逻辑上有问题。
    
    return 0;
}

动态内存跨函数使用： 代码如下：

#include<stdio.h>
#include<malloc.h>

void f(int ** q)
{
    *q = (int *)malloc(sizeof(int));//sizeof(数据类型)
    //等价于 p = (int *)malloc(sizeof(int));
    //q = 5;
    //*q = 5;//p = 5;
    **q = 5;//*p=5;

}

int main(void)
{
    int *p ;
    
    f(&p);
    printf("%d\n",*p);
    
    return 0;
}

C Primer Plus课后习题

题目：

1. 打印的内容：

8 8

4 4

0 0

2 2

2. 数组ref有4个元素

3. 数组名ref指向该数组的第一个元素表达式

ref+1指向该数组的第2个元素，++ref应该是错误的

4.

a.12和16

b.12和14

5. a.12和16

b.12和14

该篇文章代码来源：www.bilibili.com/video/BV1os… (如有侵权请在文章下留言)