c语言重点知识点总结

2024-04-13 总结

  上学的时候,说起知识点,应该没有人不熟悉吧?知识点是指某个模块知识的重点、核心内容、关键部分。还在苦恼没有知识点总结吗?下面是小编帮大家整理的c语言重点知识点总结,欢迎大家分享。

  c语言重点知识点总结 1

  ◆知识点1:交换两个变量值的方法

  1)采用第三方变量(最容易想到的方法)

  2)采用加减法进行值得交换(面试时常用**)

  代码如下:

  b = a - b;

  a = a - b;

  b = a + b;

  3)采用按位异或的位方式

  代码如下:

  a = a^b;

  b = a^b;

  a = a^b;

  ◆知识点2:取语言重点知识点总结余运算%的结果与被除的符号相同,结果为两个正数取余后前面加符号

  ◆知识点3:sizeof的使用

  sizeof是一种运算符不要想当然理解为函数

  sizeof使用时可以不加()

  sizeof可以加变量、常量、数据类型

  跟数据类型是必须加()

  ◆知识点4:static和 extern区别是能否进行跨文件访问

  ①函数

  ②变量

  1、对函数的作用:

  外部函数:定义的函数能被本文件和其他文件访问

  内部函数:定义的函数只能被本文件访问

  默认情况下,所有函数都是外部函数(相当于带关键字extern),所以可以省略

  extern作用:

  完整的定义和引用一个外部函数都加extern

  引用时也是默认是外部函数所以也省略extern

  static作用:定义一个内部函数

  使用:static返回类型函数名(参数列表)

  不能被其他文件调用

  一个项目中,本文件的外部函数名不能和其他文件的外部函数同名(error)

  本文件中的内部函数(static)可以和其他文件的函数名同名的

  2、对变量的作用:

  全局变量分为两种:

  外部变量:定义的变量可以被其他文件访问

  ①默认情况下所有的全局变量都是外部变量

  ②不同文件中的同名外部变量都代表同一个

  ③定义一个外部变量不加extern,声明才加extern

  同样的声明是没有错误的

  内部变量:定义的变量不能被其他文件访问

  不同文件的同名内部变量互不影响

  ◆知识点5:数组的几种初始化方式如下:

  int a[3] = {10, 9, 6};

  int a[3] = {10,9};

  int a[] = {11, 7, 6};

  int a[4] = {[1]=11,[0] = 7};(知道有此种初始化方式即可)

  ◆知识点6:数组的内存分析和注意点

  存储空间的划分(内存的分配是从高地址到低地址进行的,但一个数组内部元素又是从低到高进行的)【注:对于以后学习重要】

  数组名的作用,查看元素地址

  注意数组不要越界

  ◆知识点7:字符串知识点

  "123”其实是由’1’、’2’、’3’、’’组成

  字符串的输出”%s”,’’是不会输出的

  ◆知识点8 : 字符串处理函数:strlen()

  计算的是字符数,不是字数

  计算的字符不包括’’,一个汉字相当于3个字符

  例子:"哈haha" 字符数为7

  从某个地址开始的数字符个数,知道遇到’’为止

  指针部分在C语言中占据重要地位,所以重点学习与整理了指针的知识:

  ◆知识点9:指针定义的格式

  变量类型 *变量名

  如:Int *p

  ◆知识点10:指针作用

  能够根据一个地址值,访问对应的.存储空间

  例:

  Int *p;

  Int a = 90;

  P = &a;

  *p = 10;//把10赋值给p所指的存储空间

  ◆知识点11:指针使用注意

  Int *p只能指向int类型的数据

  指针变量只能存储地址

  指针变量未经初始化不要拿来间接访问其他存储空间

  ◆知识点12:指针与数组

  遍历数组

  int ages[5] = {10, 4, 9, 44, 99};

  for(int i = 0; i<5; i++)

  {

  printf("%d ", ages[i]);

  }

  使用指针遍历数组:

  int *p;

  // 指针变量P指向了数组的首地址

  p = &ages[0];

  // 使用指针遍历数组

  for(int i = 0; i<5; I++)

  {

  printf("ages[%d] = %d ", i, *(p + i));

  }

  注:指针+ 1取决于指针的类型

  注:数组的访问方式

  数组名[下标]

  指针变量名[下标]

  *(p + i)

  ◆知识点12:指针与字符串

  定义字符串的两种方式:

  1、利用数组

  Char name[] = “Andyzhao”

  特点:字符串里的字符可以修改

  适用场合:字符串内容需要经常修改

  2、利用指针

  Char *name = “itcast”

  特点:字符串是一个常量,字符串里面的字符不能修改

  使用场合:字符串的内容不需要修改,而这个字符串经常使用

  ◆知识点13:预处理指令(三种):

  宏定义

  条件编译

  文件包含

  1、宏定义的配对使用和带参数的宏:

  #define

  #undef

  带参数的宏:

  #define sum(v1,v2) ((v1) + (v2))//括号是必须的

  例如:

  #define pingfang(a) a*a

  #define pingfang(a) (a*a)

  调用时

  pingfang(10)/pingfang(2)//不正确

  pingfang(5+5)//不正确

  带参数的宏效率比函数高

  2、条件编译(一般是判断宏的值)

  #if 条件

  #elif 条件

  #else

  #endif(非常重要)不然后面的代码全部无效

  3、文件包含:

  <>表示系统自带的文件,""表示自定义文件

  不允许循环包含,比如ah包含bh,bh又包含ah

  ◆知识点14:typedef 只是给类型起了个别名并不是定义新类型

  struct Student{

  int age;

  char *name;

  };

  typedef struct Student Student;

  等价于

  typedef struct Student{

  int age;

  char *name;

  }Student;

  也等价于

  typedef struct {

  int age;

  char *name;

  }Student;

  类似的给枚举类型起名

  typedef enum Sex

  {

  Man,Women

  }Sex;

  下面这种情况的写法比较特殊

  //下面是函数指针类型的自定义数据类型,返回值类型和参数类型要匹配

  #include

  typedef int (*TypeFuncPointer)(int, int);

  int add(int a, intb)

  {

  return a + b;

  }

  int minus(int a, intb)

  {

  return a - b;

  }

  int main()

  {

  TypeFuncPointer p = add;//使用自定义类型

  TypeFuncPointer p2 = minus;//使用自定义类型

  printf("add = %d ",p(1, 2));

  printf("minus = %d ",p2(1, 2));

  return 0;

  }

  下面是定义结构体的指针类型

  typedef struct Student{

  int age;

  char *name;

  }*PtrStu;

  //使用方式

  Student stu ={18, "zhangsan"};

  PtrStu p = &stu;

  宏定义也是可以为类型起名的

  #define Integer int

  相当于

  typedef int Integer

  注意和typedef的区别

  例如:

  typedef char * String

  #define String2char *

  c语言重点知识点总结 2

  C语言位运算基础知识

  1、程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算说穿了,就是直接对整数在内存中的二进制位进行操作。

  2、与运算:只有前后两个运算数都是 1 的时候结果才是1。

  3、或运算:有1位为1,结果便为1。

  4、异或:不相同则为1。

  5、取反运算:将1变为0,将0变为1。

  6、移位运算:左移则乘2,右移则除2。如果超出边界,则舍弃。

  c语言入门知识:位运算

  一、位运算符

  在计算机中,数据都是以二进制数形式存放的,位运算就是指对存储单元中二进制位的运算。C语言提供6种位运算符。

  二、位运算

  位运算符 & |~<< >> ∧ 按优先级从高到低排列的顺序是:

  位运算符中求反运算“~“优先级最高,而左移和右移相同,居于第二,接下来的顺序是按位与 “&“、按位异或 “∧“和按位或 “|“。顺序为~ << >> & ∧ | 。

  例1:左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位,由“<<”右边的`数指定移动的位数,高位丢弃,低位补0。

  例如:

  a<<4

  指把a的各二进位向左移动4位。如a=00000011(十进制3),左移4位后为00110000(十进制48)。

  例2:右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位,“>>”右边的数指定移动的位数。

  例如:

  设 a=15,a>>2

  表示把000001111右移为00000011(十进制3)。

  应该说明的是,对于有符号数,在右移时,符号位将随同移动。当为正数时,最高位补0,而为负数时,符号位为1,最高位是补0或是补1 取决于编译系统的规定。

  例3:设二进制数a是00101101 ,若通过异或运算a∧b 使a的高4位取反,低4位不变,则二进制数b是。

  解析:异或运算常用来使特定位翻转,只要使需翻转的位与1进行异或操作就可以了,因为原数中值为1的位与1进行异或运算得0 ,原数中值为0的位与1进行异或运算结果得1。而与0进行异或的位将保持原值。异或运算还可用来交换两个值,不用临时变量。

  如 int a=3 , b=4;,想将a与b的值互换,可用如下语句实现:

  a=a∧b;

  b=b∧a;

  a=a∧b;

  所以本题的答案为: 11110000 。

  c语言重点知识点总结 3

  基本问题

  在计算机中,所有的数据都是存放在存储器中的,不同的数据类型占有的内存空间的大小各不相同。内存是以字节为单位的连续编址空间,每一个字节单元对应着一个独一的编号,这个编号被称为内存单元的地址。比如:int 类型占 4 个字节,char 类型占 1 个字节等。系统在内存中,为变量分配存储空间的首个字节单元的地址,称之为该变量的地址。地址用来标识每一个存储单元,方便用户对存储单元中的数据进行正确的访问。在高级语言中地址形象地称为指针。

  地址与指针

  指针相对于一个内存单元来说,指的是单元的地址,该单元的内容里面存放的是数据。在 C 语言中,允许用指针变量来存放指针,因此,一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。

  变量及其定义

  指针变量是存放一个内存地址的变量,不同于其他类型变量,它是专门用来存放内存地址的,也称为地址变量。定义指针变量的一般形式为:类型说明符*变量名。

  类型说明符表示指针变量所指向变量的数据类型;*表示这是一个指针变量;变量名表示定义的指针变量名,其值是一个地址,例如:char*p1;表示 p1 是一个指针变量,它的值是某个字符变量的地址。

  1.1 指针与指针变量的概念,指针与地址运算符

  1.在C语言中,指针是指一个变量的地址,通过变量的地址″指向″的位置找到变量的值,这种″指向″变量地址可形象地看作″指针″。用来存放指针的变量称为指针变量,它是一种特殊的变量,它存放的是地址值。

  2.定义指针变量的一般形式为:

  类型名 *指针变量1,*指针变量2,…;

  ″类型名″称为″基类型″它规定了后面的指针变量中存放的数据类型,″*″号表明后面的″指针变量1″,″指针变量2″等是指针变量,″*″号在定义时不能省略,否则就会变成一般变量的定义了。″指针变量1″,″指针变量2″等称为指针变量名。

  3.一个指针变量只能指向同一类型的变量。

  4.与指针和指针变量有关的两个运算符:

  (1)*:指针运算符(或称″间接访问″运算符)

  (2)&:取地址运算符

  通过*号可以引用一个存储单元,如有如下定义:

  int i=123,*p,k;

  则 p=&I;或k=*p;或k=*&I;都将变量i中的值赋给k。

  *p=10;或*&i=10;都能把整数10赋给变量i。这里,等号左边的表达式*p和*&i都代表变量i的存储单元。

  1.2 变量、数组、字符串、函数、结构体的指针以及指向它们的指针变量

  1.变量的指针和指向变量的指针变量。

  2.数组的指针和指向数组的指针变量。

  所谓数组的指针是指数组的起始地址,数组元素的指针是数组元素的地址。

  C语言规定数组名代表数组的首地址,也就是第一个元素的地址。

  3.字符串的指针和指向字符串的指针变量。

  我们可以通过定义说明一个指针指向一个字符串。

  C语言将字符串隐含处理成一维字符数组,但数组的每个元素没有具体的名字,这一点跟字符数组不一样。要引用字符串中的某个字符,只能通过指针来引用:*(s+0),*(s+1),…,*(s+n)。

  4.函数的指针和指向函数的指针变量。

  指向函数的指针变量的一般形式为 :

  数据类型标识符 (*指针变量名)();

  这里的″数据类型标识符″是指函数返回值的类型。

  函数的调用可以通过函数名调用,也可以通过函数指针调用(即用指向函数的指针变量调用)。

  指向函数的指针变量表示定义了一个指向函数的指针变量,它不是固定指向哪一个函数,而只是定义了这样的一个类型变量,它专门用来存放函数的入口地址。在程序中把哪一个函数的地址赋给它,它就指向哪一个函数。在一个程序中,一个指针变量可以先后指向不同的函数。

  在给函数指针变量赋值时,只需给出函数名而不必给出参数。因为函数指针赋的值仅是函数的入口地址,而不涉及到实参与形参的结合问题。

  对指向函数的指针变量,表达式p+n,p++,p--等都无意义。

  5.结构体的指针与指向结构体的指针变量

  一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量,用来指向一个结构体变量,此时该指针变量的`值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。

  1.3 用指针做函数参数

  函数的参数不仅可以是整型、实型、字符型等数据,还可以是指针类型,它的作用是将一个变量的地址传送到另一个函数中。

  1.4 返回指针值的指针函数

  一个函数可以返回一个整型值、字符值、实型值等,也可以返回指针型数据 ,即地址这种带回指针值的函数,一般的定义形式为:

  类型标识符 *函数名(形参表);

  1.5 指针数组、指向指针的指针

  1.指针数组指的是一个数组,其元素均为指针类型数据,也就是说,指针数组中的每一个元素都是指针变量。指针数组的定义形式为:

  类型标识 *数组名[数组长度说明]

  指针数组可以使字符串处理更加方便。

  2.指向指针的指针是指指向指针数据的指针变量,一个指向指针数据的指针变量的一般形式为:

  类型标识 * *p;

  1.6 main函数的命令参数

  指针数组的一个重要应用是作为main函数的形参,一般来说,main函数后的括号中是空的,即没有参数。实际上main可以有参数,如:

  main(argc,argv)

  其中,argc和argv就是main函数的形参。其他函数形参的值可以通过函数调用语句的实参中得到,由于main函数是由系统调用的,因而main函数的形参值不能从程序中得到,但可以在操作系统状态下,将实参和命令一起给出,从而使main函数的形参得到值。命令行的一般形式为:

  命令名 参数1 参数2…参数n

  命令名和各参数之间用空格分隔开。

  1.7 动态存储分配

  在C语言中有一种称为“动态存储分配”的内存空间分配方式:程序在执行期间需要存储空间时,通过“申请”分配指定的内存空间;当闲置不用时,可随时将其释放,由系统另作它用。本节介绍C语言中动态分配系统的主要函数:malloc()、calloc()、free()及realloc(),使用这些函数时,必须在程序开头包含文件stdlib.h。

  1.主内存分配函数—malloc()

  函数格式:void*malloc(unsigned size);

  函数功能:从内存中分配一大小为size字节的块。

  参数说明:size为无符号整型,用于指定需要分配的内存空间的字节数。

  返回值:新分配内存的地址,如无足够的内存可分配,则返回NULL。

  说明:当size为0时,返回NULL。

  2.主内存分配函数——calloc()

  函数格式:void*malloc(unsigned n,unsigned size);

  函数功能:从内存中分配n个同一类型数据项的连续存储空间,每个数据项的大小为size字节。

  参数说明:n为无符号整型,用于指定分配的数据项的个数size为无符号整型,用于指定需要分配的数据项所占内存空间的字节数。

  返回值:新分配内存的地址,如无足够的内存可分配,则返回NULL。

  3.重新分配内存空间函数——realloc()

  函数格式:void*realloc(void *block,unsigned size);

  函数功能:将block所指内存区的大小改为size字节的块。

  参数说明:block为void类型的指针,指向内存中某块,size为无符号整型,用于指定需要分配的内存空间的字节数。

  返回值:新分配内存的地址,如无足够的内存可分配,则返回NULL。

  4.释放内存函数—free()

  函数格式:void free(void*block);

  函数功能:将calloc()、malloc()及realloc()函数所分配的内存空间释放为自由空间。

  参数说明:block为void类型的指针,指向要释放的内存空间。

  返回值:无。

  c语言重点知识点总结 4

  指针简介

  指针是C语言中广泛使用的一种数据类型。运用指针编程是C语言最主要的风格之一。利用指针变量可以表示各种数据结构; 能很方便地使用数组和字符串; 并能象汇编语言一样处理内存地址,从而编出精练而高效的程序。指针极大地丰富了C语言的功能。 学习指针是学习C语言中最重要的一环, 能否正确理解和使用指针是我们是否掌握C语言的一个标志。同时, 指针也是C语言中最为困难的一部分,在学习中除了要正确理解基本概念,还必须要多编程,上机调试。只要作到这些,指针也是不难掌握的。

  指针的基本概念

  在计算机中,所有的数据都是存放在存储器中的。 一般把存储器中的一个字节称为一个内存单元, 不同的数据类型所占用的内存单元数不等,如整型量占2个单元,字符量占1个单元等, 在第二章中已有详细的介绍。为了正确地访问这些内存单元, 必须为每个内存单元编上号。 根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号也叫做地址。 既然根据内存单元的编号或地址就可以找到所需的内存单元,所以通常也把这个地址称为指针。 内存单元的指针和内存单元的内容是两个不同的概念。 可以用一个通俗的例子来说明它们之间的关系。我们到银行去存取款时, 银行工作人员将根据我们的帐号去找我们的存款单, 找到之后在存单上写入存款、取款的金额。在这里,帐号就是存单的指针, 存款数是存单的内容。对于一个内存单元来说,单元的地址即为指针, 其中存放的数据才是该单元的内容。在C语言中, 允许用一个变量来存放指针,这种变量称为指针变量。因此, 一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。图中,设有字符变量C,其内容为“K”(ASCII码为十进制数 75),C占用了011A号单元(地址用十六进数表示)。设有指针变量P,内容为011A, 这种情况我们称为P指向变量C,或说P是指向变量C的指针。 严格地说,一个指针是一个地址, 是一个常量。而一个指针变量却可以被赋予不同的指针值,是变。 但在常把指针变量简称为指针。为了避免混淆,我们中约定:“指针”是指地址, 是常量,“指针变量”是指取值为地址的变量。 定义指针的目的是为了通过指针去访问内存单元。

  既然指针变量的值是一个地址, 那么这个地址不仅可以是变量的地址, 也可以是其它数据结构的地址。在一个指针变量中存放一

  个数组或一个函数的首地址有何意义呢? 因为数组或函数都是连续存放的。通过访问指针变量取得了数组或函数的首地址, 也就找到了该数组或函数。这样一来, 凡是出现数组,函数的地方都可以用一个指针变量来表示, 只要该指针变量中赋予数组或函数的首地址即可。这样做, 将会使程序的概念十分清楚,程序本身也精练,高效。在C语言中, 一种数据类型或数据结构往往都占有一组连续的内存单元。 用“地址”这个概念并不能很好地描述一种数据类型或数据结构, 而“指针”虽然实际上也是一个地址,但它却是一个数据结构的首地址, 它是“指向”一个数据结构的,因而概念更为清楚,表示更为明确。 这也是引入“指针”概念的一个重要原因。

  指针变量的类型说明

  对指针变量的类型说明包括三个内容:

  (1)指针类型说明,即定义变量为一个指针变量;

  (2)指针变量名;

  (3)变量值(指针)所指向的变量的数据类型。

  其一般形式为: 类型说明符 *变量名;

  其中,*表示这是一个指针变量,变量名即为定义的指针变量名,类型说明符表示本指针变量所指向的变量的数据类型。

  例如: int *p1;表示p1是一个指针变量,它的值是某个整型变量的地址。 或者说p1指向一个整型变量。至于p1究竟指向哪一个整型变量, 应由向p1赋予的地址来决定。

  再如:

  staic int *p2; /*p2是指向静态整型变量的指针变量*/

  float *p3; /*p3是指向浮点变量的指针变量*/

  char *p4; /*p4是指向字符变量的指针变量*/ 应该注意的是,一个指针变量只能指向同类型的变量,如P3 只能指向浮点变量,不能时而指向一个浮点变量, 时而又指向一个字符变量。

  指针变量的赋值

  指针变量同普通变量一样,使用之前不仅要定义说明, 而且必须赋予具体的值。未经赋值的指针变量不能使用, 否则将造成系统混乱,甚至死机。指针变量的赋值只能赋予地址, 决不能赋予任何其它数据,否则将引起错误。在C语言中, 变量的地址是由编译系统分配的,对用户完全透明,用户不知道变量的具体地址。 C语言中提供了地址运算符&来表示变量的地址。其一般形式为: & 变量名; 如&a变示变量a的地址,&b表示变量b的地址。 变量本身必须预先说明。设有指向整型变量的指针变量p,如要把整型变量a 的地址赋予p可以有以下两种方式:

  (1)指针变量初始化的方法 int a;

  int *p=&a;

  (2)赋值语句的方法 int a;

  int *p;

  p=&a;

  不允许把一个数赋予指针变量,故下面的赋值是错误的: int *p;p=1000; 被赋值的指针变量前不能再加“*”说明符,如写为*p=&a 也是错误的

  指针变量的运算

  指针变量可以进行某些运算,但其运算的种类是有限的。 它只能进行赋值运算和部分算术运算及关系运算。

  1.指针运算符

  (1)取地址运算符&

  取地址运算符&是单目运算符,其结合性为自右至左,其功能是取变量的地址。在scanf函数及前面介绍指针变量赋值中,我们已经了解并使用了&运算符。

  (2)取内容运算符*

  取内容运算符*是单目运算符,其结合性为自右至左,用来表示指针变量所指的变量。在*运算符之后跟的变量必须是指针变量。需要注意的是指针运算符*和指针变量说明中的指针说明符* 不是一回事。在指针变量说明中,“*”是类型说明符,表示其后的变量是指针类型。而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。

  main(){

  int a=5,*p=&a;

  printf ("%d",*p);

  }

  ......

  表示指针变量p取得了整型变量a的地址。本语句表示输出变量a的值。

  2.指针变量的运算

  (1)赋值运算

  指针变量的赋值运算有以下几种形式:

  ①指针变量初始化赋值,前面已作介绍。

  ②把一个变量的地址赋予指向相同数据类型的指针变量。例如:

  int a,*pa;

  pa=&a; /*把整型变量a的地址赋予整型指针变量pa*/

  ③把一个指针变量的值赋予指向相同类型变量的另一个指针变量。如:

  int a,*pa=&a,*pb;

  pb=pa; /*把a的地址赋予指针变量pb*/

  由于pa,pb均为指向整型变量的指针变量,因此可以相互赋值。 ④把数组的首地址赋予指向数组的指针变量。

  例如: int a[5],*pa;

  pa=a; (数组名表示数组的首地址,故可赋予指向数组的指针变量pa)

  也可写为:

  pa=&a[0]; /*数组第一个元素的地址也是整个数组的首地址,也可赋予pa*/

  当然也可采取初始化赋值的方法:

  int a[5],*pa=a;

  ⑤把字符串的首地址赋予指向字符类型的指针变量。例如: char *pc;pc="c language";或用初始化赋值的方法写为: char *pc="C Language"; 这里应说明的是并不是把整个字符串装入指针变量, 而是把存放该字符串的字符数组的首地址装入指针变量。 在后面还将详细介绍。

  ⑥把函数的入口地址赋予指向函数的指针变量。例如: int (*pf)();pf=f; /*f为函数名*/

  (2)加减算术运算

  对于指向数组的指针变量,可以加上或减去一个整数n。设pa是指向数组a的指针变量,则pa+n,pa-n,pa++,++pa,pa--,--pa 运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。应该注意,数组指针变量向前或向后移动一个位置和地址加1或减1 在概念上是不同的。因为数组可以有不同的类型, 各种类型的数组元素所占的字节长度是不同的。如指针变量加1,即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。

  例如:

  int a[5],*pa;

  pa=a; /*pa指向数组a,也是指向a[0]*/

  pa=pa+2; /*pa指向a[2],即pa的值为&pa[2]*/ 指针变量的加减运算只能对数组指针变量进行, 对指向其它类型变量的指针变量作加减运算是毫无意义的。(3)两个指针变量之间的运算只有指向同一数组的两个指针变量之间才能进行运算, 否则运算毫无意义。

  ①两指针变量相减

  两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。实际上是两个指针值(地址) 相减之差再除以该数组元素的长度(字节数)。例如pf1和pf2 是指向同一浮点数组的两个指针变量,设pf1的值为2010H,pf2的值为2000H,而浮点数组每个元素占4个字节,所以pf1-pf2的结果为(2000H-2010H)/4=4,表示pf1和 pf2之间相差4个元素。两个指针变量不能进行加法运算。 例如, pf1+pf2是什么意思呢?毫无实际意义。

  ②两指针变量进行关系运算

  指向同一数组的两指针变量进行关系运算可表示它们所指数组元素之间的关系。例如:

  pf1==pf2表示pf1和pf2指向同一数组元素

  pf1>pf2表示pf1处于高地址位置

  pf1  main(){

  int a=10,b=20,s,t,*pa,*pb;

  pa=&a;

  pb=&b;

  s=*pa+*pb;

  t=*pa**pb;

  printf("a=%d b=%d a+b=%d a*b=%d ",a,b,a+b,a*b);

  printf("s=%d t=%d ",s,t);

  }

  ......

  说明pa,pb为整型指针变量

  给指针变量pa赋值,pa指向变量a。

  给指针变量pb赋值,pb指向变量b。

  本行的意义是求a+b之和,(*pa就是a,*pb就是b)。

  本行是求a*b之积。

  输出结果。

  输出结果。

  ......

  指针变量还可以与0比较。设p为指针变量,则p==0表明p是空指针,它不指向任何变量;p!=0表示p不是空指针。空指针是由对指针变量赋予0值而得到的。例如: #define NULL 0 int *p=NULL; 对指针变量赋0值和不赋值是不同的。指针变量未赋值时,可以是任意值,是不能使用的。否则将造成意外错误。而指针变量赋0值后,则可以使用,只是它不指向具体的变量而已。

  main(){

  int a,b,c,*pmax,*pmin;

  printf("input three numbers: ");

  scanf("%d%d%d",&a,&b,&c);

  if(a>b){

  pmax=&a;

  pmin=&b;}

  else{

  pmax=&b;

  pmin=&a;}

  if(c>*pmax) pmax=&c;

  if(c<*pmin) pmin=&c;

  printf("max=%d min=%d ",*pmax,*pmin);

  }

  ......

  pmax,pmin为整型指针变量。

  输入提示。

  输入三个数字。

  如果第一个数字大于第二个数字...

  指针变量赋值

  指针变量赋值

  指针变量赋值

  指针变量赋值

  判断并赋值

  判断并赋值

  输出结果

  ......

  数组指针变量的说明和使用

  指向数组的指针变量称为数组指针变量。 在讨论数组指针变量的说明和使用之前,我们先明确几个关系。

  一个数组是由连续的一块内存单元组成的。 数组名就是这块连续内存单元的首地址。一个数组也是由各个数组元素(下标变量) 组成的。每个数组元素按其类型不同占有几个连续的内存单元。 一个数组元素的首地址也是指它所占有的几个内存单元的首地址。 一个指针变量既可以指向一个数组,也可以指向一个数组元素, 可把数组名或第一个元素的地址赋予它。如要使指针变量指向第i号元素可以把i元素的首地址赋予它或把数组名加i赋予它。

  设有实数组a,指向a的指针变量为pa,从图6.3中我们可以看出有以下关系:

  pa,a,&a[0]均指向同一单元,它们是数组a的首地址,也是0 号元素a[0]的首地址。pa+1,a+1,&a[1]均指向1号元素a[1]。类推可知a+i,a+i,&a[i]

  指向i号元素a[i]。应该说明的`是pa是变量,而a,&a[i]都是常量。在编程时应予以注意。

  main(){

  int a[5],i;

  for(i=0;i<5;i++){

  a[i]=i;

  printf("a[%d]=%d ",i,a[i]);

  }

  printf(" ");

  }

  主函数

  定义一个整型数组和一个整型变量

  循环语句

  给数组赋值

  打印每一个数组的值

  ......

  输出换行

  ......

  数组指针变量说明的一般形式为:

  类型说明符 * 指针变量名

  其中类型说明符表示所指数组的类型。 从一般形式可以看出指向数组的指针变量和指向普通变量的指针变量的说明是相同的。

  引入指针变量后,就可以用两种方法来访问数组元素了。

  第一种方法为下标法,即用a[i]形式访问数组元素。 在第四章中介绍数组时都是采用这种方法。

  第二种方法为指针法,即采用*(pa+i)形式,用间接访问的方法来访问数组元素。

  main(){

  int a[5],i,*pa;

  pa=a;

  for(i=0;i<5;i++){

  *pa=i;

  pa++;

  }

  pa=a;

  for(i=0;i<5;i++){

  printf("a[%d]=%d ",i,*pa);

  pa++;

  }

  }

  主函数

  定义整型数组和指针

  将指针pa指向数组a

  循环

  将变量i的值赋给由指针pa指向的a[]的数组单元

  将指针pa指向a[]的下一个单元

  ......

  指针pa重新取得数组a的首地址

  循环

  用数组方式输出数组a中的所有元素

  将指针pa指向a[]的下一个单元

  ......

  ......

  下面,另举一例,该例与上例本意相同,但是实现方式不同。

  main(){

  int a[5],i,*pa=a;

  for(i=0;i<5;){

  *pa=i;

  printf("a[%d]=%d ",i++,*pa++);

  }

  }

  主函数

  定义整型数组和指针,并使指针指向数组a

  循环

  将变量i的值赋给由指针pa指向的a[]的数组单元

  用指针输出数组a中的所有元素,同时指针pa指向a[]的下一个单元

  ......

  ......

  数组名和数组指针变量作函数参数

  在第五章中曾经介绍过用数组名作函数的实参和形参的问题。在学习指针变量之后就更容易理解这个问题了。 数组名就是数组的首地址,实参向形参传送数组名实际上就是传送数组的地址, 形参得到该地址后也指向同一数组。 这就好象同一件物品有两个彼此不同的名称一样。同样,指针变量的值也是地址, 数组指针变量的值即为数组的首地址,当然也可作为函数的参数使用。

  float aver(float *pa);

  main(){

  float sco[5],av,*sp;

  int i;

  sp=sco;

  printf(" input 5 scores: ");

  for(i=0;i<5;i++) scanf("%f",&sco[i]);

  av=aver(sp);

  printf("average score is %5.2f",av);

  }

  float aver(float *pa)

  {

  int i;

  float av,s=0;

  for(i=0;i<5;i++) s=s+*pa++;

  av=s/5;

  return av;

  }

  指向多维数组的指针变量

  本小节以二维数组为例介绍多维数组的指针变量。

  一、多维数组地址的表示方法

  设有整型二维数组a[3][4]如下:

  0 1 2 3

  4 5 6 7

  8 9 10 11

  设数组a的首地址为1000,各下标变量的首地址及其值如图所示。在第四章中介绍过, C语言允许把一个二维数组分解为多个一维数组来处理。因此数组a可分解为三个一维数组,即a[0],a[1],a[2]。每一个一维数组又含有四个元素。例如a[0]数组,含有a[0][0],a[0][1],a[0][2],a[0][3]四个元素。 数组及数组元素的地址表示如下:a是二维数组名,也是二维数组0行的首地址,等于1000。a[0]是第一个一维数组的数组名和首地址,因此也为1000。*(a+0)或*a是与a[0]等效的, 它表示一维数组a[0]0 号元素的首地址。 也为1000。&a[0][0]是二维数组a的0行0列元素首地址,同样是1000。因此,a,a[0],*(a+0),*a?amp;a[0][0]是相等的。同理,a+1是二维数组1行的首地址,等于1008。a[1]是第二个一维数组的数组名和首地址,因此也为1008。 &a[1][0]是二维数组a的1行0列元素地址,也是1008。因此a+1,a[1],*(a+1),&a[1][0]是等同的。 由此可得出:a+i,a[i],*(a+i),&a[i][0]是等同的。 此外,&a[i]和a[i]也是等同的。因为在二维数组中不能把&a[i]理解为元素a[i]的地址,不存在元素a[i]。

  C语言规定,它是一种地址计算方法,表示数组a第i行首地址。由此,我们得出:a[i],&a[i],*(a+i)和a+i也都是等同的。另外,a[0]也

  可以看成是a[0]+0是一维数组a[0]的0号元素的首地址, 而a[0]+1则是a[0]的1号元素首地址,由此可得出a[i]+j则是一维数组a[i]的j号元素首地址,它等于&a[i][j]。由a[i]=*(a+i)得a[i]+j=*(a+i)+j,由于*(a+i)+j是二维数组a的i行j列元素的首地址。该元素的值等于*(*(a+i)+j)。

  [Explain]#define PF "%d,%d,%d,%d,%d, "

  main(){

  static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

  printf(PF,a,*a,a[0],&a[0],&a[0][0]);

  printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);

  printf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);

  printf("%d,%d ",a[1]+1,*(a+1)+1);

  printf("%d,%d ",*(a[1]+1),*(*(a+1)+1));

  }

  二、多维数组的指针变量

  把二维数组a 分解为一维数组a[0],a[1],a[2]之后,设p为指向二维数组的指针变量。可定义为: int (*p)[4] 它表示p是一个指针变量,它指向二维数组a 或指向第一个一维数组a[0],其值等于a,a[0],或&a[0][0]等。而p+i则指向一维数组a[i]。从前面的分析可得出*(p+i)+j是二维数组i行j 列的元素的地址,而*(*(p+i)+j)则是i行j列元素的值。

  二维数组指针变量说明的一般形式为: 类型说明符 (*指针变量名)[长度] 其中“类型说明符”为所指数组的数据类型。“*”表示其后的变量是指针类型。 “长度”表示二维数组分解为多个一维数组时, 一维数组的长度,也就是二维数组的列数。应注意“(*指针变量名)”两边的括号不可少,如缺少括号则表示是指针数组(本章后面介绍),意义就完全不同了。

  [Explain]main(){

  static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

  int(*p)[4];

  int i,j;

  p=a;

  for(i=0;i<3;i++)

  for(j=0;j<4;j++) printf("- ",*(*(p+i)+j));

  }

  Expain字符串指针变量的说明和使用字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。 对指向字符变量的指针变量应赋予该字符变量的地址。如: char c,*p=&c;表示p是一个指向字符变量c的指针变量。而: char *s="C Language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。

  请看下面一例。

  main(){

  char *ps;

  ps="C Language";

  printf("%s",ps);

  }

  运行结果为:

  C Language

  上例中,首先定义ps是一个字符指针变量, 然后把字符串的首地址赋予ps(应写出整个字符串,以便编译系统把该串装入连续的一块内存单元),并把首地址送入ps。程序中的: char *ps;ps="C Language";等效于: char *ps="C Language";输出字符串中n个字符后的所有字符。

  main(){

  char *ps="this is a book";

  int n=10;

  ps=ps+n;

  printf("%s ",ps);

  }

  运行结果为:

  book 在程序中对ps初始化时,即把字符串首地址赋予ps,当ps= ps+10之后,ps指向字符“b”,因此输出为"book"。

  main(){

  char st[20],*ps;

  int i;

  printf("input a string: ");

  ps=st;

  scanf("%s",ps);

  for(i=0;ps[i]!=;i++)

  if(ps[i]==k){

  printf("there is a k in the string ");

  break;

  }

  if(ps[i]==) printf("There is no k in the string ");

  }

  本例是在输入的字符串中查找有无‘k’字符。 下面这个例子是将指针变量指向一个格式字符串,用在printf函数中,用于输出二维数组的各种地址表示的值。但在printf语句中用指针变量PF代替了格式串。 这也是程序中常用的方法。

  main(){

  static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

  char *PF;

  PF="%d,%d,%d,%d,%d ";

  printf(PF,a,*a,a[0],&a[0],&a[0][0]);

  printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);

  printf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);

  printf("%d,%d ",a[1]+1,*(a+1)+1);

  printf("%d,%d ",*(a[1]+1),*(*(a+1)+1));

  }

  在下例是讲解,把字符串指针作为函数参数的使用。要求把一个字符串的内容复制到另一个字符串中,并且不能使用strcpy函数。函数cprstr的形参为两个字符指针变量。pss指向源字符串,pds指向目标字符串。表达式:

  (*pds=*pss)!=`

  cpystr(char *pss,char *pds){

  while((*pds=*pss)!=){

  pds++;

  pss++; }

  }

  main(){

  char *pa="CHINA",b[10],*pb;

  pb=b;

  cpystr(pa,pb);

  printf("string a=%s string b=%s ",pa,pb);

  }

  在上例中,程序完成了两项工作:一是把pss指向的源字符复制到pds所指向的目标字符中,二是判断所复制的字符是否为`,若是则表明源字符串结束,不再循环。否则,pds和pss都加1,指向下一字符。在主函数中,以指针变量pa,pb为实参,分别取得确定值后调用cprstr函数。由于采用的指针变量pa和pss,pb和pds均指向同一字符串,因此在主函数和cprstr函数中均可使用这些字符串。也可以把cprstr函数简化为以下形式:

  cprstr(char *pss,char*pds)

  {while ((*pds++=*pss++)!=`);}

  即把指针的移动和赋值合并在一个语句中。 进一步分析还可发现`的ASCⅡ码为0,对于while语句只看表达式的值为非0就循环,为0则结束循环,因此也可省去“!=`”这一判断部分,而写为以下形式:

  cprstr (char *pss,char *pds)

  {while (*pdss++=*pss++);}

  表达式的意义可解释为,源字符向目标字符赋值, 移动指针,若所赋值为非0则循环,否则结束循环。这样使程序更加简洁。简化后的程序如下所示。

  cpystr(char *pss,char *pds){

  while(*pds++=*pss++);

  }

  main(){

  char *pa="CHINA",b[10],*pb;

  pb=b;

  cpystr(pa,pb);

  printf("string a=%s string b=%s ",pa,pb);

  }

  使用字符串指针变量与字符数组的区别

  用字符数组和字符指针变量都可实现字符串的存储和运算。 但是两者是有区别的。在使用时应注意以下几个问题:

  1. 字符串指针变量本身是一个变量,用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘’作为串的结束。字符数组是由于若干个数组元素组成的,它可用来存放整个字符串。

  2. 对字符数组作初始化赋值,必须采用外部类型或静态类型,如: static char st[]={“C Language”};而对字符串指针变量则无此限制,如: char *ps="C Language";

  3. 对字符串指针方式 char *ps="C Language";可以写为: char *ps; ps="C Language";而对数组方式:

  static char st[]={"C Language"};

  不能写为:

  char st[20];st={"C Language"};

  而只能对字符数组的各元素逐个赋值。

  从以上几点可以看出字符串指针变量与字符数组在使用时的区别,同时也可看出使用指针变量更加方便。前面说过,当一个指针变量在未取得确定地址前使用是危险的,容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。因此,char *ps="C Langage";

  或者 char *ps;

  ps="C Language";都是合法的。

  函数指针变量

  在C语言中规定,一个函数总是占用一段连续的内存区, 而函数名就是该函数所占内存区的首地址。 我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量, 使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。 我们把这种指向函数的指针变量称为“函数指针变量”。

  函数指针变量定义的一般形式为:

  类型说明符 (*指针变量名)();

  其中“类型说明符”表示被指函数的返回值的类型。“(* 指针变量名)”表示“*”后面的变量是定义的指针变量。 最后的空括号表示指针变量所指的是一个函数。

  例如: int (*pf)();

  表示pf是一个指向函数入口的指针变量,该函数的返回值(函数值)是整型。

  下面通过例子来说明用指针形式实现对函数调用的方法。

  int max(int a,int b){

  if(a>b)return a;

  else return b;

  }

  main(){

  int max(int a,int b);

  int(*pmax)();

  int x,y,z;

  pmax=max;

  printf("input two numbers: ");

  scanf("%d%d",&x,&y);

  z=(*pmax)(x,y);

  printf("maxmum=%d",z);

  }

  从上述程序可以看出用,函数指针变量形式调用函数的步骤如下:1. 先定义函数指针变量,如后一程序中第9行 int (*pmax)();定义pmax为函数指针变量。

  2. 把被调函数的入口地址(函数名)赋予该函数指针变量,如程序中第11行 pmax=max;

  3. 用函数指针变量形式调用函数,如程序第14行 z=(*pmax)(x,y); 调用函数的一般形式为: (*指针变量名) (实参表)使用函数指针变量还应注意以下两点:

  a. 函数指针变量不能进行算术运算,这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素,而函数指针的移动是毫无意义的。

  b. 函数调用中"(*指针变量名)"的两边的括号不可少,其中的*不应该理解为求值运算,在此处它只是一种表示符号。

  指针型函数

  前面我们介绍过,所谓函数类型是指函数返回值的类型。 在C语言中允许一个函数的返回值是一个指针(即地址), 这种返回指针值的函数称为指针型函数。

  定义指针型函数的一般形式为:

  类型说明符 *函数名(形参表)

  {

  …… /*函数体*/

  }

  其中函数名之前加了“*”号表明这是一个指针型函数,即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。

  如:

  int *ap(int x,int y)

  {

  ...... /*函数体*/

  }

  表示ap是一个返回指针值的指针型函数, 它返回的指针指向一个整型变量。下例中定义了一个指针型函数 day-name,它的返回值指向一个字符串。该函数中定义了一个静态指针数组name。name 数组初始化赋值为八个字符串,分别表示各个星期名及出错提示。形参n表示与星期名所对应的整数。在主函数中, 把输入的整数i作为实参, 在printf语句中调用day-name函数并把i值传送给形参 n。day-name函数中的return语句包含一个条件表达式, n 值若大于7或小于1则把name[0] 指针返回主函数输出出错提示字符串“Illegal day”。否则返回主函数输出对应的星期名。主函数中的第7行是个条件语句,其语义是,如输入为负数(i<0)则中止程序运行退出程序。exit是一个库函数,exit(1)表示发生错误后退出程序, exit(0)表示正常退出。

  应该特别注意的是函数指针变量和指针型函数这两者在写法和意义上的区别。如int(*p)()和int *p()是两个完全不同的量。int(*p)()是一个变量说明,说明p 是一个指向函数入口的指针变量,该函数的返回值是整型量,(*p)的两边的括号不能少。int *p() 则不是变量说明而是函数说明,说明p是一个指针型函数,其返回值是一个指向整型量的指针,*p两边没有括号。作为函数说明, 在括号内最好写入形式参数,这样便于与变量说明区别。 对于指针型函数定义,int *p()只是函数头部分,一般还应该有函数体部分。

  main(){

  int i;

  char *day-name(int n);

  printf("input Day No: ");

  scanf("%d",&i);

  if(i<0) exit(1);

  printf("Day No:--->%s ",i,day-name(i));

  }

  char *day-name(int n){

  static char *name[]={ "Illegal day","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

  return((n<1||n>7) ? name[0] : name[n]);

  }

  本程序是通过指针函数,输入一个1~7之间的整数, 输出对应的星期名。指针数组的说明与使用一个数组的元素值为指针则是指针数组。 指针数组是一组有序的指针的集合。 指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

  指针数组说明的一般形式为: 类型说明符*数组名[数组长度]

  其中类型说明符为指针值所指向的变量的类型。例如: int *pa[3] 表示pa是一个指针数组,它有三个数组元素, 每个元素值都是一个指针,指向整型变量。通常可用一个指针数组来指向一个二维数组。 指针数组中的每个元素被赋予二维数组每一行的首地址, 因此也可理解为指向一个一维数组。图6—6表示了这种关系。

  int a[3][3]={1,2,3,4,5,6,7,8,9};

  int *pa[3]={a[0],a[1],a[2]};

  int *p=a[0];

  main(){

  int i;

  for(i=0;i<3;i++)

  printf("%d,%d,%d ",a[i][2-i],*a[i],*(*(a+i)+i));

  for(i=0;i<3;i++)

  printf("%d,%d,%d ",*pa[i],p[i],*(p+i));

  }

  本例程序中,pa是一个指针数组,三个元素分别指向二维数组a的各行。然后用循环语句输出指定的数组元素。其中*a[i]表示i行0列元素值;*(*(a+i)+i)表示i行i列的元素值;*pa[i]表示i行0列元素值;由于p与a[0]相同,故p[i]表示0行i列的值;*(p+i)表示0行i列的值。读者可仔细领会元素值的各种不同的表示方法。 应该注意指针数组和二维数组指针变量的区别。 这两者虽然都可用来表示二维数组,但是其表示方法和意义是不同的。

  二维数组指针变量是单个的变量,其一般形式中"(*指针变量名)"两边的括号不可少。而指针数组类型表示的是多个指针( 一组有序指针)在一般形式中"*指针数组名"两边不能有括号。例如: int (*p)[3];表示一个指向二维数组的指针变量。该二维数组的列数为3或分解为一维数组的长度为3。 int *p[3] 表示p是一个指针数组,有三个下标变量p[0],p[1],p[2]均为指针变量。

  指针数组也常用来表示一组字符串, 这时指针数组的每个元素被赋予一个字符串的首地址。 指向字符串的指针数组的初始化更为简单。例如在例6.20中即采用指针数组来表示一组字符串。 其初始化赋值为:

  char *name[]={"Illagal day","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

  完成这个初始化赋值之后,name[0]即指向字符串"Illegal day",name[1]指?quot;Monday"......。

  指针数组也可以用作函数参数。在本例主函数中,定义了一个指针数组name,并对name 作了初始化赋值。其每个元素都指向一个字符串。然后又以name 作为实参调用指针型函数day name,在调用时把数组名 name 赋予形参变量name,输入的整数i作为第二个实参赋予形参n。在day name函数中定义了两个指针变量pp1和pp2,pp1被赋予name[0]的值(即*name),pp2被赋予name[n]的值即*(name+ n)。由条件表达式决定返回pp1或pp2指针给主函数中的指针变量ps。最后输出i和ps的值。

  指针数组作指针型函数的参数

  main(){

  static char *name[]={ "Illegal day","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

  char *ps;

  int i;

  char *day name(char *name[],int n);

  printf("input Day No: ");

  scanf("%d",&i);

  if(i<0) exit(1);

  ps=day name(name,i);

  printf("Day No:--->%s ",i,ps);

  }

  char *day name(char *name[],int n)

  {

  char *pp1,*pp2;

  pp1=*name;

  pp2=*(name+n);

  return((n<1||n>7)? pp1:pp2);

  }

  下例要求输入5个国名并按字母顺序排列后输出。在以前的例子中采用了普通的排序方法, 逐个比较之后交换字符串的位置。交换字符串的物理位置是通过字符串复制函数完成的。 反复的交换将使程序执行的速度很慢,同时由于各字符串(国名) 的长度不同,又增加了存储管理的负担。 用指针数组能很好地解决这些问题。把所有的字符串存放在一个数组中, 把这些字符数组的首地址放在一个指针数组中,当需要交换两个字符串时, 只须交换指针数组相应两元素的内容(地址)即可,而不必交换字符串本身。程序中定义了两个函数,一个名为sort完成排序, 其形参为指

  针数组name,即为待排序的各字符串数组的指针。形参n为字符串的个数。另一个函数名为print,用于排序后字符串的输出,其形参与sort的形参相同。主函数main中,定义了指针数组name 并作了初始化赋值。然后分别调用sort函数和print函数完成排序和输出。值得说明的是在sort函数中,对两个字符串比较,采用了strcmp 函数,strcmp函数允许参与比较的串以指针方式出现。name[k]和name[ j]均为指针,因此是合法的。字符串比较后需要交换时, 只交换指针数组元素的值,而不交换具体的字符串, 这样将大大减少时间的开销,提高了运行效率。

  现编程如下:

  #include"string.h"

  main(){

  void sort(char *name[],int n);

  void print(char *name[],int n);

  static char *name[]={ "CHINA","AMERICA","AUSTRALIA","FRANCE","GERMAN"};

  int n=5;

  sort(name,n);

  print(name,n);

  }

  void sort(char *name[],int n){

  char *pt;

  int i,j,k;

  for(i=0;i  k=i;

  for(j=i+1;j  if(strcmp(name[k],name[j])>0) k=j;

  if(k!=i){

  pt=name[i];

  name[i]=name[k];

  name[k]=pt;

  }

  }

  }

  void print(char *name[],int n){

  int i;

  for (i=0;i  }

  main函数的参数

  前面介绍的main函数都是不带参数的。因此main 后的括号都是空括号。实际上,main函数可以带参数,这个参数可以认为是 main函数的形式参数。C语言规定main函数的参数只能有两个, 习惯上这两个参数写为argc和argv。因此,main函数的函数头可写为: main (argc,argv)C语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后,main函数的函数头应写为:

  main (argc,argv)

  int argv;

  char *argv[];或写成:

  main (int argc,char *argv[])

  由于main函数不能被其它函数调用, 因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传送到main的形参中去。

  DOS提示符下命令行的一般形式为: C:>可执行文件名 参数 参数……; 但是应该特别注意的是,main 的两个形参和命令行中的参数在

  位置上不是一一对应的。因为,main的形参只有二个,而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意:文件名本身也算一个参数),argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。例如有命令行为: C:>E6 24 BASIC dbase FORTRAN由于文件名E6 24本身也算一个参数,所以共有4个参数,因此argc取得的值为4。argv参数是字符串指针数组,其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。 指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图6.8所示:

  main(int argc,char *argv){

  while(argc-->1)

  printf("%s ",*++argv);

  }

  本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe,存放在A驱动器的盘内。

  因此输入的命令行为: C:>a:e24 BASIC dBASE FORTRAN

  则运行结果为:

  BASIC

  dBASE

  FORTRAN

  该行共有4个参数,执行main时,argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句,每循环一次 argv值减1,当argv等于1时停止循环,共循环三次, 因此共可输出三个参数。在printf函数中,由于打印项*++argv是先加1再打印, 故第一次打印的是argv[1]所指的字符串BASIC。第二、 三次循环分别打印后二个字符串。而参数e24是文件名,不必输出。

  下例的命令行中有两个参数,第二个参数20即为输入的n值。在程序中*++argv的值为字符串“20”,然后用函数"atoi"把它换为整型作为while语句中的循环控制变量,输出20个偶数。

  #include"stdlib.h"

  main(int argc,char*argv[]){

  int a=0,n;

  n=atoi(*++argv);

  while(n--) printf("%d ",a++*2);

  }

  本程序是从0开始输出n个偶数。指向指针的指针变量如果一个指针变量存放的又是另一个指针变量的地址, 则称这个指针变量为指向指针的指针变量。

  在前面已经介绍过,通过指针访问变量称为间接访问, 简称间访。由于指针变量直接指向变量,所以称为单级间访。 而如果通过指向指针的指针变量来访问变量则构成了二级或多级间访。在C语言程序中,对间访的级数并未明确限制, 但是间访级数太多时不容易理解解,也容易出错,因此,一般很少超过二级间访。 指向指针的指针变量说明的一般形式为:

  类型说明符** 指针变量名;

  例如: int ** pp; 表示pp是一个指针变量,它指向另一个指针变量, 而这个指针变量指向一个整型量。下面举一个例子来说明这种关系。

  main(){

  int x,*p,**pp;

  x=10;

  p=&x;

  pp=&p;

  printf("x=%d ",**pp);

  }

  上例程序中p 是一个指针变量,指向整型量x;pp也是一个指针变量, 它指向指针变量p。通过pp变量访问x的写法是**pp。程序最后输出x的值为10。通过上例,读者可以学习指向指针的指针变量的说明和使用方法。

  下述程序中首先定义说明了指针数组ps并作了初始化赋值。 又说明了pps是一个指向指针的指针变量。在5次循环中, pps 分别取得了ps[0],ps[1],ps[2],ps[3],ps[4]的地址值(如图6.10所示)。再通过这些地址即可找到该字符串。

  main(){

  static char *ps[]={ "BASIC","DBASE","C","FORTRAN","PASCAL"};

  char **pps;

  int i;

  for(i=0;i<5;i++){

  pps=ps+i;

  printf("%s ",*pps);

  }

  }

  本程序是用指向指针的指针变量编程,输出多个字符串。

  本章小结

  1. 指针是C语言中一个重要的组成部分,使用指针编程有以下优点:

  (1)提高程序的编译效率和执行速度。

  (2)通过指针可使用主调函数和被调函数之间共享变量或数据结构,便于实现双向数据通讯。

  (3)可以实现动态的存储分配。

  (4)便于表示各种数据结构,编写高质量的程序。

  2. 指针的运算

  (1)取地址运算符&:求变量的地址

  (2)取内容运算符*:表示指针所指的变量

  (3)赋值运算

  ·把变量地址赋予指针变量

  ·同类型指针变量相互赋值

  ·把数组,字符串的首地址赋予指针变量

  ·把函数入口地址赋予指针变量

  (4)加减运算

  对指向数组,字符串的指针变量可以进行加减运算,如p+n,p-n,p++,p--等。对指向同一数组的两个指针变量可以相减。对指向其它类型的指针变量作加减运算是无意义的。

  (5)关系运算

  指向同一数组的两个指针变量之间可以进行大于、小于、 等于比较运算。指针可与0比较,p==0表示p为空指针。

  3. 与指针有关的各种说明和意义见下表。

  int *p; p为指向整型量的指针变量

  int *p[n]; p为指针数组,由n个指向整型量的指针元素组成。

  int (*p)[n]; p为指向整型二维数组的指针变量,二维数组的列数为n

  int *p() p为返回指针值的函数,该指针指向整型量

  int (*p)() p为指向函数的指针,该函数返回整型量

  int **p p为一个指向另一指针的指针变量,该指针指向一个整型量。

  4. 有关指针的说明很多是由指针,数组,函数说明组合而成的。

  但并不是可以任意组合,例如数组不能由函数组成,即数组元素不能是一个函数;函数也不能返回一个数组或返回另一个函数。例如

  int a[5]();就是错误的。

  5. 关于括号

  在解释组合说明符时, 标识符右边的方括号和圆括号优先于标识符左边的“*”号,而方括号和圆括号以相同的优先级从左到右结合。但可以用圆括号改变约定的结合顺序。

  6. 阅读组合说明符的规则是“从里向外”。

  从标识符开始,先看它右边有无方括号或园括号,如有则先作出解释,再看左边有无*号。 如果在任何时候遇到了闭括号,则在继续之前必须用相同的规则处理括号内的内容。例如:

  int*(*(*a)())[10]

  ↑ ↑↑↑↑↑↑

  7 6 4 2 1 3 5

  上面给出了由内向外的阅读顺序,下面来解释它:

  (1)标识符a被说明为;

  (2)一个指针变量,它指向;

  (3)一个函数,它返回;

  (4)一个指针,该指针指向;

  (5)一个有10个元素的数组,其类型为;

  (6)指针型,它指向;

  (7)int型数据。

  因此a是一个函数指针变量,该函数返回的一个指针值又指向一个指针数组,该指针数组的元素指向整型量。

  基本数据类型

  void:声明函数无返回值或无参数,声明无类型指针,显示丢弃运算结果。(C89标准新增)

  char:字符型类型数据,属于整型数据的一种。(K&R时期引入)

  int:整型数据,表示范围通常为编译器指定的内存字节长。(K&R时期引入)

  float:单精度浮点型数据,属于浮点数据的一种。(K&R时期引入)

  double:双精度浮点型数据,属于浮点数据的一种。(K&R时期引入)

  -Bool:布尔型(C99标准新增)

  -Complex:复数的基本类型(C99标准新增)

  -Imaginary:虚数,与复数基本类型相似,没有实部的纯虚数(C99标准新增)

  -Generic:提供重载的接口入口(C11标准新增)

  类型修饰关键字

  short:修饰int,短整型数据,可省略被修饰的int。(K&R时期引入)

  long:修饰int,长整型数据,可省略被修饰的int。(K&R时期引入)

  long long:修饰int,超长整型数据,可省略被修饰的int。(C99标准新增)

  signed:修饰整型数据,有符号数据类型。(C89标准新增)

  unsigned:修饰整型数据,无符号数据类型。(K&R时期引入)

  restrict:用于限定和约束指针,并表明指针是访问一个数据对象的唯一且初始的方式。(C99标准新增)

  复杂类型关键字

  struct:结构体声明。(K&R时期引入)

  union:联合体声明。(K&R时期引入)

  enum:枚举声明。(C89标准新增)

  typedef:声明类型别名。(K&R时期引入)

  sizeof:得到特定类型或特定类型变量的大小。(K&R时期引入)

  inline:内联函数用于取代宏定义,会在任何调用它的地方展开。(C99标准新增)

  存储级别关键字

  auto:指定为自动变量,由编译器自动分配及释放。通常在栈上分配。与static相反。当变量未指定时默认为auto。(K&R时期引入)

  static:指定为静态变量,分配在静态变量区,修饰函数时,指定函数作用域为文件内部。(K&R时期引入)

  register:指定为寄存器变量,建议编译器将变量存储到寄存器中使用,也可以修饰函数形参,建议编译器通过寄存器而不是堆栈传递参数。(K&R时期引入)

  extern:指定对应变量为外部变量,即标示变量或者函数的定义在别的文件中,提示编译器遇到此变量和函数时在其他模块中寻找其定义。(K&R时期引入)

  const:指定变量不可被当前线程改变(但有可能被系统或其他线程改变)。(C89标准新增)

  volatile:指定变量的值有可能会被系统或其他线程改变,强制编译器每次从内存中取得该变量的值,阻止编译器把该变量优化成寄存器变量。(C89标准新增)

  流程控制关键字

  跳转结构

  return:用在函数体中,返回特定值(如果是void类型,则不返回函数值)。(K&R时期引入)

  continue:结束当前循环,开始下一轮循环。(K&R时期引入)

  break:跳出当前循环或switch结构。(K&R时期引入)

  goto:无条件跳转语句。(K&R时期引入)

  分支结构

  if:条件语句,后面不需要放分号。(K&R时期引入)

  else:条件语句否定分支(与if连用)。(K&R时期引入)

  switch:开关语句(多重分支语句)。(K&R时期引入)

  case:开关语句中的分支标记,与switch连用。(K&R时期引入)

  default:开关语句中的“其他”分支,可选。(K&R时期引入)

  编译

  #define 预编译宏

  #if 表达式 #else if 表达式 #else #endif 条件编译

  #ifdef 宏 #else #endif 条件编译

  #ifndef 宏 #else #endif 条件编译与条件编译

  c语言知识易错点

  1.书写标识符时,忽略了大小写字母的区别。

  2.忽略了变量的类型,进行了不合法的运算。

  3.将字符常量与字符串常量混淆。

  4.忽略了“=”与“==”的区别。

  5.忘记加分号。分号是C语句中不可缺少的一部分,语句末尾必须有分号。

  6.多加分号。 复合语句的花括号后不应再加分号,否则将会画蛇添足。

  7.输入变量时忘记加地址运算符“&”。

  8.输入数据的方式与要求不符。代码①scanf("%d%d",&a,&b);输入时,不能用逗号作两个数据间的分隔符②scanf("%d,%d",&a,&b);C规定:如果在“格式控制”字符串中除了格式说明以外还有其它字符,则在输入数据时应输入与这些字符相同的字符。

  9.输入字符的格式与要求不一致。在用“%c”格式输入字符时,“空格字符”和“转义字符”都作为有效字符输入。

  10.输入输出的数据类型与所用格式说明符不一致。

  11.输入数据时,企图规定精度。

  12.switch语句中漏写break语句。

  13.忽视了while和do-while语句在细节上的区别。

  14.定义数组时误用变量。

  15.在定义数组时,将定义的“元素个数”误认为是可使的最大下标值。

  16.初始化数组时,未使用静态存储。

  17.在不应加地址运算符&的位置加了地址运算符。

  18.同时定义了形参和函数中的局部变量。

  • 相关推荐

【c语言重点知识点总结】相关文章:

大学c语言知识点总结03-15

儿科重点知识点总结08-09

税法重点知识点总结07-13

c语言学习总结通用03-03

初识c语言实验总结09-30

高考地理重点知识点总结11-08

初中数学重点知识点总结10-12

春望重点知识点总结12-01

c语言练习试题11-14