C语言复习笔记

最新推荐文章于 2024-06-27 17:39:56 发布

lonelysnowman

最新推荐文章于 2024-06-27 17:39:56 发布

阅读量1.5k

点赞数 3

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/lonelysnowman/article/details/125083952

版权

C语言复习笔记

一，数据类型

1)标识符

a. 概念: 编程时给变量或者函数起的名字就是标识符

b. C 语言规定，标识符可以是字母(A～Z，a～z)、数字(0～9)、下划线_组成的字符串，并且第一个字符必须是字母或下划线。

重点细节:

标识符的长度最好不要超过8位，因为在某些版本的C中规定标识符前8位有效，当两个标识符前8位相同时，则被认为是同一个标识符。
标识符是严格区分大小写的。
标识符最好选择有意义的英文单词组成。
标识符不能是C语言的关键字。

2)基本数据类型

3)格式化输出语句

格式为：printf(“输出格式符”，输出项)

C语言中的常用格式化符:

4)不可改变的常量

概念: 在程序执行过程中，值不发生改变的量称为常量。C语言的常量可以分为直接常量和符号常量**。**

整型常量：13、0、-13；
实型常量：13.33、-24.4；
字符常量：‘a’、‘M’
字符串常量：”I love imooc!”

在C语言中，可以用一个标识符来表示一个常量，称之为符号常量。符号常量在使用之前必须先定义，其一般形式为：

#define 标识符常量值

#include <stdio.h>
#define POCKETMONEY 10    //定义常量及常量值
int main()
{
    printf("小明今天又得到%d元零花钱\n", POCKETMONEY);
    return 0;  
}

5)自动类型转换

注意:自动转换发生在不同数据类型运算时，在编译的时候自动完成。

下图表示了类型自动转换的规则:

注: char类型数据转换为int类型数据遵循ASCII码中的对应值
注：字节小的可以向字节大的自动转换，但字节大的不能向字节小的自动转换

6)强制转换类型

强制类型转换是通过定义类型转换运算来实现的。其一般形式为：

(数据类型) (表达式)

输入结果：

注意:

数据类型和表达式都必须加括号
转换后不会改变原数据的类型及变量值，只在本次运算中临时性转换。
强制转换后的运算结果不遵循四舍五入原则。

二，C中的运算符

1)运算符的种类

※ 算术运算符

※ 赋值运算符

※ 关系运算符

※ 逻辑运算符

※ 三目运算符

2)算数运算符

除法运算中注意:

如果相除的两个数都是整数的话，则结果也为整数，小数部分省略，如8/3 = 2；而两数中有一个为小数，结果则为小数，如：9.0/2 = 4.500000。

取余运算中注意：

该运算只适合用两个整数进行取余运算，如：10%3 = 1；而10.0%3则是错误的；运算后的符号取决于被模数的符号，如(-10)%3 = -1;而10%(-3) = 1。

3)自增与自减运算符

4)赋值运算符

C语言中赋值运算符分为简单赋值运算符和复合赋值运算符

简单赋值运算符“=”
复合赋值运算符就是在简单赋值符“=”之前加上其它运算符构成，例如+=、-=、*=、/=、%=。

注意：复合运算符中运算符和等号之间是不存在空格的。

5)关系运算符

关系表达式的值是“真”和“假”，在C程序用整数1和0表示

注意：>=，<=，==，!=这种符号之间不能存在空格。

6)逻辑运算符

7)三目运算符

格式为：

表达式1 ? 表达式2 : 表达式3;

执行过程是：

先判断表达式1的值是否为真，如果是真的话执行表达式2；如果是假的话执行表达式3。

#include <stdio.h>
int main()
{
    //定义小编兜里的钱
    double money = 12     ; 
    //定义打车回家的费用
    double cost =  11.5     ;  
    printf("小编能不能打车回家呢："); 
    //输出y小编就打车回家了，输出n小编就不能打车回家
    printf("%c\n",money>=cost? 'y' : 'n'                      );
    return 0;
}

8)运算符大比拼之优先级比较

三，C程序结构语句

1)基础语句种类

if
if-else
while
do-while
for
switch
goto
break
continue

2)switch语句

#include <stdio.h>
int main() 
{
    int score = 87; //考试分数为87分 
    score /=10;
    switch(score)
    {
        /*想想以下代码为什么用这种方式；
          这种方式的好处？*/
        case 10:
        case 9:
            printf("等级A");
            break;
        case 8:
            printf("等级B");
            break; #include <stdio.h>
int main() 
{
    int score = 87; //考试分数为87分 
    score /=10;
    switch(score)
    {
        /*想想以下代码为什么用这种方式；
          这种方式的好处？*/
        case 10:
        case 9:
            printf("等级A");
            break;
        case 8:
            printf("等级B");
            break;                //这里是不是缺点什么？            
        case 7:
        case 6: 
            printf("等级C");
            break;                //这里是不是缺点什么？  
        default:
            printf("等级D");
            break;    
    }
    return 0;
}

特别注意!!!

在case后的各常量表达式的值不能相同，否则会出现错误。
在case子句后如果没有break;会一直往后执行一直到遇到break;才会跳出switch语句。

default(违约)一定要会拼写!!!

3)for语句

注意:

for循环中的“表达式1、2、3”均可可以缺省，但分号(;)不能缺省。
省略“表达式1（循环变量赋初值）”，表示不对循环变量赋初始值。
省略“表达式2(循环条件)”，不做其它处理，循环一直执行（死循环）。
省略“表达式3(循环变量增量)”，不做其他处理，循环一直执行（死循环）。
表达式1可以是设置循环变量的初值的赋值表达式，也可以是其他表达式。
表达式2一般是关系表达式或逻辑表达式，但也可是数值表达式或字符表达式，只要其值非零，就执行循环体。
各表达式中的变量一定要在for循环之前定义。(在表达式1 中 int 或者在for循环之前 int)

4)语句综合练习 99乘法表

#include <stdio.h>

int main() 

{ 
    // 定义相乘数字i,j以及结果result
    int i, j, result;
    for(i=9;i>=1;i--)
    {
         for(j=1;j<=i;j++)
         {
             result=i*j;
            printf("%d*%d=%d\t",i,j,result);
         }
        printf("\n");
    }
   return 0;
}

四，函数练习

1)自定义函数

注意:

先在main函数前声明自定义函数再将自定义函数代码写在main函数后

2)形参与实参

3)函数的返回值

概念:

函数的返回值是指函数被调用之后，执行函数体中的程序段所取得的并返回给主调函数的值。

例:

没有返回值的函数，返回类型为void

注意：void函数中可以有执行代码块，但是不能有返回值，另void函数中如果有return语句，该语句只能起到结束函数运行的功能。其格式为：return;

4)!!!递归函数!!!

例题一:

任务

小明为了学好英语，需要每天记单词，第一天记1个，第二天记2个依次类推，到第10天的时候小明一共记了多少个单词？

请用代码完成，算出小明第10天开始的时候会了多少个单词？

第10行根据注释提示，填写代码

输出结果为：

#include <stdio.h>
/* 定义获取单词数量的函数 */
int getWordNumber(int n)
{   
    if(n == 1)
    {
        return 1;    //第一天只会1个单词
    }
    else{
    int words=    getWordNumber (n-1)+n;
        return words ;       //到第天会的单词数量
    }
}
int main()
{
    int num = getWordNumber(10);     //获取会了的单词数量
    printf("小明第10天记了:%d个单词。\n", num);
    return 0;
}

例题二:

计算N的阶乘:

5)局部与全局

局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内。
全局变量也称为外部变量，它是在函数外部定义的变量。它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。

6)<目前还不了解原理,需要导师讲解>变量存储类别(艰涩难懂)

A. C语言根据变量的生存周期来划分，可以分为静态存储方式和动态存储方式。

静态存储方式：是指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量，如全局变量。

动态存储方式：是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的，通常包括：函数形式参数；自动变量；函数调用时的现场保护和返回地址等。

C语言中存储类别又分为四类：自动（auto）、静态（static）、寄存器的（register）和外部的（extern）。

注: 用extern声明的的变量是外部变量，外部变量的意义是某函数可以调用在该函数之后定义的变量。如：

7）内部函数与外部函数

内部函数，内部函数由static关键字来定义，因此又被称谓静态函数，形式为：static [数据类型] 函数名（[参数]）

外部函数 ，外部函数由extern关键字来定义，形式为： extern [数据类型] 函数名([参数])

调用外部函数：#include “外部函数名称”

五，数组

1）数组基础知识

声明数组：

数据类型数组名称[长度];

数组初始化：

数据类型数组名称[长度n] = {元素1,元素2…元素n};
数据类型数组名称[] = {元素1,元素2…元素n};
数据类型数组名称[长度n]; 数组名称[0] = 元素1; 数组名称[1] = 元素2; 数组名称[n-1] = 元素n;

注意:

1.数组的下标均以0开始；数组在初始化的时候，数组内元素的个数不能大于声明的数组长度；

2.如果采用第一种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0；

3.在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定。

2）数组作为函数参数

例题：

#include <stdio.h>
void replaceMax(int arr[],int value)
{
    int max = arr[0];
    int index = 0;
    int i;
    for(i=1;i<5;i++)
    {
        if(arr[i]>max)
        {
            max=arr[i];         //将数组中较大的数赋值给max
            index = i;  //记录当前索引
        }                
    }  
    arr[index] = value;
}

int main()
{
    int arr1[] = {10,41,3,12,22};
    int arr2[] = {1,2,3,4,5};
    int i;
    replaceMax(arr1 ,arr2[0]   ); //将数组arr1和数组arr2的第一个元素传入函数中
    for(i=0;i<5;i++)
    {
        printf("%d ",arr1[i]);                
    }
    return 0;    
}

3）数组应用：冒泡排序

例题：

#include <stdio.h>
int main()
{
    double arr[]={1.78, 1.77, 1.82, 1.79, 1.85, 1.75, 1.86, 1.77, 1.81, 1.80};
    int i,j;
    printf("\n************排队前*************\n");
    for(i=0;i<10;i++)
    {
        if(i != 9)   
            printf("%.2f, ", arr[i]);  //%.2f表示小数点后精确到两位
        else
            printf("%.2f", arr[i]);    //%.2f表示小数点后精确到两位
    }
    for(i=8; i>=0; i--)
    {
        for(j=0;j<=i;j++)
        {
            if(     arr[j]>arr[j+1]     )      //当前面的数比后面的数大时
            {
                double temp;    //定义临时变量temp
                temp = arr[j];//将前面的数赋值给temp
                arr[j] = arr[j+1] ;              //前后之数颠倒位置
                arr[j+1]=temp;             //将较大的数放在后面    
            }                 
        }                
    }
    printf("\n************排队后*************\n");
    for(i=0;i<10;i++)
    {
        if(i != 9)   
            printf("%.2f, ", arr[i]);  //%.2f表示小数点后精确到两位     
        else
            printf("%.2f", arr[i]);    //%.2f表示小数点后精确到两位
    }
    return 0;    
}

4）数组应用：元素查询

#include <stdio.h>
int getIndex(int arr[5],int value)
{

    int i;
    int index;
    for(i=0;i<5;i++)
    {
       /* 请完善数组查询功能 */
        if( arr[i] == value ) { 
        index = i ;
        break;
          
       
       
       
    }
    else {
        index=-1;
        
    }}
    return index;
}

int main()
{
    int arr[5]={3,12,9,8,6};
    int value = 8;
    int index = getIndex( arr , value );      //这里应该传什么参数呢？
    if(index!=-1)
    {
        printf("%d在数组中存在，下标为：%d\n",value,index);             
    }
    else
    {
        printf("%d在数组中不存在。\n",value);    
    }
    return 0;    
}

5) 字符串数组

定义格式：

1、char 字符串名称[长度] = “字符串值”;

2、char 字符串名称[长度] = {‘字符1’,‘字符2’,…,‘字符n’,‘\0’};

注意：

1、[]中的长度是可以省略不写的；

2、采用第2种方式的时候最后一个元素必须是’\0’，'\0’表示字符串的结束标志；

3、采用第2种方式的时候在数组中不能写中文。

在输出字符串的时候要使用：printf(“%s”,字符数组名字);或者puts(字符数组名字);。例如：

6）字符串函数

1.strlen()获取字符串的长度，在字符串长度中是不包括‘\0’而且汉字和字母的长度是不一样的。比如：

但是sizeof函数是包括 \0 的！

2.strcmp()在比较的时候会把字符串先转换成ASCII码再进行比较,返回的结果为0表示s1和s2的ASCII码相等,返回结果为1表示s1比s2的ASCII码大,返回结果为**-1表示s1比s2的ASCII码小**，例如：

3.strcpy()拷贝之后会覆盖原来字符串且不能对字符串常量进行拷贝

4.strcat在使用时s1与s2指的内存空间不能重叠，且s1要有足够的空间来容纳要复制的字符串

7)多维数组

相当于数组里继续存储数组！！！！

初始化方式：

1、数据类型数组名称[常量表达式1][常量表达式2]…[常量表达式n] = {{值1,…,值n},{值1,…,值n},…,{值1,…,值n}};

2、数据类型数组名称[常量表达式1][常量表达式2]…[常量表达式n]; 数组名称[下标1][下标2]…[下标n] = 值;

多维数组初始化要注意以下事项：

1、采用第一种始化时数组声明必须指定列的维数。因为系统会根据数组中元素的总个数来分配空间，当知道元素总个数以及列的维数后，会直接计算出行的维数；

2、采用第二种初始化时数组声明必须同时指定行和列的维数。

六，指针

————————————————

借鉴声明：指针笔记参考此博主讲的太细了非常好！！！！

版权声明：本文为CSDN博主「ZackSock」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ZackSock/article/details/101594794

1）变量和地址

&：取地址符 and ！！！

例：

int x;

int* px = &x;

代表px为 int* 类型的指针，为变量x 的地址。

x为 int 类型的变量。

printf(“%d”,x); 与 printf(“%d”,*px); 输出结果相同

均为x的值！！！

2) **“&”和“*”的结合方向**

“&”和“”都是右结合的。假设有变量 x = 10，则&x 的含义是，先获取变量 x 的地址，再获取地址中的内容。因为“&”和“*”互为逆运算，所以 x = *&x。

3）指针变量的初始化

一定进行初始化避免 野指针

指针变量与其它变量一样，在定义时可以赋值，即初始化。也可以赋值“NULL”或“0”，如果赋值“0”，此时的“0”含义并不是数字“0”，而是 NULL 的字符码值。

//利用取地址获取 x 的地址，在指针变量 px 定义时，赋值给 px
int x;
int *px = &x;
//定义指针变量，分别赋值“NULL”和“0”
int *p1= NULL, *p2 = 0;

4)指针运算

1.赋值运算

指针变量可以互相赋值，也可以赋值某个变量的地址，或者赋值一个具体的地址

int *px, *py, *pz, x = 10;
//赋予某个变量的地址
px = &x;
//相互赋值
py = px;
//赋值具体的地址
pz = 4000;

2.指针与整数的加减运算

指针变量的自增自减运算。指针加 1 或减 1 运算，表示指针向前或向后移动一个单元（不同类型的指针，单元长度不同）。这个在数组中非常常用。
指针变量加上或减去一个整形数。和第一条类似，具体加几就是向前移动几个单元，减几就是向后移动几个单元。

//定义三个变量，假设它们地址为连续的，分别为 4000、4004、4008
int x, y, z;

//定义一个指针，指向 x
int *px = &x;

//利用指针变量 px 加减整数，分别输出 x、y、z
printf("x = %d", *px);		//因为 px 指向 x，所以*px = x

//px + 1，表示，向前移动一个单元（从 4000 到 4004）
//这里要先(px + 1)，再*(px + 1)获取内容，因为单目运算符“*”优先级高于双目运算符“+”
printf("y = %d", *(px + 1));		
printf("z = %d", *(px + 2));

3.关系运算

假设有指针变量 px、py。

px > py 表示 px 指向的存储地址是否大于 py 指向的地址
px == py 表示 px 和 py 是否指向同一个存储单元
px == 0 和 px != 0 表示 px 是否为空指针

5)指针与数组

在数组中，数组名即为该数组的首地址，结合上面指针和整数的加减，就可以实现指针访问数组元素。

定义了一个数组 nums，在定义时分配了 10 个连续的int 内存空间。而一个数组的首地址即为数组名nums，或者第一个元素的首地址也是数组的首地址。那么有两种方式让指针变量 p 指向数组 nums：

int nums[10], *p;
//数组名即为数组的首地址
p = nums;
//数组第一个元素的地址也是数组的首地址
p = &nums[0];

上面两句是等价的

如下几个操作，用指针操作数组：

*p = 1，此操作为赋值操作，即将指针指向的存储空间赋值为 1。此时 p 指向数组 nums 的第一个元素，则此操作将 nums 第一个元素赋值为 0，即 nums[0] = 1。
p + 1，此操作为指针加整数操作，即向前移动一个单元。此时 p + 1 指向 nums[0]的下一个元素，即 nums[1]。通过p + 整数可以移动到想要操作的元素（此整数可以为负数）。
如上面，p（p + 0）指向 nums[0]、p + 1 指向 nums[1]、、、类推可得，p+i 指向 nums[i]，由此可以准确操作指定位置的元素。
在 p + 整数的操作要考虑边界的问题，如一个数组长度为 2，p+3 的意义对于数组操作来说没有意义。

以上内容很重要！！！

下面写一段代码，用指针访问数组的元素：

//定义一个整形数组，并初始化
int nums[5] = {4, 5, 3, 2, 7};

//定义一个指针变量 p，将数组 nums 的首地址赋值给 p，也可以用p = &nums[0]赋值
int *p = nums, i;			//i 作为循环变量

//p 指向数组第一个元素（数组首地址），我们可以直接用间接寻址符，获取第一个元素的内容
printf("nums[0] = %d\n", *p);			//输出结果为 nums[0] = 4

//我们可以通过“p + 整数”来移动指针，要先移动地址，所以 p + 1 要扩起来
printf("nums[1] = %d\n", *(p + 1));		//输出结果为 nums[1] = 5

//由上面推导出*(p + i) = nums[i]，所以我们可以通过 for 循环变量元素
for(i = 0; i < 5; i++){
	printf("nums[%d] = %d", i, *(p + i));
}

注：数组名不等价于指针变量，指针变量可以进行 p++和&操作，而这些操作对于数组名是非法的。数组名在编译时是确定的，在程序运行期间算一个常量。

6)多级指针

数据类型 **二级指针名;

和指针变量的定义类似，由于是右结合的，所以pp 相当于*(p)。在本次定义中，二级指针的变量名为 pp，而不是**p。多级指针的定义就是定义时使用多个“”号。

//定义普通变量和指针变量
int *pi, i = 10;
//定义二级指针变量
int **ppi;

//给指针变量赋初值
pi = &i;

//给二级指针变量赋初值
ppi = &pi;

//我们可以直接用二级指针做普通指针的操作
//获取 i 的内容
printf("i = %d", **ppi);
//获取 i 的地址
printf("i 的地址为%d", *ppi);

注：在初始化二级指针 ppi 时，不能直接 ppi = &&i，因为&i 获取的是一个具体的数值，而具体数字是没有指针的。

7)指针数组

指针变量和普通变量一样，也能组成数组，指针数组的具体定义如下：

数据类型 *数组名[指针数组长度];

//定义一个数组
int nums[5] = {2, 3, 4, 5, 2}, i;

//定义一个指针数组
int *p[5];

//定义一个二级指针
int **pp;

//循环给指针数组赋值
for(i = 0; i < 5; i++){
	p[i] = &nums[i];
}

//将指针数组的首地址赋值给 pp，数组 p 的数组名作为 p 的首地址，也作为 p 中第一个元素的地址。
//数组存放的内容为普通变量，则数组名为变量的指针；数组存放的内容为指针，则数组名为指针的指针。
pp = p;

//利用二级指针 pp 输出数组元素
for(i = 0; i < 5; i++){
	//pp == &p[0] == &&nums[0]，nums[0] == *p[0] == **pp
	printf("%d", **pp);
	
	//指针变量+整数的操作，即移动指针至下一个单元
	pp++;
}

8)多维数组的指针

在学习指针与数组的时候，我们可以如下表示一个数组：

int nums[5] = {2, 4, 5, 6, 7};
int *p = nums;

//----------------------------（分界线)

//定义一个二维数组
int nums[2][2] = {
	{1, 2},
	{2, 3}
};

//此时 nums[0]、和 nums[1]各为一个数组
int *p[2] = {nums[0], nums[1]};

//我们可以用指针数组 p 操作一个二维数组

//p 为数组 p 的首地址，p[0] = nums[0] = *p，**p = nums[0][0]
printf("nums[0][0] = %d", **p);

//指针 + 整数形式，p+1 移动到 nums 的地址，*(p +1) = nums[1]，则**(p + 1) = nums[1][0]
printf("nums[1][0] = %d", **(p + 1));

//先*p = nums[0]，再*p + 1 = &nums[0][1]，最后获取内容*(*p + 1)即为 nums[0][1]
printf("nums[0][1] = %d", *(*p + 1));

注：为什么*p + 1 = &nums[0] [1 ]，而不是 nums[1]。p 获得的是一个一维数组，而 int 数组 + 1 的跨度只有 4 个字节，也就是一个单元。前面 p 是一维数组的指针，其跨度为一个数组。所以p + 1 = &nums[0 ] [ 1]，而 p + 1 = nums[1]。

9）指针与函数

1.函数参数为指针

用来交换两个变量的内容

void swap(int *x, int *y);
void main(){
	int x = 20, y = 10;
	swap(&x, &y);
	printf("x = %d, y = %d", x ,y);
}
void swap(int *x, int *y){
	int t;
	t = *x;
	*x = *y;
	*y = t;
}

这里传入的参数为指针，所以调用 swap 方法后 x，y 的内容发生了交换。如果直接传入 x，y，那么交换只在 swap 中有效，在 main 中并没有交换。

2.函数的返回值为指针

数据类型 *函数名(参数列表){
函数体
}

//例如：
int s;
int *sum(int x, int y){
	s = x + y;
	return &s;
}
int s;
void mian(){
	int *r = sum(10, 9);
	printf("10 + 9 + %d", *r);
}
int *sum(int x, int y){
	s = x + y;
	return &s;
}

3.指向函数的指针

#include <string.h>
/**
*	定义一个方法，传入两个字符串和一个函数指针 p，用 p 对两个字符串进行操作
*/
void check(char *x, char *y, int (*p)());
void main(){
	//string.h 库中的函数，使用之前需要声明该函数。字符串比较函数
	int strcmp();
	char x[] = "Zack";
	char y[] = "Rudy";
	
	//定义一个函数指针
	int (*p)() = strcmp;

	check(x, y, p);
}
void check(char *x, char *y, int (*p)()){
	if(!(*p)(x, y)){
		printf("相等");
	}else{
		printf("不相等");
	}
}

利用函数指针调用方法具体操作如下：

(*p)(x, y);

lonelysnowman

关注

3
点赞
踩
45

收藏

觉得还不错? 一键收藏
0
评论
C语言复习笔记

C语言，编程入门基础。初学者必备！！！
复制链接

扫一扫

C语言复习笔记

C语言复习笔记

一，数据类型

1)标识符

2)基本数据类型

3)格式化输出语句

4)不可改变的常量

5)自动类型转换

6)强制转换类型

二，C中的运算符

1)运算符的种类

2)算数运算符

3)自增与自减运算符

4)赋值运算符

5)关系运算符

6)逻辑运算符

7)三目运算符

8)运算符大比拼之优先级比较

三，C程序结构语句

1)基础语句种类

2)switch语句

3)for语句

4)语句综合练习 99乘法表

四，函数练习

1)自定义函数

2)形参与实参

3)函数的返回值

4)!!!递归函数!!!

5)局部与全局

6)<目前还不了解原理,需要导师讲解>变量存储类别(艰涩难懂)

7）内部函数与外部函数

五，数组

1）数组基础知识

2）数组作为函数参数

3）数组应用：冒泡排序

4）数组应用：元素查询

5) 字符串数组

6）字符串函数

7)多维数组

六，指针

1）变量和地址

2) “&”和“*”的结合方向

3）指针变量的初始化

4)指针运算

1.赋值运算

2.指针与整数的加减运算

3.关系运算

5)指针与数组

6)多级指针

7)指针数组

8)多维数组的指针

9）指针与函数

1.函数参数为指针

2.函数的返回值为指针

2) **“&”和“*”的结合方向**