C语言(最全)

1.编译程序
(1)gcc xx.c,他会默认生成一个a.out的可执行文件,在a.out所在目录,执行./a.out
(2)gcc xx.c -o xx,生成一个xx可执行文件,注意不要命名成xx.c,这样会覆盖原先的xx.c文件内容
(3)gcc xx.c -o xx -g -Wall,-g -Wall的意思是开启所有的语法警告,
(4)gcc只检查语法错误,不会检查逻辑错误
(5)每次修改完.c程序都必须要执行一次gcc

如果觉得gcc太麻烦,写一个shell脚本
思路:
mygcc xx.c
(1)参数
(2)xx.c文件是否存在
(3)如果存在,rm ./a.out gcc xx.c
(4)如果gcc出错,#判断./a.out这个文件是否存在,exit
(5)./a.out

1 if [ $# -eq 0 ]
2 then
3 echo "gcc what"
4 elif [ $# -eq 1 ]
5 then
6 if [ -e $1 ]
7 then
8 if [ -f $1 ]
9 then
10 #是否是.c文件
11 if [ -e ./a.out ]
12 then
13 rm ./a.out
14 fi
15 gcc $1
16 if [ -e ./a.out ]
17 then
18 ./a.out
19 fi
20 else
21 echo "$1 is not a file"
22 fi
23 else
24 echo "no such file"
25 fi
26 else
27 echo "too much arguments"
28 fi

2.hello world程序
(1)
int main()
{

return 0;

}

(2)可执行程序一执行,就会去找一个叫做main函数,然后运行main大括号里面的语句
(3)一个.c文件有且只能有一个main的函数
(4)如果一个函数碰到return就代表这个函数运行结束,return后面的语句将永远不会被执行
(5)如果是main函数,他可以将前面的int省略,return也是可以省略
(6)main(int argc,char *argv[])
(7)#include<stdio.h>是一个c语言标准输入输出库

3.注释
(1)//代表单行注释
(2)/* /多行注释,第一个/会与遇到第一个*/匹配

4.注释使用情况
(1)注释代码
(2)解释代码
(3)写清文件名,文件制作方,如果是某人:要写清联系方式

4.printf:打印函数
打印""里面的语句
\n:转义字符,代表换行

5.代码格式
main()
{

}
注意:每碰到一个{,就要换行,再来一个Tab键

6.常量
1>常量
(1)1,2,3,4:整型常量
(2)'a','b','c':字符常量
(3)1.2,2.4:浮点常量
(4)"hello world":字符串常量
(5)0xff1:地址常量

2>常量的特点
(1)常量不会改变
(2)常量不能作为左值
(3)8,const(只读常量),define(宏常量)

7.地址
内存:字节:Byte是计算机存储的最小单位
位:bit:一个字节占8位
1M=1024KB
1KB=1024Byte
1Byte=8bit

地址:是每一个字节所对应的编号
(中国===>每一个家庭(房子)===》门牌号)
(计算机===>字节========》地址)

8.进制
二进制:0~1 以0B,0b,
八进制:0~7 以0开头,012
十进制:0~9
十六进制:0~15,0x开头,0X
10:a,A
11:b:B
12:c:C
13:d:D
14:e:E
15:f:F

2,8,16进制===>10进制
12:1X101+2X100=12

0b0010:0X23+0X22+1X21+0X20=2

012:1X81+2X80=10

0x12:1X161+2X160=18

10进制===》2,8,16进制
12:1100=1X23+1X22
12/2=6...0 [1]
6/2=3...0 [2]
3/2=1...1 [3]
1/2=0..1 [4]

9.变量
1>变量的特点
(1)可以改变的量
(2)可以作为左值,也可以作为右值

2>变量的定义
在shell脚本里:变量名=值
在C语言里面:数据类型 变量名;
同时定义多个同种类型的变量:数据类型 变量1,变量2;

3>数据类型
整型数据类型:int
字符数据类型:char
浮点类型:float(单精度) double(双精度)
float类型的变量是精确到7位
double类型的变量是精确到16位(具体根据编译器定)

数据类型的作用
(1)标志着后面的变量具体是接收什么类型的值
(2)这个变量在内存当中占几个字节
int:4
char:1
float:4
double:8

4>整型变量
(1)int value=8;
(2)int value;value=7;
5>字符变量
(1)char ch='c';
(2)char ch;ch='d';
6>浮点变量
(1)float f1=1.2;
(2)double f2=2.3;

7>变量的使用
int value;
value=8;

10.标识符的命名规范
硬性规范:
1>不能用数字开头
2>只能由字母,下划线和数字组成
3>不能与C语言关键字相同

建议的规范:
1>不能用拼音,多查字典
2>尽量使用驼峰numOfStudent,num_of_student
3>见名知义

10.printf具体的用法
1>
int a=6;
float b=9.8;
printf("a=%d,b=%f\n",a,b);
%d:占位符,是输出整数
%c:占位符,是输出字符
%f:占位符,是输出浮点数

2>%m.nf
m<=n+1+整数实际部分的位数,m无效
m>n+1+整数实际部分的位数,m有效,左边以空格补全

11.大端小端存储法
小端法:低位上的数存储在低的地址所对应的字节
大端法:低位上的数存储在高的地址所对应的字节

用处:一般网络传输内容的时候
0x0123456:小端
hston

0x56342301:大端
hntos

12.打印特殊字符
":\"
':\'或'
%:%%
\:\\

13.字符与ASCII编码
1>字符是一个特殊的整型,占8位
2>记住的字符
'\0':0
'空格':32
'0':48
'A':65
'a':97
全球unicode编码

14.scanf:scan formatter格式化输入函数
1>基本用法
int a;
//&a:取a变量的地址
scanf("%d",&a);
printf("a=%d\n",a);

2>同时输入多个变量
int a;
int b;
scanf("%d%d",&a,&b);

3>
%d:
%f:
%c:
%lf:输入double类型的数据
%p:输出变量的地址

注意点:
(1)scanf,后面必须是取变量的地址
(2)一个变量必须先定义出来,再进行scanf
(3)不要在scanf()里面做小动作

15.getchar()和putchar()
char ch;
ch=getchar();
putchar(ch);

16.数据类型转换
1>隐式转换:精度小的===》精度大的
char===>short int===>int====>float===>double

2>强制类型转换
(数据类型)变量/常量
int a=9;
int b=8;

float c=(float)a/b;
printf("c=%f\\n",c);

0:+
1:-
1+(-1)=0;
0000 0000 | 0000 0000 | 0000 0000 | 0000 0001
+1000 0000 | 0000 0000 | 0000 0000 | 0000 0001
1000 0000 | 0000 0000 | 0000 0000 | 0000 0010
问题:如果是按照上面的格式去运算1+(-1)=-2,不符合事实逻辑

原码:
反码:正数的反码与原码相同;负数的反码在原码的基础之上,符号位不变,后面依次取反(0变1,1变0)
补码:正数的补码与原码,反码相同。负数的补码在反码基础之上+1

解决之道:
1: 0000 0000 | 0000 0000 | 0000 0000 | 0000 0001

-1:
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 0001
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1110
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1111
0000 0000 | 0000 0000 | 0000 0000 | 0000 0001
+1111 1111 | 1111 1111 | 1111 1111 | 1111 1111
10000 0000 | 0000 0000 | 0000 0000 | 0000 0000

结论:
(1)数据在内存当中是以数据的补码存在。
(2)数据是以补码存在,原码输出

18.运算符
注意点:计算机只进行相同类型数据的运算,最后算出来的结果也与他们相同的数据类型
1>算数运算符
+:
-:
*:
/:
%:%左右两个的数都必须是整数
++:

案例:
后缀++:
int a=9;
int b=a++;//b=a,a=a+1
printf("b=%d\na=%d\n",b,a);

前缀++:
int a=9;
int b=++a;//a=a+1,b=a
printf("b=%d\na=%d\n",b,a);

后缀--:
int a=9;
int b=a--;//b=a,a=a-1
printf("b=%d\na=%d\n",b,a);

前缀--:
int a=9;
int b=--a;//a=a-1,b=a
printf("b=%d\na=%d\n",b,a);

2>位运算
|:位或:有1就为1

案例:
3:0011
|5:0101
0111

&:位与:有0就为0

案例:
3:0011
&5:0101
0001

^:异或:只要不同就为1
案例:
3:0011
^5:0101
0110=6

~:取反运算:按位取反

案例:正数取反
3:0000 0000 | 0000 0000 | 0000 0000 | 0000 0011
~3:
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1100
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1011
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 0100

案例:负数取反
-3:
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 0011
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1100
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1101
~(-3):
补码:0000 0000 | 0000 0000 | 0000 0000 | 0000 0010

<<:左移:
案例:正数
3:
0000 0000 | 0000 0000 | 0000 0000 | 0000 0011
<<2
0000 0000 | 0000 0000 | 0000 0000 | 0000 1100

案例:负数
-3:
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 0011
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1100
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1101
<<2
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 0100
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 0011
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 1100

:右移
案例:正数
3:
原码:0000 0000 | 0000 0000 | 0000 0000 | 0000 0011
2
0000 0000 | 0000 0000 | 0000 0000 | 0000 0000

案例:负数
-3:
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 0011
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1100
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1101

2:右移以符号位补全
补码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1111
反码:1111 1111 | 1111 1111 | 1111 1111 | 1111 1110
原码:1000 0000 | 0000 0000 | 0000 0000 | 0000 0001

3>关系运算符

:
<:
=:
<=:
==:
!=:
在计算当中,关系运算符构成的运算,我们可以看成一个事件,如果这个事件成立,其结果(逻辑结果【0/1】)1;如果事件不成立,其结果为0

4>逻辑运算符
事件1&&事件2:并且,事件1成立并且事件2也成立,整个逻辑结果才为1;否则,整个逻辑结果为0
事件1||事件2:或者,事件1成立或者事件2也成立,整个逻辑结果才为1;否则,整个逻辑结果为0
!事件:非,如果事件成立,逻辑结果1,!1,整个结果为0;否则,逻辑结果为1

进阶:
事件1&&事件2:如果事件1不成立,就不会执行&&后面的运算
事件1||事件2:如果事件1成立,就不会执行||后面的运算

4>取地址运算符
&
案例:
int a;
printf(“a的地址=%p\n”,&a);

5>字节长度运算符
sizeof(数据类型/变量名)

6>三目运算符(条件运算符)
事件1?事件2:事件3
用法:如果事件1成立,就执行事件2,将事件2的运算结果作为整个事件的结果;
如果事件1不成立,就执行事件3,将事件3的运算结果作为整个事件的结果;

总结:
1>()===>单目====》算数=====》关系====》逻辑====》三目=====》赋值====》,
2>单目====》双目=====》三目

19.三大执行流程
(1)顺序执行流程
(2)条件执行流程
(3)循环执行流程

int a=8;
int b=7;
int c=a+b;

20.条件执行流程
1>
if(条件)
{

}
用法:如果条件成立,就执行{}里面的语句

注意点:
(1)如果{}不加,只会执行if下面语句的一行代码
if(条件)
语句
(2)不管if下面执行几条语句,请你用{},便于将来代码调试

2>
if(条件)
{
语句体;
}
else
{
语句体;
}

3>
if(条件)
{
语句体;
}
else if(条件)
{
语句体;
}

4>
if(条件)
{

}
else if(条件)
{

}
else if(条件)
{

}
else
{

}

注意点:
(1)如果if语句有else,那么else必须放在最后,不可以放在if 和else if中间
(2)if语句可以嵌套

/*
练习:
1>输入一个成绩score,
0<=score<60:D
60<=score<85:C
85<=score<90:B
90<=score<100:A
用if语句实现

2>输入一个你的工资,如果工资小于等于1000,那么所得的工资就是实际工资;如果工资大于1000,大于1000的部分需要缴纳0.05的税,求实际所得到的工资总额,使用三目运算符完成
*/

22.条件分支switch
/*
死人(王五)
案例1(根据张三握了他的手):张三;

案例2(根据喉咙发黑,李四跟死者喝酒):李四

案例3(柯南脖子有嘞痕):王二麻子

案例4 (仓老师):王任;
*/

/*
switch(变量)//ch
{
case 常量1:
语句体1;
break;//跳出

case 常量2:
    语句体2;
    break;

case 常量3:
    语句体3;
    break;

default:
    语句体4;
    break;

}

用法分析:
看变量与下面的常量值那个相同,就执行对应的语句体,执行完之后跳出switch},继而执行下面的语句

注意点:
(1)case后面的值必须是常量。
(2)case后面的值是唯一的,不能与其他case后面的值相同
(3)default可以没有,也可有,有的话可以放在任意位置
(4)每一个case后面的语句都必须要有break

/*
输入两个整数,再输入一个运算符,根据运算符的+ - * /,然后计算相应的运算结果,使用switch-case完成
*/

吸收输入缓存流里面的回车残留,
1>char ch;
scanf(“%c”,&ch);

2>getchar()

3>getc(stdin)

23.循环
whie(条件)
{
语句体;
}

/*

晚上作业:
打印如图:






*/

24.do—while
do
{
语句体;

}while(条件);

25.for循环
for(表达式1;条件;表达式3)
{
语句体2;

}

分析:
【1】先执行表达式1,表达式1有且只执行一次;
【2】再去判断条件是否成立;如果条件成立,就执行语句体2;
【3】执行完语句体2之后再去执行表达式3
【4】再从步骤2开始判断

注意点:
(1);不能省略,也不能写成,隔开
(2)表达式1,表达式2,表达式3都可以省略,但是;不能省略。如果三个表达式都省略,代表这个for循环是一个死循环

案例:
int i;
int sum=0;
for(i=1;i<=100;i++)
{
sum+=i;

}

26.break的用法
(1)break只能用在switch,while,do—while,for
(2)break是跳出整个循环,继而执行下面的代码
(3)当碰到break语句时,break下面的直到循环体}里面的代码不会被执行
(4)break只跳出最近的一层循环

27.continue
(1) continue只能用在while,do—while,for
(2) continue是跳出一次循环,继而执行下面的循环
(3)当碰到continue语句时,continue下面的直到循环体}里面的代码不会被执行,但是for表达式3还会继续执行
(4) continue只跳出最近的一层循环的一次循环

/*
判断200~300之间的素数
素数:只能被1和他本身整除的数
如果是素数,就输出该数
*/

28.数组
1>数组的定义
int array[4];

2>数组的初始化
//1.数组的初始化
int array1[6]={1,3,5,6,7,8};

//2.元素不足用0补全
int array2[6]={1,3,4};

//3.如果行号省略,根据后面元素的实际个数确定行号
int array3[]={1,2,3,5};

//4.
int array4['a']={1,2,3};

//5.
int array5[6]={[4]=8,[5]=7};

3>数组元素的访问:数组名[下标]
0<=下标<数组大小

29.指针
指针:就是地址

1>指针的定义和初始化
int a;
int *p=&a;

int *q;
q=&a;

2>同时定义多个指针变量
int p1,p2;
不能这么写:int *p1,p2;就代表p1是指针变量,p2是整型变量

3>二级指针:指针的指针
int a;
int *p=&a;
int **q=&p;

使用q访问a:**q=8;

4>指针所占字节数
int *,char *,float *…
在32位机:4个字节
在64位机:8个字节

30.指针与一维数组的关系
数组名就相当于首元素的地址
int arr[4];
int *p=arr;

第i个元素的地址:arr+i==>&arr[i]===>p+i===>&p[i]
第i个元素:(arr+i)====>arr[i]===>(p+i)====>p[i]

区别:
1>arr不能自加,因为arr相当于一个int * const arr;
2>p可以自加

31.const关键的使用
constant,如果一个变量使用const修饰,代表这个变量属性只读,不可写(不可改变)
const变量只能在定义的时候进行初始化

const int a;
int const a;
两者效果一样,

int a=9;
const int *p=&a;
int const p=&a;
如果const是写在
号的左边,代表这个变量将来如果用p访问变量的时候,内容只读,这两种写法,效果一样

int a=9;
int b;
int const p=&a;
如果const是写在
号的右边,代表这个指针变量本身的内容只读,不可更改

int a=9;
int b;
const int * const p=&a;
如果*左右两边都有cosnt,代表p所指向的内容只读,p本身的内容只读

/*
练习:定义一个整型数组,使用指针去对数组进行排序
练习:
int arr[5]={1,2,3,4,5};
请你将数组元素颠倒输出,变成{5,4,3,2,1},不准使用第二个数组。
练习:使用指针交换两个变量的值

*/

32.指针数组
//指针数组
//先算[],代表他是一个数组,再算*,代表这个数组所有的元素都是指针

int a,b,c;
int *p[3]={&a,&b,&c};
*(p[0])=7;
printf("a=%d\\n",a);

33.二维数组
1>
/*
二维数组:看成多个一维数组构成
*/
//2代表行数,3代表列数
//二维数组的定义
int arr[2][3];

//1.
int arr1[2][3]={{1,2,3},{4,5,6}};

//2.
int arr2[2][3]={1,2,3,4,5,6};

//3.
int arr3[2][3]={{[1]=3},{[2]=6}};

//4.
int arr4['a'][3]={1,2,3};

//5.行号省略,取后面算元素的个数,找到最近的数是列的倍数
int arr5[][3]={1,2,3,4};

//错误的,列号不能省略
//int arr6[5][]={1,2,3,4};

2>访问二维数组元素
//数组名[行下标][列下标];
//0<=行下标<行数 0<=列下标<列数

//    int arr6[2][3];错误
//    arr[2][3]={1,2,4,5,6};

3>
/*
第i行首元素的地址:&arr[i][0]===>arr[i]===>(arr+i)===>arr+i
第i行j列元素的地址:&arr[i][j]====>arr[i]+j===>
(arr+i)+j
第i行j列元素:arr[i][j]===>(arr[i]+j)====>(*(arr+i)+j)
*/

4>数组指针
//先算(p),代表p是一个指针变量,再算[3];代表这个指针变量将来指向一个大小为3的一维数组,数组指针,行指针
int (
p)[3]=arr;

34.函数
1>函数定义格式
数据类型 函数名(数据类型 变量1,数据类型 变量2,......)
{

}
数据类型:[unsigned ]int ,char ,float ,double,void(空类型)

2>形参
形参:形式上的参数,在函数定义的时候存在

3>实参
实参:有实际意义的参数,在函数调用的时候存在

4>函数定义注意点:
(1)函数不能嵌套定义
(2)函数名不能与系统提供的函数名相同
(3)函数不能重复定义
(4)如果函数的数据类型是int,char,float。。。,那么这个函数必须要有return,return 后面的值的数据类型必须要与函数的数据类型保持一致
(5)如果函数的数据类型是void,那么函数可以有return,也可以没有return,如果有return的话,return后面没有数值
(6)函数定义时形参的个数,必须要与函数调用时实参个数相同
(7)形参变量的数据类型即使相同,也不能省略数据类型,比如:如下错误void sum(int a,b);必须要写成void sum(int a,int b)
(8)形参个数可以是多个,没有限制;形参变量的数据类型可以各不相同

5>函数调用:函数名();

6>return在函数中的作用
(1)函数结束的标志,当函数碰到return时,该函数return下面的语句不会被执行
(2)将return后面的值返回给函数调用者

7>函数的递归:函数自己调用自己

8>函数指针
//先算(p),代表p是一个指针变量;再算(),代表将来p这个指针执行一个没有形式参数的函数;再看void,代表p指向的这个函数返回值是void类型
//函数名是函数的入口地址
void (
p)()=test;

9>指针函数
//指针函数:就是函数的返回值是指针
//不要返回一个自动存储类型的局部变量的地址

35.变量按作用域分
1>局部变量:定义在函数内部的变量叫做局部变量
2>全局变量:定义在函数外部的变量叫做全局变量
作用域只能决定访问性

注意点:
如果全局变量和局部变量同名,局部变量会看不见全局变量的存在

变量按生存期分
静态变量:
自动变量:

局部变量
1>静态局部变量
2>自动局部变量

全局变量
1>静态全局变量
2>自动全局变量

/*
1>利用函数求一个数组的最大值。

2>将万年历改成函数格式,对其进行合理(按模块功能)的封装

3>
(1)指针
一维数组
二维数组
函数

(2)
指针和变量关系
指针和一维数组
指针和二维数组
指针和函数

(3)
指针数组:
数组指针:
指针函数:
函数指针:

*/

推荐阅读更多精彩内容

  • 指针是C语言中广泛使用的一种数据类型。 运用指针编程是C语言最主要的风格之一。利用指针变量可以表示各种数据结构; ...
    朱森阅读 1,812评论 3 42
  • 1.编译程序 (1)gcc xx.c,他会默认生成一个a.out的可执行文件,在a.out所在目录,执行./a....
    萌面大叔2阅读 40评论 0 1
  • 第1章 第一个C程序第2章 C语言基础第3章 变量和数据类型第4章 顺序结构程序设计第5章 条件结构程序设计第6章...
    小狮子365阅读 5,791评论 4 64
  • 一、栏目简介 《长江大讲堂》是一档期货投资者教育栏目,由长江期货资深研究员担任讲师,从专业角度为广大期货爱好者提供...
    琳郎_3411阅读 203评论 0 5
  • 2015年12月2日,我在朋友圈发了这张图 当时,正值我一边百度PS教程一边请教师弟一边做着各种海报。 我一直觉的...
    A_7阅读 18评论 0 0