函数，数组，原码反码补码，~ 按位取反，-- ++ 前置 后置，下标，#define 定义常量 宏，指针 学习笔记
2025-06-21 17:56:57 / 法国直播世界杯函数
void MAX(int a, int b) //定义函数
数组
一组相同类型数据的集合
int arr[10] = {0,1,2,3,4}; //定义一个整型的数组占10*4个字节
原码、反码、补码
只要是整数，内存中都是二进制的补码
原码、反码、补码
负数再内存中存储的是二进制的补码 有符号数最高位0表示正数 1表示负数
使用的，打印的是这个数的原码
原码符号位不变，其他位按位取反得到反码，反码加一得到补码
反过来补码-1=反码 反码按位取反=原码
~ 按位取反
int a = 0; //4个字节 0000 0000 0000 0000 0000 0000 0000 0000
int b = ~a; // 1111 1111 1111 1111 1111 1111 1111 1111
-- ++ 前置 后置
前置++先++，后使用
前置++先++，后使用
三目操作符
条件操作符 exp1? exp2: exp3 exp是表达式的意思
?前面为真执行第二个，若前面为假执行第三个
typedef 类型定义 类型重定义
int a = (int)3.14; //强制类型转换double->int
static
修饰局部变量 生命周期变长 逗号表达式 分隔
修饰全局变量 作用域改变 让静态全局变量只能在自己所在源文件内部使用
修饰函数 作用域 只能在自己所在源文件内部使用（改变函数连接属性 一般函数都有外部连接）
下标
[] () -> .
()函数调用操作符
[]下表标引用操作符
常见关键字
定义不能冲突 不能自己创建 define 是一种指令不是关键字
F10调试 F11进入函数 要开启监视窗口
#define 定义常量 宏
#define MAX 1000 定义标识符常量
#define 可以定义宏一带参数
宏的定义方式
#define MAX(X,Y) (X>Y?X:Y) //不用写类型 简洁
比较函数的定义方式
int Max(int x, int y)
{
if (x > y)
return x;
else
return y;
}
指针
内存 地址编号 内存中一个个小单元（可以看成内存小格子）地址->空间
如何产生地址，32位 64位 32根地址线 正电 负电2^32个字节编号bit 4,94,679,296
申请内存
&取地址符号 看它的地址
int* p = &a; //取地址 int*是类型 p是指针变量 p存的是a的地址
*p = 20;//*p解引用操作符，改变变量的值 *p就相当于20
32位系统下32bit 4个字节
#define _CRT_SECURE_NO_WARNINGS
//练习笔记
//#include
//
//int main()
//{
// int a, b, c;
// scanf("%d%d", &a, &b);
// if (a > b)
// {
// c = a;
// printf("%d", c);
// }
// else
// {
// c = b;
// printf("%d\n", b);
// }
// return 0;
//}
//#include
//
//void MAX(int a, int b) //定义函数
//{
// int c;
// if (a > b)
// {
// c = a;
// printf("%d\n", c); //或者return c；返回后再操作
// }
// else
// {
// c = b;
// printf("%d\n", b);
// }
//}
//int main()
//{
// int num1 = 30;
// int num2 = 50;
// MAX(num1, num2); //传参num1 num1
// return 0;
//}
//*******************************************************************//
//数组 一组相同类型数据的集合
//#include
//int main()
//{
// int arr[10] = {0,1,2,3,4}; //定义一个整型的数组占10*4个字节
// int arr1[] = { 0,1,2,3,4 };
// printf("sizeof(arr)=%d\n", sizeof(arr));
// printf("sizeof(arr2)=%d\n", sizeof(arr1)); //计算数组的大小，单位是字节 20
// return 0;
//}
//
//#include
//
//int main()
//{
// //~ 按位取反
// int a = 0; //4个字节 0000 0000 0000 0000 0000 0000 0000 0000
// int b = ~a; // 1111 1111 1111 1111 1111 1111 1111 1111
// printf("%d\n", b);
// //只要是整数，内存中都是二进制的补码
// //原码、反码、补码
// //负数再内存中存储的是二进制的补码 有符号数最高位0表示正数 1表示负数
// //使用的，打印的是这个数的原码
// //原码符号位不变，其他位按位取反得到反码，反码加一得到补码
// //反过来补码-1=反码 反码按位取反=原码
// -2
// 1000 0000 0000 0000 0000 0000 0000 0000 0010
// return 0;
//}
//#include
//
-- ++ 前置 后置
//
//int main()
//{
// int a = 10;
// int b = a++; //后置++先使用，后++
// printf("a=%d b=%d\n", a, b); //a=11,b=10
// int c = 10;
// int d = ++c; //前置++先++，后使用
// printf("c=%d d=%d\n", c, d); //11 11
// //后置-- ++同理
// int num1 = 10;
// int num2 = num1--;
// printf("num1=%d\n num2=%d\n", num1, num2);
// return 0;
//}
//
//#include
强制类型转换
//int main()
//{
// int a = (int)3.14; //强制类型转换double->int
// return 0;
//}
//
//关系操作符>= <= ==
逻辑操作符 真-非零 假-0
逻辑与 &&
逻辑或 ||
//#include
//
//int main()
//{
// int a = 3;
// int b = 5;
// int c = a && b; //左右为真，所以为真 并且
// printf("%d\n", c); //1
// int d = a || b; //只要一个为真就为真，张三和李四搬凳子
// printf("%d\n", d); //1
// return 0;
//}
//#include
//
条件操作符 exp1? exp2: exp3 exp是表达式的意思 三目操作符
//
//int main()
//{
// int a = 10;
// int b = 20;
// int max = 0;
// max = (a > b ? a : b); //?前面为真执行第二个，若前面为假执行第三个
// return 0;
//}
//逗号表达式 分隔
//下标 [] () -> .
//#include
//
//int Add(int num1, int num2)
//{
// int z = 0;
// z = num1 + num2;
// return 0;
//}
//
//int main()
//{
// int arr[10] = { 0 }; //[]下表引用操作符
// int a = 10;
// int b = 20;
// int sum = Add(a, b); //()函数调用操作符
// return 0;
//}
1111 1111 1111 1111 1111 1111 1111 1111
1000 0000 0000 0000 0000 0000 0000 0000 0
1*2^32-1
-1 --整型-32
1 --整型-32
[1]符号位[][][] [][][][] [][][][] [][][][] [][][][] [][][][] [][][][] [][][][]
有符号
常见关键字 定义不能冲突 不能自己创建 define 是一种指令不是关键字
//#include
//
//int main()
//{
// //auto 自动创建自动销毁，一般都有所以不写省略
// auto int a = 10;
// //break case case const continue defaut do double else enum extern float for
// //if int long goto registe 建议定义成寄存器变量 计算机存储（寄存器最快 高速缓存 内存 硬盘）访问速度越前越快 (CPU 中央处理器)
// //return short unsigned signed sizeof static struct switch typedf union void volatile while
// return 0;
//}
//#include
//
typedef 类型定义 类型重定义
//
//int main()
//{
// typedef unsigned int u_int; //u_int 与unsigned int 相同
// unsigned int num = 20;
// u_int num2 = 20;
// return 0;
//}
//#include
//
static 修饰局部变量 生命周期变长
//
//void test()
//{
// //static int a = 1; //加static 静态局部变量，不销毁
// int a = 1;
// a++;
// printf("a=%d\n", a); //5个a=2 函数出去后生命周期结束，销毁
//}
//
//int main()
//{
// int i = 0;
// while (i < 5)
// {
// test(); //F10调试 F11进入函数 要开启监视窗口
// i++;
// }
// return 0;
//}
//#include
//
static 修饰全局变量 作用域改变 让静态全局变量只能在自己所在源文件内部使用
//
//int main()
//{
// extern int g_val; //extern 声明外部符号 如果外部这个全局变量 加 static 则失败
// printf("%d\n", g_val);
// return 0;
//}
//#include
//
static修饰函数 作用域 只能在自己所在源文件内部使用（改变函数连接属性 一般函数都有外部连接）
int main()
//
//extern int Add(int, int); //声明外部函数 分号
//
//int main()
//{
// int a = 10;
// int b = 20;
// int sum = Add(a,b);
// printf("sum=%d\n", sum);
// return 0;
//}
//#include
//
#define 定义常量 宏
#define MAX 1000 定义标识符常量
#define 可以定义宏一带参数
//
函数的定义方式
//int Max(int x, int y)
//{
// if (x > y)
// return x;
// else
// return y;
//}
宏的定义方式
//#define MAX(X,Y) (X>Y?X:Y) //不用写类型 简洁
//int main()
//{
// int a = 10;
// int b = 20;
// int max = Max(a,b);
// printf("max=%d\n", max);
// //宏的方式
// max = MAX(a,b); //max=(a>b?:b) 这是编译器完成的
// printf("max=%d\n", max);
// return 0;
//}
指针
内存 地址编号 内存中一个个小单元（可以看成内存小格子）地址->空间
如何产生地址，32位 64位 32根地址线 正电 负电2^32个字节编号bit 4,94,679,296
申请内存
&取地址符号 看它的地址
//#include
//
//int main()
//{
// int a = 0;
// printf("%p\n", &a); //十六进制
// int* p = &a; //取地址 int*是类型 p是指针变量 p存的是a的地址
// //有一种变量是用来存放地址的指针变量
// printf("%p\n", p);
// *p = 20;//*p解引用操作符，改变变量的值 *p就相当于20
// printf("a=%d", a);
// return 0;
//}
#include
int main()
{
char ch = 'w';
char* pc = &ch; //char型
*pc = 'a';
printf("%c\n", ch);
printf("%d\n", sizeof(pc)); //Debug->配置管理器->新建X64
return 0;
}
//32位系统下32bit 4个字节
//已知地址取值写法很危险；