C语言要点—— 数据类型、关键字

*数据类型与变量

1、数据类型可以理解为固定内存大小的别名。

2、数据类型是创建变量的模子。

eg，char是1个byte内存的别名，short int是2个byte内存的别名，int是4个byte内存的别名.

3、变量是一段实际连续存储空间的别名。

程序中通过变量来申请并命名存储空间，通过变量的名字可以使用存储空间。

*auto，static，register分析

1、auto是c语言中局部变量的默认属性，编译器默认所有的局部变量都是auto的。

auto变量存储在程序的栈中，变量使用时即在栈中分配内存，使用后即从栈中释放变量，不占用栈空间。

2、static具有“作用域限定符”的意义：①static修饰的全局变量作用域只是声明的文件中；②static修饰的函数作用域只是声明的文件中。

static修饰的变量只初始化一次。

static修饰的局部变量存储在程序静态区。

3、register关键字指明将变量存储于寄存器中。

register只是请求寄存器变量，但不一定请求成功。

不能用&运算符获取register变量的地址。

register变量请求存储于CPU寄存器中。

*break和continue的区别

1、break表示终止循环的执行，跳出块的操作，white，do...while，for为三种不同类型的循环块，可用break。

2、continue表示终止本次循环体，进入下次循环执行。

*void

void修饰函数返回值和参数，仅为了表示无：

1、如果函数没有返回值，应将其声明为void型。

2、如果函数没有参数，应声明其参数为void。

*void指针的意义

1、C语言规定只有相同类型的指针才可以相互赋值。

2、void*指针作为左值用于“接收”任意类型的指针。

3、void*指针作为右值赋值给其它指针时需要强制类型转换。

eg:

int* pi = (int*)malloc(sizeof(int));

char* pc = (char*)malloc(sizeof(char));

void* p = NULL;

int* pni = NULL;

char* pnc = NULL;

p = pi; （正确）

pni = p; （错误）

p = pc; （正确）

pnc = p; （错误）

*extern

1、extern用于声明外部定义的变量和函数。

2、extern用于“告诉”编译器用C方式编译。C++编译器和一些变种C编译器默认会按照“自己”的方式编译函数和变量，通过extern关键字可以命令编译器“以标准C方式进行编译”。

eg:

extern "C"

{

int f(int a, intb)

{

return a+b;

}

}

*sizeof

1、sizeof是编译器的内置指示符，不是函数。

2、sizeof用于“计算”相应实体所占的内存大小。

3、sizeof的值在编译期就已经确定。

*const

1、const修饰变量：

在C语言中const修饰的变量是只读的，变量的值放在内存的数据表中，每次调用时，则直接从数据表中读取变量的值。const修饰的变量本质还是变量，可以通过指针改变变量的值。

2、const修饰指针：

口诀：左数右指

当const出现在*号左边时，指针指向的数据为常量。

当const出现在*号右边时，指针本身为常量。

eg：

const int* p; //p可变，p指向的内容不可变

int const* p; //p可变，p指向的内容不可变

int* const p; //p不可变，p指向的内容可变

const int* const p; //p和p指向的内容都不可变

3、const修饰函数和返回值：

const修饰函数参数表示在函数体内不希望改变参数的值。

const修饰函数返回值表示返回值不可改变，多用于返回指针的情形。

eg：

const int* func()

{

static int count = 0;

count++;

return &count;

}

*volatile

1、volatile可理解为“编译器警告指示字”。

2、volatile用于告诉编译器必须每次去内存中取变量值。

3、volatile主要修饰可能被多个线程访问的变量。

4、volatile也可以修饰可能被未知因素更改的变量。

*柔性数组

1、由结构体产生柔性数组。

2、柔性数组即数组大小待定的数组。

3、C语言中结构体的最后一个元素可以是大小未知的数组。

4、C语言中可以由结构体产生柔性数组。

eg：

struct softArray

{

int len;

int array[];

}

*union和struct的区别

1、struct中的每个域在内存中都独立分配空间。

2、union只分配最大的空间，所有域共享这个空间。

eg:

struct A

{

int a;

int b;

int c;

};

union B

{

int a;

int b;

int c;

};

int main()

{

printf("%d\n", sizeof(A)); //12字节

printf("%d\n", sizeof(B)); //4字节

return 0;

}

*union

1、同一个内存段可以用来存放几种不同类型的成员，但在每一个时刻只能存在其中一种，起始地址相同。

2、共用体变量中起作用的成员是最后一个存放的成员，原有的成员被覆盖。

3、union变量不能作为函数参数。

*enum

1、枚举是一个被命名的整型常数的集合。

2、枚举中每个标识符的结束符是“,”，不是";"，最后 一个成员可省略。不准对枚举变量做++或--。

3、初始化时可以赋负数，以后的标识符仍依次加1。

4、枚举变量只能取枚举结构中的某个标识符常量。

*枚举类型和#define的区别

1、#define宏常量只是简单的进行值替换，枚举常量是真正意义上的常量。

2、#define宏常量无法被调试，枚举常量可以。

3、#define宏常量无类型信息，枚举常量是一种特定类型的常量。

*typedef

1、typedef用于给一个已存在的数据类型重命名，并没有产生新的类型。

2、typedef重命名的类型不能进行unsigned 和 signed扩展。

*注释符号

1、编译器会在编译过程删除注释，但不是简单的删除，而是用空格代替。

2、编译器认为双引号括起来内容都是字符串，双斜杠也不例外。

3、/*...*/型注释不能被嵌套。

eg：

①、int/*...*/;         正确

②、char* s = "abcdefgh //hijklmn"; /正确

③、//Is it a \

valid comment?             正确

④、in/*..*/t;         错误

*接续符“\"

1、编译器会将反斜杠剔除，跟在反斜杠后面的字符自动解到前一行。

2、在接续单词时，反斜杠之后不能有空格，反斜杠的下一行之前也不能有空格。

3、接续符适合在定义宏代码块时使用。

eg:

#define swap(a, b) \

{ \

int temp = a; \

a = b; \

b = temp; \

}

*单引号和双引号

1、C语言中的单引号用来表示字符常量。

2、C语言中的双引号用来表示字符串常量。

3、本质上单引号括起来的一个字符代表整数。

4、双引号括起来的字符代表一个指针。

5、C编译器接受字符和字符串的比较，可意义是错误的。

6、C编译器允许字符串对字符变量赋值，其意义是可笑的。

eg:

'a'表示字符常量，在内存中占1个字节。

'a'+1表示‘a'的ASCII码加1，结果为’b'。

“a"表示字符串常量，在内存中占2个字节。

“a"+1表示指针运算，结果指向”a"结束符‘\0’。

*C语言隐式类型转换

1、算术运算式中，低类型转换为高类型。

2、赋值表达式中，表达式的值转换为左边变量的类型。

3、函数调用时，实参转换为形参的类型。

4、函数返回值，return表达式转换为返回值类型。

char->short->int->unsigned int->long->unsigned long->double

float

*宏定义与使用分析

1、宏定义常量

①、#define定义宏常量可以出现在代码的任何地方。

②、#define从本行开始，之后的代码都可以使用这个宏常量。

eg:

#define ERROR -1 正确

#define PI 3.141592653 正确

#define PATH_1 "D:\Delph:\C\Topic3.ppt" 正确

#define PATH_2 D:\Delph:\C\Topic3.ppt 正确

#define PATH_3 D:\Delph:\C\

Topic3.ppt 正确

2、宏定义表达式

①、#define表达式给有函数调用的假象，却不是函数。

②、#define表达式可以比函数更强大。

③、#define表达式比函数更容易出错。

eg：

#define SUM(a, b) (a)+(b)

#define MIN(a, b) ((a)<(b) ? (a):(b))

#define DIM(a) (sizeof(a) / sizeof(*a))

3、宏表达式与函数的对比

1、宏表达式在预编译期被处理，编译器不知道宏表达式的存在。

2、宏表达式用“实参”（数据类型、常量、变量）完全代替形参，不进行任何运算。

3、宏表达式没有任何的“调用”开销。

4、宏表达式不能出现递归定义。

eg:

#define FAC(n) ((n>0)?(FAC(n-1)+1):0)

int j = FAC(100); (错误)

5、宏定义的常量或表达式没有作用域限制，除非用#undef来限制作用域。

eg:

int f1(int a, int b)

{

#define MIN(a, b) ((a)<(b) ? a:b)

return MIN(a,b) //MIN表达式只在f1中有用

#undef MIN

}

int f2(int a, int b, int c)

{

return MIN(MIN(a, b), c) //出错，不能使用MIN

}

*#include

1、#include 本质是将已经存在的文件内容嵌入到当前文件中。

2、#include的间接包含同样会产生嵌入文件内容的动作。

3、为避免文件的重复包含，可用以下结构在.h文件中，则头文件可以任意包含。

#ifndef _FILE_H_

#define _FILE_H_

..

#endif

*条件编译：#if...#else...#endif

1、条件编译是预编译指示指令，用于控制是否编译某段代码。

2、条件编译使得我们可以按不同的条件编译不同的代码段，因而可以产生不同的目标代码。

3、#if...#else...#endif被预编译器处理；

if...else语句被编译器处理，必然被编译进目标代码。

4、实际工程中条件编译主要用于以下两种情况：

不同的产品线共用一份代码。

区分编译产品的调试版和发布版。

*#error用法

#error用于生成一个编译错误消息，并停止编译。

用法：#error message

注：message不需要用双引号包围

#error编译指示字用于自定义程序员特有的编译错误消息。

#warning用于生成编译警告，但不会停止编译。