变量和数据类型

先看一个简单的例子：

#include <stdio.h> //预处理命令
int main(void)               
{
    int num;      //声明变量。int是关键字，num是标识符
    num = 1;      //给变量赋值

    printf("一个简单的程序。\n"); //调用printf系统函数，\n为转义字符，表示换行。
    printf("Num的值是：%d\n",num);

    return 0; //主函数返回，操作权给操作系统。
}

变量（Variable）

变量名：标识符（由字母、数字、下划线组成，数字不能开头，区分大小写），先定义后使用。最好初始化，即定义的时候赋值。
关键字：系统使用，比如int。
变量名保存了地址，数据类型保存了长度和转换关系。

变量名

• 类型确定了则需要给一个名字，最好是能够一看就知道是什么意思的，比如书本数量，就叫BookNumber，变量必须要是合法的标识符（由字母、数字、下划线组成，数字不能开头，区分大小写），不能与关键字（系统要用的名字）相同。
• 从内存来看，内存可以粗略地理解为一个个小衣柜，你向系统申请个柜子，然后给你个号码，你下次按着号码来拿衣服。变量名就是这个号码，所以需要先定义后使用。
• 赋值操作符：=,把右边的值赋给左边的变量。 int a; a = 3;
  后面想用数字3的时候可以直接使用变量名。
• 变量里面的数在赋值前是随机的（永远有数）。最好初始化，即定义的时候赋值。

基本数据类型

计算机存储的是二进制，则全是0或者1，计算机需要知道变量放在哪里，放的是什么。变量名保存了地址，数据类型保存了长度和转换关系。

举个例子，int这个类型就告诉编译器，从变量名那个地址开始算，往后32个格子（位bit，1字节=8位，即int数据占4个字节）是这个变量的。

字节（byte,B）是计算机管理内存的基本单位，变量是若干个相邻的字节构成，变量的地址是地址最小的那个字节的地址。

1. 数值数据类型：整型，浮点型
2. 字符数据类型：字符型，标识符（identifier），关键字（keyword），保留字

3.    标识符（变量名，函数名，数组名，文件名，类型名）由字母、数字、下划线组成，数字不能开头。区分大小写。
   

4. 空类型：void，不确定的数据类型，通常作为类型占位符。
   

数值数据类型

整数类型：

• 短整型(short,2B,-32768 - +32767)
• 整型(int,4B,-21.47亿 - +21.47亿)
• 长整型(long,4B,在32位操作系统上表数范围和int一样)，后面加L或l。

//sizeof（）运算符可以求一个变量，类型，常量等所占的存储空间。会执行括号中的计算，但是不会有结果。（也可以理解为没有执行）

有符型，为了区分正负，将第一位作为符号位，0表示正，1表示负。无符号类型(unsigned)表数范围的绝对值扩大两倍，只能表示非负整数，比如unsigned short表数范围为0-65535。

浮点类型：

• 单精度浮点型(float,4B,(-10^38 - -10^-38)和(10-38 - 10^38))
• 双精度浮点型(double,8B,(-10^308 - -10^-308)和(10-308 - 10^308))
• 存储：float最高位为符号位，接下来8位为指数位，最后23位为尾数位。后面加f或F。
• 科学计数法表示：E前面必须有数字，指数必须为整数。

•   浮点数通常只是实际值的近似值。
  

字符数据类型

• 字符型(char,1B,-128 - +127)，无符号字符型(unsigned char,1B,0 - 255)
  标识符，关键字，空白符（空格符、制表符、换行符）都属于字符型。
  用ASCII编码方案编码后储存，0-255个（有的系统会扩展）。
• 标识符（Identifier）（变量名，函数名，数组名，文件名，类型名）由字母、数字、下划线组成，数字不能开头。区分大小写。
• 关键字（Key Word）：具有特俗意义的标识符，不能用于它用。
• 保留字（Reserved Word）:系统暂时不使用，未来可能会使用的标识符，比如java中的goto。

特殊数据类型

空类型(void，不确定的数据类型，通常作为类型占位符)

原子类型和构造类型

原子类型：基本类型、指针类型、空类型。不可再分割。
构造类型：数组类型、结构体类型、共用体（结合体）类型。由基本类型构造而成。

	char(unsigned char)         1个字节
	short(unsigned short)       2个字节
	int(unsigned int)           4个字节
	long(unsigned long)         4个字节
	float                       4个字节
	double                      8个字节

常量

• 常量(Constant)：值不能改变的量，不能对常量赋值
• 整数常量：十进制，八进制，十六进制。（前缀，0，0x）(后缀，L,U)
• 实型常量 ：十进制小数，在后面加F（f）。
• 科学计数法表示：E前面必须有数字，指数必须为整数（double型）
  1.5E+2.5、E6都是错的。
• 字符型常量分为普通字符常量（‘a’,‘3’）和转义字符常量（‘\n’）。在c/c++中，反斜线（/）为转义符，后面的内容有特殊含义。
• 字符串常量：\0结尾。“”括起来。

常用转义字符：
	\n 回车换行
	\t (transverse) 相当于tab
	\v (vertical)  竖向跳格
	\r 左移符 左移光标，输出覆盖
	\f 换页符
	\b 退格符
	\ddd 1-3位八进制所代表的的字符 （ascii码）
	\xhh 1-2位十六进制所代表的的字符

• 字符串常量：“”字符串尾自动加一个“\0”作为结束标志，没有内容的称为空串。
  ‘ab’既不是字符常量，也不是字符串常量。
• 符号常量：利用标识符定义一个常量，即宏替换。

复数类型：
复数类型：float_Complex、double_Complex和long double_Complex
虚数类型是float_Imaginary、double_Imaginary和long double_Imaginary。
如果包含complex.h头文件，便可用complex代替_Complex，用imaginary代替_Imaginary，还可以用I代替-1的平方根。

//char类型小结：
	char a;  //声明一个char类型变量。
	a = 'T'; //赋值
	a = T;   //错误，T是一个变量。
	a = "T"; //错误，T是一个字符串。
	a = 65;  //对于ASCII正确，但是不建议，也许什么时候就错了。

例子代码：

#include <stdio.h>

int main()
{
	char c1 = 65;
	short int i1 = 10;
	int i2 = 10;
	long int i3 = 10;
	double d1 = 10.11;
	float f1 = 10.12;

	printf("char:%d Bytes\nshort int:%d Bytes\nint:%d Bytes\nlong int:%d Bytes\ndouble:%d Bytes\nsfloat:%d Bytes\n",
	sizeof(c1),sizeof(i1++),sizeof(i2++),sizeof(i3++),sizeof(d1),sizeof(f1));
	//sizeof（）运算符可以求一个变量，类型，常量等所占的存储空间。会执行括号中的计算，但是不会有结果。
	printf("字符是用ASC码存储的：%c\n", c1);
	printf("sizeof(i++)后i的值：%d,%d,%d\n",i1,i2,i3);
	printf("\n****************************************\n\n");

	int x = 100;
	printf("进制显示：100\n");
	printf("dec = %d; octal = %o; hex = %x\n", x, x, x);
	printf("dec = %d; octal = %#o; hex = %#x\n", x, x, x);
	printf("\n****************************************\n\n");

	//溢出
	printf("溢出\n");
	int i = 2147483647;
	unsigned int j = 4294967295;
	printf("%d %d %d\n", i, i+1, i+2);
	printf("%u %u %u\n", j, j+1, j+2);//溢出后会从最小的开始
	printf("\n****************************************\n\n");

	//h修饰符可以显示较大整数被截断成 short 类型值
	unsigned int un = 3000000000; /* int为32位和short为16位的系统 */
	short end = 200;
	long big = 65537;
	long long verybig = 12345678908642;
	printf("un = %u and not %d\n", un, un);
	printf("end = %hd and %d\n", end, end);
	printf("big = %ld and not %hd\n", big, big);
	printf("verybig= %lld and not %ld\n", verybig, verybig);
	printf("\n****************************************\n\n");

	//指数显示
	float aboat = 32000.0;
	double abet = 2.14e9;
	long double dip = 5.32e-5;
	printf("%f can be written %e\n", aboat, aboat);
	// 下一行要求编译器支持C99或其中的相关特性
	printf("And it's %a in hexadecimal, powers of 2 notation\n",aboat);
	printf("%f can be written %e\n", abet, abet);
	printf("%Lf can be written %Le\n", dip, dip);
	printf("\n****************************************\n\n");

	return 0;
}