第二节--数据类型，常亮，变量以及运算符

一、数据类型

1、数据类型分类-掌握
2、基本数据类型-掌握
3、强制类型转换

---

数据类型：

---

基本数据类型：

逻辑类型。只有两个量true和false，表示逻辑真值和逻辑假值。
整数类型。包括char, short, int和long。
浮点类型。包括float和double。
void类型。主要用于说明不返回值的函数或指向任一类型的指针等。

bool类型 <stdbool.h> _Bool基本类型

  //例如
  if ( -1 )
    	x=12 ;
  else
	    x=18 ;
  //上面-1是非零数值，逻辑值为真，所以x赋给的是12，而不是18。

Char 类型

使用char数据类型的变量需要特别注意，防止数据超出值域，思考下列几个语句：
char c1= 128; //出错，数据越界(-128)
char c1= 129; //出错，数据越界(-127) unsigned char
c2= -1; //出错，数据越界(255)

short类型<limits.h>

int类型<limits.h>

long类型<limits.h>

浮点类型<limits.h>

---

强制数据类型转换：
强制数据类型的转换是指采用某种方式将某种数据类型强制转换成指定的数据类型。包括显式的数据类型转换，和隐式的数据类型转换。
例如，

   int    a＝22,  b=0 ;
   float  c = 24.87,  d= 3.3;
   b = (int) (a + c +d) ; // b为50

强制类型转换符后面的表达式如存在复杂运算，就一定要用小括号括起来
强制类型转换符是一种不安全的转换，一般都是将高级类型转换成低级类型，要丢失数据的精度；
强制类型转换并不改变表达式中变量的数据类型和其值。

---

补充知识：创建一个TXT文档：

linux@linux:~/xiaoyu/ctype$ gedit note.txt
gedit note.txt  创建一个TXT文档

---

补充知识：复制程序并向外面拷贝：

linux@linux:~/xiaoyu/ctype$ gedit char.c 

使用这个命令可以打开下面的窗口

在新弹出的窗口，可以将程序复制出来

---

补充知识：打开预处理文件：

linux@linux:~/xiaoyu/ctype$ gcc -E bool.c -o bool.i
linux@linux:~/xiaoyu/ctype$ vi bool.i
可以查看程序执行内容（过程）

---

补充知识：打开头文件的方法：

linux@linux:~/xiaoyu/ctype$ vi /usr/include/limits.h

---

BOOL的使用方法：

#include<stdbool.h>  
#define bool _Bool
#define true 1
#define false 0

由上述宏定义可知 :
1、使用bool时，需要引入头文件#include<stdbool.h>
2、使用_Bool时，不需要头文件（此时true 和false也不能用）

---

使用sizeof查看数据长度：
对于嵌入式开发来说，可能有23位的，64位的等不同的处理器，这些对于数据类型有一定的影响，我们在写程序的时候，可以使用 “sizeof”命令来查看当前数据的长度。

#include<stdio.h>
#include<stdbool.h>
int main()
   {
    printf("%d %d %d %d\n",sizeof(_Bool),sizeof(char),sizeof(short),sizeof(int));
	 return 0;
}

**编译结果

linux@linux:~/xiaoyu/ctype$ gcc int.c -o int -Wall
linux@linux:~/xiaoyu/ctype$ ./int
1 1 2 4

---

反码是负数在内存当中的实际存储：

-1
原码：1000 0001（*最高位1 代表负号。0 代表正号）
反码：1111 1110
补码：1111 1111（反码+1）
-127
原码：1111 1111（*最高位1 代表负号。0 代表正号）
反码：1000 0000
补码：1000 0001（反码+1）
特殊记忆 -128 补码：1000 0000

---

字符型数据赋值注意事项：

#include<stdio.h>
int main()
   {
     char ch;
	 ch=127;
    printf("ch=%d %c\n",ch, ch);
		 return 0;
} 

编译结果

linux@linux:~/xiaoyu/ctype$ gcc char.c -o char -Wall
linux@linux:~/xiaoyu/ctype$ ./char
ch=127 【乱码】

可以看到，第二个数据是乱码，这是为什么呢？

计算机无法直接识别字符，需要先将字符对应的十进制数查出来，然后转化为二进制进行处理，由上图ASCII表可以看出，在我们将字符型变量CH=127的时候，计算机通过查表，找到了ASCII表的最后一行，十进制127对应的是DEL，所以程序执行结果显示乱码，而不是显示127。

如果我们将CH的值赋值为65，会显示字符A吗？

#include<stdio.h>
int main()
   {
     char ch;
	 ch=65;
    printf("ch=%d %c\n",ch, ch);
	 return 0;
}

编译结果

linux@linux:~/xiaoyu/ctype$ gcc char.c -o char -Wall
linux@linux:~/xiaoyu/ctype$ ./char
ch=65  A

---

字符和字符串的关系：
字符串以\0结尾
“9” = ‘9’，’\0’

#include<stdio.h>
int main()
{
char arr1[ ]={"abc"};
char arr2[ ]={'a','b','c','\0'};
printf("%d %d\n",sizeof(arr1),sizeof(arr2));
return 0;
}

编译结果

linux@linux:~/xiaoyu/ctype/constant$ gcc char3.c -o char3 -Wall
linux@linux:~/xiaoyu/ctype/constant$ ./char3
4 4

有上面的编译结果可以看出：{“abc”} = {‘a’,‘b’,‘c’,’\0’};

二、常量

1、基本数据类型的常量-掌握
2、标识常量-掌握

---

整形常量：

常量是指在程序运行期间其数值不发生变化的数据。整型常量通常简称为整数。
整数可以是十进制数、八进制数和十六进制数。例如，十进制的数值3356可以有下列二种不同的表示形式：
八进制数 06434
十六进制数 0xd1c

---

浮点型常量：

浮点常量又称为实数，一般含有小数部分。
在C语言中，实数只有十进制的实数，分为单精度和双精度。实数有两种表示方法， 即一般形式和指数形式。
一般形式的实数基本形式如下：
例如， 3.5 , -12.5, 3.1415926

---

指数常量：

指数形式的实数一般是由尾数部分、字母e或E和指数部分组成。 当一个实数的符号为正号时，可以省略不写，其表示的一般形式如下：
1.176e+10 表示 1.176×10^10
-3.5789e-8 表示 -3.5789×10^-8
%e用来输出指数形式
.通常表示特别大或特别小的数

---

字符常量：

字符常量是指一个单一字符， 其表示形式是由两个单引号包括的一个字符。
A’, ‘a’, ‘Q’, ‘0’, ‘9’, ‘+’, ‘:’, ‘?’, ‘$’ 都是字符常量。
在C语言中， 字符常量具有数值。字符常量的值就是该字符的ASCII码值。
可以把字符常量看做一个字节的正整数。
例如，char a, b, u, v
a = ‘F’ ; // 将70送给a
b = ‘A’+2; // b存放的是 ‘C’ 字符
u = ’ ’ + ‘B’; // u存放的是 ‘b’ 字符
v= ‘b’ - 32; // v存放的是 ‘B’ 字符
它们分别相当于下列运算；
a= 70;
b= 65+2;
u= 32+66 ;
v= 97-32;

---

字符串常量：

所谓字符串常量是指用双引号括起来的一串字符来表示的数据。(字符串以\0结尾) “9”—‘9’,’\0’
下面给出几个字符串常量的例子：
“Hello!”, “StudentS”, “9”, “LINUX", “李四”
“北京海淀成府路号"， “姓名：”， “*@163.com", “”

---

标识常量：

所谓标识常量是指用标识符代替常量使用的一种常量, 其名称通常是一个标识符。
标识常量也叫符号常量，一般用大写英文字母的标识符。
在使用之前必须预先定义。说明形式为：
#define <标识常量名称> <常量>
例如
#define MAX 50
#define PI 3.1415926
#define NULL 0
#define EOF -1
#define ERROR -1
其中，MAX、PI、NULL、 EOF和ERROR都是标识常量， 它们代替的常量分别是50、3.1415926、0 、-1和-1 。
一般情况，每个标识常量说明式子只能给出一个标识常量，并且占据一个书写行。
定义一个宏名字之后，可以在其他宏定义中使用,例如：
#define ONE 1
#define TWO ONE+ONE
#define THREE ONE+TWO
如果一个串长于一行，可在行尾用反斜线”\”续行
#define LONG_STRING “This is a very very long
String that is used as an example”

---

宏定义函数：
在软件开发过程中，经常有一些常用或者通用的功能或者代码段，封装成为宏定义

　#define MAX( a, b) ( (a) > (b) ? (a) : (b) )
  int max( int a, int b)
　　{
　　return (a > b a : b)
    }

swap（x，y）交换函数
#define swap(x, y)\
x = x + y;\
y = x - y;\
x = x - y;

有一些任务根本无法用函数实现，但是用宏定义却很好实现。
比如参数类型没法作为参数传递给函数，但是可以把参数类型传递给带参的宏。

#define MALLOC（n, type） \
（ (type *) malloc（（n）* sizeof（type）））

宏可以增加程序的长度，如果相同的代码需要出现在程序的几个地方，更好的方法是把它实现为一个函数

三、变量

1、变量的基础-掌握
2、变量的说明-掌握
3、变量的存储类型-掌握
4、变量的存储类型static-掌握
5、变量的存储类型extern-掌握

---

变量基础：
变量在程序中用变量名表示。变量名由用户根据其用途任意命名。
变量名由字母、数字、下划线组成，不能以数字开头，不能和C的关键字重名。
在程序运行时，变量占据存储空间的大小由其数据类型决定。
变量在内存空间中的首地址，称为变量的地址。

---

变量的说明：
变量在程序中使用时,必须预先说明它们的存储类型和数据类型。
变量说明的一般形式是：
<存储类型> <数据类型 > <变量名> ；
<存储类型>是关键词auto、register、static和extern
<数据类型>可以是基本数据类型，也可以是自定义的数据类型

---

变量的存储类型：
auto说明的变量只能在某个程序范围内使用，通常在函数体内或函数中的复合语句里。（默认是随机值）
在函数体的某程序段内说明auto存储类型的变量时可以省略关键字auto，如下：
auto int k ;
int j ;
double x;
register称为寄存器型，register变量是想将变量放入CPU的寄存器中，这样可以加快程序的运行速度。
如申请不到就使用一般内存，同auto ;

register变量必须是能被CPU所接受的类型。这通常意味着register变量必须是一个单个的值，并且长度应该小于或者等于整型的长度。
不能用“&”来获取register变量的地址。
由于寄存器的数量有限，真正起作用的register修饰符的数目和类型都依赖于运行程序的机器。
在某些情况下，把变量保存在寄存器中反而会降低程序的运行速度。因为被占用的寄存器不能再用于其它目的；或者变量被使用的次数不够多，不足以装入和存储变量所带来的额外开销。

---

变量的存储类型static：
static变量称为静态存储类型的变量，既可以在函数体内，也可在函数体外说明。(默认是0）
局部变量使用static修饰,有以下特点:
在内存中以固定地址存放的，而不是以堆栈方式存放
只要程序没结束，就不会随着说明它的程序段的结束而消失，它下次再调用该函数，该存储类型的变量不再重新说明，而且还保留上次调用存入的数值。

---

变量的存储类型extern：
当变量在一个文件中的函数体外说明，所有其他文件中的函数或程序段都可引用这个变量。
extern称为外部参照引用型，使用extern说明的变量是想引用在其它文件中函数体外部说明的变量。
static修饰的全部变量，其它文件无法使用

---

思考：
C语言中，变量的存储类型有哪些？
修饰局部变量时，auto和static有什么区别？

---

补充：
vsp :在底行模式下打开另一个编辑界面、
：vsp extern1.c

tail -n file 将VI界面下的程序后N行放到终端界面显示
N不写 默认为10行

---

联合编译：
当一个文件想使用另一个文件的东西时，需要将两个文件联合起来编译
linux@linux:~/xiaoyu/extern$ gcc extern1.c extern2.c -o extern2 -Wall

四、运算符

1、算术运算符-掌握
2、关系运算符-掌握
3、逻辑运算符-掌握
4、掌握C语言中的位运算符
5、掌握赋值运算符
6、掌握特殊运算符
7、熟悉运算符的优先级

---

算术运算符：
C提供的算术运算符:+，-，*，/，%，++，如下:float/double不能取余

例如，
int a=15, b=8,c;
double x=15, y=8, z;
c = a + b ;    c = a – b;    c = a * b;    c = a / b; // c 赋值为
c = a % b;    // c 赋值为
z = x + y ;     //z 赋值为 
z = x - y;        // z 赋值为
z = x * y ;     // z 赋值为
z = x / y ;     // z 赋值为
z = x % y ;  

 int  x=5, y=9, z;
        z =  ++x ;   
        z =  x++ ;   
        z =  --x ;    
        z =  x-- ;  
        z= ++x + y++ ;  
        z= --x + y++ ;  
        z= ++x + y-- ;  

---

关系运算符：
C语言的关系运算符如下:

例如，
int  a=5, b=6;
a>(b-1)        结果值为0  
(a +1)== b  结果值为1
a>=(b-2)      结果值为1
a<100          结果值为1
(a+3)<=b    结果值为0
a != (b-1)     结果值为0

逻辑运算符：
C语言的逻辑运算符如下:

逻辑非“!”运算符的运算律如下：

例如，
int  k=8;
! ( k ==0)        结果值为1
! ((k-8) == 0)   结果值为0
! (k<= 0)         结果值为1

逻辑与“&&”运算符的运算规律如下：短路特性-逢0截止

逻辑或“||”运算符的运算规律如下：短路-逢1截止

例如
int  x=5, y=18;
(x>=5) && (y<20)        	结果值为1
((x+1)>=0) && (y<17)      	结果值为0
((x-8)>=0) && (y==18)      	结果值为0
((x-5)>0)  && (y!=18)    	结果值为0
((x>=5))   ||  (y<20)     结果值为1
((x+1)>=0) ||  (y<17)      结果值为1
((x-8)>=0) ||  (y==18)      结果值为1
((x-5)>0)  ||  (y!=8)     	结果值为1

---

位运算符：
C语言的位运算符如下:

例如:
unsigned char  x=0x17, y;
y = ~x;

位逻辑与“&”运算符的运算规律如下：

例如，
unsigned char x=0126, y=0xac, z;
z = x & y;

---

十六进制表示方法：

%# ：输出十六进制
# ：显示十六进制的 0X
******带#号***********
y=0x17;
printf("%#x\n",y);
********编译结果*************
0x17

*********没有#号*******
y=0x17;
printf("%x\n",y);
/********编译结果*************
17

---

左移/右移：

0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8

左移就是乘2，右移就是除2

五、补充-C99

C99标准是 ISO/IEC 9899:1999 - Programming languages – C 的简称[1] ，是C语言的官方标准第二版。1999年12月1日，国际标准化组织（ISO）和国际电工委员会（IEC）旗下的C语言标准委员会（ISO/IEC JTC1/SC22/WG14）正式发布了这个标准文件[2] 。

C99标准简介编辑
C99是在C89/90的基础上发展起来的，增加了基本数据类型、关键字和一些系统函数等。
C99有一部分是对于增加了宽字符集，还加入了一些库函数，是继C89标准之后的第二个C语言官方标准。第一个C++语言官方标准C++98标准，就是基于C89编写的，因此C99标准新增的语法特性在C++的编译器中就或多或少地支持了，而完全或几乎完全支持C99标准的主流编译器有：GCC[3] 、Clang[4] 、Intel C++ Compiler[5] 等。另外，Visual Studio2013也部分支持了C99语法特征[6] 。
C99标准的草案是免费的[7] 。
C99标准的新特性编辑
在ANSI标准化发布了C89标准以后，C语言的标准在一段相当的时间内都保持不变，尽管C++继续在改进。（实际上，Normative Amendment1在1995年已经开发了一个新的C语言版本（即C95）。但是这个版本很少为人所知。）标准在90年代才经历了改进，这就是ISO/IEC 9899:1999（1999年出版）。这个版本就是通常提及的C99。
在C99中包括的特性有：
对编译器限制增加了，比如源程序每行要求至少支持到 4095 字节，变量名与函数名的要求支持到 63 字节 (extern 要求支持到 31)。
预编译处理增强了。例如：
支持了可变参数的宏（Variadic Macro）： #define Macro(…) VA_ARGS
使用宏的时候，参数如果不写，宏里用 #，## 这样的东西会扩展成空串。(C89标准中会出错的)
可变参数宏的示例代码：
#include <stdio.h>

#define MY_DEBUG_LOG(…) (printf(VA_ARGS))
#define MY_DEBUG_TRACE(format,…) (printf(format,##VA_ARGS))

int main(void)
{
MY_DEBUG_LOG(“Hello, world! The value is:%d\n”, 100);
MY_DEBUG_TRACE(“Hello, world! The value is:%d\n”, -100);

MY_DEBUG_LOG("Hello,world!");
MY_DEBUG_TRACE("Hi,there!");
  //MY_DEBUG_TRACE("424632975");
  //MY_DEBUG_TRACE("Q qun +上面");

}
支持 // 行注释（这个特性实际上在C89的很多编译器上已经被支持了）
增加了新关键字 restrict，inline，_Complex，_Imaginary，_Bool
支持 long long，long double _Complex，float _Complex 这样的类型
支持 <: :> <% %> %: %:%: ，等等奇怪的符号替代，D&E 里提过这个
支持了不定长的数组。数组的长度就可以用变量了。声明类型的时候呢,就用 int a[*] 这样的写法。不过考虑到效率和实现，这玩意并不是一个新类型。所以就不能用在全局里，或者 struct union 里面，如果你用了这样的东西，goto 语句就受限制了。
变量声明不必放在语句块的开头，for 语句提倡这么写 for(int i=0;i<100;++i) 就是说，int i 的声明放在里面，i 只在 for 里面有效。(VC6.0没有遵守这条标准，i 在 for 外也有效；但vc2005里已经默认是i在外面不可见了，但有编译选项可以设置。）
复合字面量：当一个类似结构的东西需要临时构造的时候，可以用 (type_name){xx,xx,xx} 这有点像 C++ 的构造函数
相较于C89标准，C99标准新增了一种结构体/数组的初始化方式，名叫designated initializers[8] ，即：
struct { int a[3], b; } w[] ={ [0].a = {1}, [1].a[0] = 2 };[9]
字符串里面，\u 支持 unicode 的字符
支持 16 进制的浮点数的描述
所以 printf和scanf 的格式化串增加了支持 “%lld"和”%llu"，对应long long int类型和unsigned long long int类型（可以分别简写为long long和unsigned long long）。
浮点数的内部数据描述支持了新标准，这个可以用 #pragma 编译器指定
增加了一个内置的局部静态字符数组变量 func ，可以用于得到当前函数的函数名[10] 。
对于非常量的表达式，也允许编译器做化简
修改了 /% 处理负数时的定义，这样可以给出明确的结果，例如在C89中-22 / 7 = -3, -22% 7 = -1，也可 以-22 / 7= -4, -22% 7 = 6。 而C99中明确为 -22 / 7 = -3, -22% 7 = -1，只有一种结果。
取消了不写函数返回类型默认就是 int 的规定
允许 struct 定义的最后一个数组写做 [] 不指定其长度描述
const const int i; 将被当作 const int i; 处理
增加和修改了一些标准头文件。比如定义 bool 的 <stdbool.h>，定义一些标准长度的 int 的 <inttypes.h>，定义复数的 <complex.h> 定义宽字符的 <wctype.h> 有点泛型味道的数学函数 <tgmath.h> 跟浮点数有关的 <fenv.h>。<stdarg.h> 里多了一个 va_copy 可以复制 … 的参数。<time.h> 里多了个 struct tmx 对 struct tm 做了扩展
输入输出对宽字符还有长整数等做了相应的支持
long double_Complex；long double_Imaginary。
<complex.h>头文件中定义了complex和imaginary宏，并将它们扩展为_Complex和_Imaginary，因此在编写新的应用程序时，应该使用<stdbool.h>头文件中的complex和imaginary宏。下面是关于C99所支持的复数语法特性的使用示例代码：

#include <math.h>
#include <stdio.h>
#include <complex.h>

int main(void)
{
float_Complex f = -1.0f;
f = csqrtf( f ) + 1.0iF;
printf( “Thecomplexnumberis:%g+i %g\n”, crealf(f), cimagf(f) );
double_Complexd=cexp(2.0i * M_PI);
printf( “e^(i2PI) = %f+i%f\n”, creal(d), cimag(d) );
}
long long int
C99标准中引进了long long int（-263至263 - 1）和unsigned long long int（0到264 - 1）。long long int能够支持的整数长度为64位。
C99标准的后续标准编辑
C99标准之后，新的C语言标准是国际标准化组织（ISO）和国际电工委员会（IEC）在2011年12月8日正式发布的C11标准，官方正式名为ISO/IEC 9899:2011[11] 。