先看一个简单的例子：

#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）是计算机管理内存的基本单位，变量是若干个相邻的字节构成，变量的地址是地址最小的那个字节的地址。

  2. 数值数据类型：整型，浮点型
  3. 字符数据类型：字符型，标识符（identifier），关键字（keyword），保留字
  4. 标识符（变量名，函数名，数组名，文件名，类型名）由字母、数字、下划线组成，数字不能开头。区分大小写。
  5. 空类型：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;
}