C数据类型变量常量
变量的分类变量的作用域和生命周期常量 字符串
转义字符 注释选择语句循环语句函数数组操作符
算术操作符： + - * / %移位操作符： >> <<位操作符：赋值操作符单目操作符
~ 按（二进制）位取法++ - - 关系操作符逻辑操作符条件操作符（三目操作符）逗号表达式下标引用，函数调用和结构成员 关键字
关键字typedef关键字static #define定义常量和宏指针
指针变量的大小 结构体
C数据类型char //字符数据类型 1字节
short //短整型 2字节
int //整型 4字节
long //长整型 4字节
long long //更长的整型 8字节
float //单精度浮点类数 4字节
double //双精度浮点数 8字节
#include变量常量int main() { printf("%d/n", sizeof(char));//打印一个整数 -%d printf("%d/n", sizeof(short));//sizeof -关键字--操作符-计算类型或者变量所占空间的大小 printf("%d/n", sizeof(int)); printf("%d/n", sizeof(long)); printf("%d/n", sizeof(long long)); printf("%d/n", sizeof(float)); printf("%d/n", sizeof(double)); return 0; }
常量 - 不能改变的量
变量 - 能被改变的量
局部变量：{}内部定义的
全局变量：{}外部定义的
#define _CRT_SECURE_NO_WARNINGS 1 #includeint a = 100;//全局变量 int main() { int a = 10;//局部变量 //当局部变量和全局变量名字冲突情况下，局部优先 printf("%dn", a); return 0;
计算两个数的和
//scanf函数是输入函数
int main()
{
int a = 0;
int b = 0;
int sum = 0;
scanf("%d%d", &a, &b);
sum = a + b;
printf("sum = %dn", sum);
return 0;
}
变量的作用域和生命周期
作用域 ：程序设计概念，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。（那里可以使用那里就是作用域）
局部变量作用域：就是变量所在的局部范围
全局变量作用域：整个工程
#includeint g_val = 2021;//全局变量 int main() { printf("1:%dn", g_val); printf("hehen"); { printf("2:%dn", g_val); int a = 10; printf("a = %dn,a"); } printf("3%dn", g_val); return 0; }
生命周期
变量的生命周期：变量的创建和销毁之间的时间段
局部变量的生命周期：进入局 部范围生命开始，出局部范围生命结束
全局变量的生命周期：程序的生命周期
C语言中的常量分为以下几种：
字面常量const修饰的常变量#define 定义的标识符常量枚举常量
#includeint main() { //1.字面常量 3.14; 10; 'a'; "abcdef"; //2.const修饰的常变量 const int num = 10;//num常变量-具有常属性（不能被改变的属性） printf("num = %dn",num);//20 return 0; }
#define MAX 10000//3.#define定义的标识符常量
int main()
{
int n = MAX;
printf("n = %dn,n");
return 0;
}
字符串
就是一串字符，由双引号引起的就是字符串
"abcdef"; "hello nathan";
注：字符串的结束符是一个 的转义字符。在计算字符串长度的时候 是结束标志，不作为字符串内容。
int main()
{
//字符数组 - 数组是一组相同类型的元素
//字符串在结尾的位置隐藏了一个 的字符
// 是字符串的结束标志
char arr[] = "hello";
return 0;
}
转义字符
转变了它原来的意思
- 代码中有不需要的代码可以直接删除，也可以注释掉代码中有些比较难懂，可以加一下注释文字
int main()
{
//int a =10;//c++注释风格
//c语言注释风格
return 0;
}
选择语句
int main()
{
int input = 0;
printf("加入学习");
printf("那么好好学习（1/0）?>:");
scanf("%d", &input);
if (input == 1)
printf("好好学习,好offern");
else
printf("卖红薯n");
return 0;
}
循环语句
int main()
{
int line = 0;
while (line < 30000)
{
printf("写代码:%dn",line);
line++;
}
if (line == 30000)
{
printf("好offern");
}
return 0;
}
函数
int Add(int x,int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int num1 = 0;
int num2 = 0;
scanf("%d%d", &num1, &num2);
//int sum =num1 + num2;
//函数的方式解决
int sum = Add(num1, num2);
printf("%dn", sum);
return 0;
}
数组
数组 ----- 一组相同类型的元素的集合
int main()
{
//10个整形1-10存起来
//数组是用下标访问
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
while (i<10)
{
printf("%d", arr[i]);
i++;
}
char ch[5] = { 'a','b','c' };//不完全初始化，剩余的默认为0
return 0;
}
操作符
算术操作符： + - * / %
int main()
{
int a = 9 / 2;//结果为4
float a = 9 / 2.0;//结果为4.5
printf("%fn", a);
return 0;
}
移位操作符： >> <<
<< 左移操作符—移动的是二进制位
位操作符：&(按位与) |（按位或） ^（按位异或）
赋值操作符+= = -= *= /= &= ^= |= >>= <<=
单目操作符！ 逻辑反操作
＋ 正值
－ 负值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
－－ 前置，后置–
++ 前置，后置++
✳ 间接访问操作符（解引用操作符）
(类型) 强制类型转换
把所有二进制位中的数字，1变成0，0变成1
整数在内存中存储的是补码~
一个整数的二进制表示有三种：
-原码
-反码
-补码
-1：
100000000000000000000000000000001（原码）
11111111111111111111111111111111111110（反码）
源码取反 符号位（第一个数）不变，其他位按位取反
11111111111111111111111111111111111111（补码）
源码取反加1
正整数：源码，反码，补码相同
++ - -int main()
{
int a = 10;
int b = ++a;//前置++ 先++,后使用
printf("%dn", b);//11
printf("%dn", a);//11
return 0;
}
int main()
{
int a = 10;
int b = a++;//后置++ 先使用，再++
printf("%dn", b);//10
printf("%dn", a);//11
关系操作符
== != <= < > >=
逻辑操作符&& 逻辑与
|| 逻辑或
exp1 ? exp2 :exp3
exp1 成立 ，exp2计算，整个表达式的结果是：exp2的结果
exp1 不成立，exp3计算，整个表达式的结果是：exp3的结果
int main()
{
int a = 0;
int b = 3;
int max = 0;
if (a > b)
max = a;
else
max = b;
max = a > b ? a : b;
printf("%dn", max);
return 0;
}
逗号表达式
逗号隔开的一串表达式
int main()
{
(2, 4 + 5, 6);
return 0;
}
逗号表达式，是从左向右依次计算的
整个表达式的结果是最后一个表达式的结果
int main()
{
//(2, 4 + 5, 6);
int a = 0;
int b = 3;
int c = 5;
int d = (a = b + 2, c = a - 4,b = c + 2);
return 0;
}
下标引用，函数调用和结构成员
[] () . ->
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%dn",arr[5]);//[]下标引用操作符
return 0;
}
int main()
{//调用函数的时候，函数名后边的()就是函数调用操作符
printf("hehen");
return 0;
}
关键字
- c语言提供的，不能自己创建关键字关键字不能做变量名
int main()
{
//大量频繁使用的数据，想放寄存器中，提升效率
register int num = 100;//建议num的值存放再寄存器中
return 0;
}
关键字typedef
类型重命名
typedef unsigned int u_int;
int main()
{
unsigned int num = 100;
u_int num2 = 100;
return 0;
}
关键字static
静态的
- static 修饰局部变量static 修饰全局变量static 修饰函数
static 修饰局部变量，改变了局部变量的生命周期（本质上改变了变量的存储类型）
void test()
{
static int a = 1;
a++;
printf("%d", a);
}
int main()
{
int i = 0;
while (i<10)
{
test();
i++;
}
return 0;
}
全局变量在整个工程都可以使用
static修饰全局变量，使得这个全局变量只能在自己所在源文件（.c）内部可以使用
其他源文件不能使用
全局变量，在其他源文件内部可以被使用，是因为全局变量具有外部链接属性
但是被static 修饰后，就变成了内部链接属性，其他源文件就不能链接到这个静态全局变量了
static 修饰函数，使得函数只能在自己的源文件内部使用，不能再其他源文件内部使用
本质上：static是将函数的外部链接属性变成了内部链接属性（和static修饰全局变量一样）
- define定义符号define 定义宏
//define 定义宏
#define ADD(X,Y) X+Y
int main()
{
printf("%dn", 4*ADD(2, 3));//4*2+3
return 0;
}
指针
指针就是地址
内存是怎么编号的？
32位 - 32根地址线 - 物理线 - 通电 - 1/0
电信号转化为数字信息：1和0组成的二进制序列
一个内存单元是一个字节，然后分配地址
int main()
{
int a = 10;//a在内存中要分配空间的-4个字节
printf("%pn", &a);//%p专门用来打印地址
int* pa = &a;//pa是用来存放地址的，在c语言中pa是指针变量
//*说明pa是指针变量
//int说明pa执行的对象是int类型
char ch = 'w';
char* pc = &ch;
return 0;
}
指针变量的大小
int main()
{
printf("%dn", sizeof(char*));
printf("%dn", sizeof(short*));
printf("%dn", sizeof(int*));
printf("%dn", sizeof(long*));
printf("%dn", sizeof(long long*));
printf("%dn", sizeof(float*));
return 0;
}
指针大小是相同的
指针需要多大空间，取决于地址的存储需要多大的空间
32位 32bit—4byte
64位 64bit----8byte
结构体使得c语言有能力描述复杂类型
//创建一个学生
struct Stu
{
char name[20];
int age;
double score;
};
//创建一个书的类型
struct Book
{
char name[20];
float price;
char id[30];
};
int main()
{
struct Stu s ={"张三",20,85.5};//结构体创建和初始化
printf("%s %d %lfn", s.name, s.age, s.score);//结构体变量.成员变量
return 0;
}
