C语言基础

如何判断自己的C语言开发水平
1.编程是否规范，比如编写代码是否规范、是否时刻关注内存使用情况；
2.是否能够灵活使用指针；
3.是否熟练掌握链表、队列这些高级数据结构知识

国际标准：
ANSI - C89
C99 /C11

C代码
.c 源文件
.h 头文件

主函数-程序入口-main函数有且仅有一个
main前面的int表示main函数调用返回一个整型值

#include <stdio.h>
包含一个叫stdio.h的文件
std -标准 standard input output

全局变量与局部变量
局部变量和全局变量的名字建议不要相同–容易误会，产生bug
当局部变量和全局变量的名字相同的时候，局部变量优先。

#include <stdio.h>
#include <stdlib.h>
//全局变量 
int a = 100;
int main(int argc, char *argv[]) {
	{
		//局部变量 
		int a = 10; 
	}
	printf("a=%d\n",a);
	return 0;
}

作用域：
作用域（scope) 程序设计概念 一般程序代码中所用到的名字并不总是有效/可用的
而限定这个名字的可用性的代码范围就是这个名字的作用域
1.局部变量的作用域是变量所在的局部范围
2.全局变量的作用域是整个工程

生命周期
变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段
1.局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。
2.全局变量的生命周期：整个程序的生命周期

常量
C语言中的常量和变量的定义形式有所差异。
C语言常量分为以下几种：
字面常量
const修饰的常变量：const int n = 10; n是变量，但是又有常属性， n是常变量

这种结构错误：
const int n = 10;
int a[n] = {0};
//[Error] variable-sized object may not be initialized

标识符常量

#define 定义的标识符常量
#define  Max 10
int main(int argc, char *argv[]) {
	int a[Max] = {0};
	return 0;
}

枚举常量
枚举：一一列举
枚举关键字：enum

enum Sex{
	FEMALE,
	MALE,
	SECREAT
};
int main(int argc, char *argv[]) {
	printf("%d\n", FEMALE); //0
	printf("%d\n",MALE);     //1
	printf("%d\n",SECREAT); //2
	return 0;
}

字符串
“hello bit.\n”
这种由双引号引起来的一串字符称为字符串字面值（String Literal) 或者简称字符串。
字符串的结束标志：\0转义字符，计算字符串长度的时候\0是结束标志，不算作字符串内容。

int main(int argc, char *argv[]){
	char arr1[] = "abc"; //数组
	char arr2[] = {'a','b','c','\0'};//'\0'字符串结束标志 
	printf("%s\n",arr1); // abc
	printf("%s\n",arr2); //abc
	return 0; 
}

#include<string.h>
int main(int argc, char *argv[]){
    char arr1[] = "abc";
    char arr2[] = {'a','b','c','\0'};
    printf("%d\n",strlen(arr1)); //3
    printf("%d\n",strlen(arr2)); //3
	return 0; 
}

转义字符：
? :在书写连续多个问号时使用，防止他们被解析成三字母词
’ :用于表示字符常量’
" :用于表示一个字符串内部的双引号
\ :用于表示一个反斜杠，防止它被解释为一个转义序列符
\a :警告字符，蜂鸣
\b :退格符
\f :进纸符
\n:换行
\r:回车
\t:水平制表符
\v:垂直制表符
\ddd: ddd表示1-3个八进制的数字
\xdd: dd表示2个十六进制数字

int main(int argc, char *argv[]){
    //  32是2个8进制数字
    // 32作为8进制代表的那个十进制数字，作为ASCll码值  对应的字符 
    // 32 10进制26  作为ASCll码值代表的字符 
   printf("%c\n",'\32');
   return 0;
}

算数操作符 + - * / %
移位运算符 << >>
移（2进制）位操作符
& 按位与
^ 按位异或
| 按位或
赋值操作符
= += -= *= /= &= ^= |= >>= <<=

单目运算符
！ 逻辑反操作（真假 0 1）
-负值
+正值
&取地址
sizeof 计算的是变量/类型所占空间的大小(以字节为单位)
~对一个数的二进制按位取反
int a = 0;
int b = ~a; //按2进制位取反
printf(“%d\n”,b);

– 前置、后置 –
++ 前置、后置++
int a = 10;
//int b = a++; //后置++ 先使用 再++
//int b = ++a; //前置++ 先++ 再使用
int b = a–; //后置-- 先使用 再–
printf(“a=%d b=%d\n”,a,b);

*间接访问操作符（解引用操作符)
(类型）强制类型转换

求数组元素个数：
sz = sizeof(arr)/sizeof(arr[0])

字符串结束标志：‘\0’
‘\0’ 转义字符 ASCll码：0
0 数字0
‘0’ ASCLL码：48
EOF end of file -文件结束标志

关系运算符 > >= < <= !=(用于测试“不相等") ==(用于测试 “相等")
逻辑操作符
&& 逻辑与
|| 逻辑或
！ 非
条件操作符
exp1 ? exp2 : exp3

下标引用、函数调用和结构成员
[] () . ->

只要是整数，内存中存储的都是二进制的补码
正数–原码 反码 补码 相同
负数：
原码 反码 补码
直接按照正负 原码的符号位不变 反码+1
写出的二进制序列 其他位按位取反得到
常见关键字
auto break case char const continue default do double
else enum extern float for goto if int long register
return short signed sizeof static struct switch typedef union unsigned void volatile while

auto int a = 10; //局部变量-自动变量 auto一般省略
register int a = 10;//建议把a定义成寄存器变量
signed int ; //定义的变量是有符号的（signed 省略)

计算机 存储数据
寄存器
高速缓存
内存
硬盘

//typedef  -类型定义
typedef unsigned int  u_int32;
u_int32 num = 20;
printf("%d\n",num); 
return 0;

关键字 static
static 用来修饰变量和函数的
1.修饰局部变量-静态局部变量 局部变量的生命周期变长了
2.修饰全局变量-静态全局变量 改变了全局变量的作用域，让静态的全局变量只能在自己所在的源文件内部使用。出了源文件就没法再使用了。
3.修饰函数-静态函数 static 修饰函数改变了函数的链接属性
普通函数具有外部链接属性
static 修饰，外部链接属性->内部链接属性

void test()
{
	static int a = 1;
	a++;
	printf("a=%d\n",a);
}
int main(int argc, char *argv[]){
  
	int i = 0;
	while(i<5){
		test();
		i++;
	}
 	return 0;
}
a=2
a=3
a=4
a=5
a=6

//extern -声明外部符号的 
extern int arc_num;
printf("arc_num:%d\n",arc_num);
return 0;

static 修饰函数

test.c
int Add(int x, int y){
	return x + y;
} 

main.c
//声明函数 
extern int Add(int, int);
int main(int argc, char *argv[]) {
	
	int sum = Add(2,3);
	printf("sum=%d\n",sum);
	return 0;
}

#define 定义标识符常量

#define MAX  100
//定义宏
#define MAX(X,Y)  (X>Y?X:Y)
int main(int argc, char *argv[]) {
 	int max = MAX(4,5);
 	printf("max=%d\n",max);
	return 0;
}

内存
如何产生地址
32位地址线/数据线
正电和负电
1 0
一个字节为一个空间

指针

int a = 4; //4个字节
int* p = &a; //取地址
//有一种变量是用来存放地址的-指针变量 
printf("%p\n",&a); 
printf("%p\n",p);
*p = 20; //* -解引用操作符
printf("%d\n",a); 

000000000062FE14
000000000062FE14
20

指针大小在32位平台是4个字节，64位平台是8个字节。

char a = '3'; 
char* p = &a;
printf("%d\n",sizeof(p));  //8

double b = 3.13;
double* p1 = &b;
printf("%d\n",sizeof(p1)); //8

结构体
复杂对象–结构体 我们自己创造出来的一种类型。

//创建结构体 
struct Book
{
	char name[20];
	short price;
};
int main(int argc, char *argv[]) {
	//利用结构体类型-创建一个该类型的结构体变量
	struct Book b1 = {"C语言程序设计",55};
	printf("书名:%s\n",b1.name);
	printf("价格:%d\n",b1.price);
	b1.price = 15;
	printf("修改后的价格:%d\n",b1.price);
	return 0;
}
//输出
书名:C语言程序设计
价格:55
修改后的价格:15

//创建结构体 
struct Book
{
	char name[20];
	short price;
};
int main(int argc, char *argv[]) {
	//利用结构体类型-创建一个该类型的结构体变量
	struct Book b1 = {"C语言程序设计",55};
	struct Book* pb = &b1;
	//利用pb打印出我的书名和价格 
	//.    结构体变量.成员
	//->  结构体指针->成员
	printf("%s\n",pb->name);
	printf("%d\n",pb->price);
	printf("%s\n",(*pb).name);
	printf("%d\n",(*pb).price); 
	return 0;
}
//输出
C语言程序设计
55
C语言程序设计
55

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

//创建结构体 
struct Book
{
	char name[20];
	short price;
};
int main(int argc, char *argv[]) {
	//利用结构体类型-创建一个该类型的结构体变量
	struct Book b1 = {"C语言程序设计",55};
	struct Book* pb = &b1;
	//更改数组内容
	strcpy(b1.name,"c++");	 
	//利用pb打印出我的书名和价格 
	//.    结构体变量.成员
	//->  结构体指针->成员
	printf("%s\n",pb->name);
	printf("%d\n",pb->price);
	printf("%s\n",(*pb).name);
	printf("%d\n",(*pb).price); 
	
	return 0;
}