C基础

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];

数组名与指针概念的区别

数组名和指针虽然都代表数组首元素的地址，但意义不同。如同他他们分别比作省政府和市政府，数组名相当于省政府，指向首元素的指针代表市政府。如陕西的省政府西安，而西安市的市政府也在西安，两个政府都在西安，但代表的意义不同。

不同之处：

1. 用sizeof关键字求数组所占的内存是整个数组的大小，指针不是
2. 对数组名取地址时是取得一个代表整个数组的地址，对指针取地址则不然。

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;

字节对其

自然对其

1. 结构体中某一变量，保存的内存地址的开始位置，相对于结构体开始位置的偏移，是这个变量字节数的整数倍
2. 结构体所占字节是结构体中，最长变量所占字节的整数倍。

定义结构体时，优先将短变量写在前面

指定对其方式

#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