C基础
程序员文章站
2022-03-22 21:35:16
...
C基础
基本数据类型
整型 字节 占位 范围
int 4 %d -2147483648到2147483647
unsigned int 4 %u 0到4294967295
short 2 %hd -32768到32767
unsigned short 2 %hu 0到65535
long 4 %ld -2147483648到2147483647
unsigned long 4 %lu 0到4294967295
char 1 %c -128到127
unsigned char 1 %c 0到255
long int = long
java 中的long = long long
浮点型 字节 占位 精度
float 4 %f 6位小数
double 8 %lf 15位小数
long double 8 %Lf 19位小数
c99 bool int #include <stdbool.h>
非0即true,非null为true
数组 必须指定长度 或初始化赋值
int a[10];
int a[] = {1,2,3,4,5,6};
打印输出
printf("打印输出")
char str[100];
sprintf(str, "将2，3参数格式化的字符%d复制到str中", 2);
指针
指向内存地址的变量
// 声明
int *p; // 推荐
int * p;
int* p;
// & 取地址符
int i= 10；
int *p = &i;
printf("i地址：%#x\n", &i);
printf("p值：%#x\n", p);
printf("p地址：%#x\n", &p);
printf("p指向地址的值：%d\n", *p); // 解引用
// 通过纸质操作内存
*p = 100;
// 指针自增、自减操作
int arr[] = {1,2,3,4,5};
int *arr_p = arr;
for (size_t i = 0; i < 4; i++) {
printf("数组中的元素：%d\n", *arr_p++); // 先执行后面的++，++在后面，先使用再++,然后取地址的值
}
p++;
数组指针&指针数组
int array[2][3] = {{11,22,33}, {44,55,66}};
// 数组的指针 int[3]
int (*array_p)[3] = array; // 3是步长
// 指针的数组
int *array_p[3];
数组名与指针概念的区别
数组名和指针虽然都代表数组首元素的地址，但意义不同。如同他他们分别比作省*和市*，数组名相当于省*，指向首元素的指针代表市*。如陕西的省*西安，而西安市的市*也在西安，两个*都在西安，但代表的意义不同。
不同之处：
- 用sizeof关键字求数组所占的内存是整个数组的大小，指针不是
- 对数组名取地址时是取得一个代表整个数组的地址，对指针取地址则不然。
const final 从右往左看
char tmp[] = "hello";
const char *p2 = tmp;
p2[1] = 'C'; // 不可以，const修饰char，不可变
p2 = "DONGAO"; // 可以让p2指向新的地址
char const *p3 = tmp; // const 不能修饰 *， 只能修饰char,与p2相同
char * const p4 = tmp;
p4 = "aaa"; // 不可以
p4[0] = 'a'; // 可以
const char * const p5 = tmp; // 都不可变
char const * const p6 = tmp; // 都不可变
多级指针
int i = 0;
int *p = &i;
int **p2 = &p;
printf("p2的值：%d", **p2);
函数
使用之前先声明
1.传值：把参数的值传给函数
2.传引用：把地址传个函数
可变参数
#include <stdarg.h>
void add(char *b, ...) {
va_list list; // 表示...的参数列表
va_start(list, b);
for (size_t i = 0; i < 5; i++) {
int j = va_arg(list, int);
printf("可变参数有：%d\n", j);
}
char c = va_arg(list, char);
printf("可变参数有：%c\n", c);
va_arg(list, );
va_end(list);
}
add(NULL,1,2,3,4,5,'a');
函数指针
void say(void (*p)(char*), char *msg) {
p(msg);
}
void println(char *msg) {
printf("println:%s\n", msg);
}
void (*p)(char*) = println;
say(p, "hello");
// 创建别名
typedef void(*Func)(char*);
Func fun = println;
say(fun, "hellp");
预处理器
预处理器不是编译器，用来文本替换(测试代码)
常用预处理器 说明
#include 导入头文件
#if if
#elif else if
#else else
#endif 结束if
#define 宏定义
#ifdef 如果定义了宏
#ifndef 如果未定义宏
#undef 取消宏定义
#pragma 设定编译器的状态 #pragma once 只会引入一次
宏变量&宏函数
#define I 1; // 代码中所有的I,都会被预处理器替换为1
#define TEST (i) printf("%d\n", i)
// 注意
#define ADD(x,y) x * y;
int add = ADD(1+10, 10+10); // 1 + 10 * 10 + 10
// 换行 \
#define TEST!(x) if(x) { \
\
else { \
\
}
}
宏函数的优缺点
- 优点：文本替换，使用到宏函数的地方会执行替换，不会函数调用的开销()
- 缺点：不会对我们的代码执行检查；代码增加了，生成的目标增大了。
内联函数
如果太复杂，编译器自动将内联函数降级为普通函数(while, switch),用inline定义。
可以指定参数和返回值类型，有代码检查。
inline int test(int x, int y) {
return x * y;
}
test(1, 2); // 会被替换成 1 * 2
结构体
struct Student {
// public
int i;
short j;
}；
struct Student student;
student.i = 10;
student.j = 20;
// 简写
struct Student {
// public
int i;
short j;
}s1,s2；
s1.i = 10;
s1.j =20;
// typedef
typedef struct {
int i;
int j;
}Student;
Student student;
student.i = 10;
student.j = 20;
字节对其
自然对其
- 结构体中某一变量，保存的内存地址的开始位置，相对于结构体开始位置的偏移，是这个变量字节数的整数倍
- 结构体所占字节是结构体中，最长变量所占字节的整数倍。
定义结构体时，优先将短变量写在前面
指定对其方式
#pragma pack(2)
共用体
// 在相同的内存位置 存储不用的数据
// 共用体 最大成员的字节大小
union MyUnion {
short i;
int j;
}
union MyUnion mu;
mu.i = 10;
printf("%d\n", mu.i); // 10
mu.j = 11;
printf("%d\n", mu.i); // 11
printf("%d\n", mu.j); // 11