c基础（二）
指针：
含义：是一个值，一个值代表着一个内存地址，类似于存放路径
* 运算符 ：
1 字符*表示指针
作用：通常跟在类型关键字的后面，表示指针指向的是什么类型的值
int * foo, * bar;
声明指针后会随机分配一个内存空间，指针指向的数据是随机的
指针的初始化：
int* p;
int i;
p = &i;
*p = 13;
未初始化的指针数据最好这样定义：int* p = NULL;2 运算符
作用：用来取出指针变量所指向的内存地址里面的值
* foo 取出定义的指针的值
/*注意，数组名指向的地址是不能更改的*/& 运算符：
作用：用来取出一个变量所在的内存地址
int i = 5;
if (i == *(&i)) // 正确，*(&i)含义：先取出i的内存地址，在获取内存地址对应的值
运算：
1 指针与整数值的加减运算
指针与整数值的运算，表示指针的移动。
2 指针与指针的加法运算
两个指针进行加法是非法的
3 指针与指针的减法
相同类型的指针允许进行减法运算，返回它们之间的距离，即相隔多少个数据单位。
高位地址减去低位地址，返回的是正值；低位地址减去高位地址，返回的是负值
返回值：ptrdiff_t类型，一个带符号的整数类型别名
4 指针与指针的比较运算
比较的是各自的内存地址哪一个更大，返回值是整数1（true）或0（false）
函数：
基础结构：
#include
/* 基础结构*/
int main(void)
{
int m = addNum(3); /* 使用函数， 3 传递的参数*/
printf("m=%d", m);
}
int addNum(int a) /* int addNum 定义函数名称 （int a 传递参数，可以传递多个，使用逗号分开） */
{ /*{函数体:使用此方法需要执行的语句}*/
return a; /* return a; return 返回值，返回计算之后的数据 */
}
参数：
传递的参数是拷贝的数据，非自身数据，不会实时更新数据；
除非
1 函数返回最新的数据，才可以获取并赋值最新的数据
2 直接修改自身的署，传入变量的地址（函数不要返回内部变量的指针）
void Swap(int* x, int* y) {
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int a = 1;
int b = 2;
Swap(&a, &b);
//参数为数组
int sum_array(int a[n], int n) {
// ...
}
int sum = sum_array(a, 4);
//等同于
int sum = sum_array((int []){3, 5, 7, 3}, 4);
/*多维数组*/
int sum_array(int n, int m, int a[n][m]);
参数数量是不确定时，声明函数的时候，可以使用省略号...表示可变数量的参数
注意：...符号必须放在参数序列的结尾，否则会报错
#include
#include /* 可以操作可变参数的类*/
double average(int i, ...);
double average(int i, ...) {
double total = 0;
va_list ap; /*va_list 一个数据类型，用来定义一个可变参数对象*/
/* va_start(ap, i); 将参数i后面的参数统一放入ap*/
va_start(ap, i); /*va_start 一个函数，用来初始化可变参数对象 va_start（可变参数对象，正常参数，用来为可变参数定位）*/
printf("i=%d \n", i);
for (int j = 1; j <= i; ++j) {
/* va_arg(ap, double)用来从ap依次取出一个参数，并且指定该参数为 double 类型*/
total += va_arg(ap, double); /* va_arg 一个函数，用来取出当前那个可变参数 va_arg（可变参数对象，当前可变参数的类型）*/
printf("total=%d \n", total);
}
printf("ap=%d \n", ap);
va_end(ap); /* va_end 一个函数，用来清理可变参数对象*/
return total / i;
}
int main(void)
{
int total=average(0,8,10);
printf("total=%d", total);
} 递归函数：
函数可以调用自身，这就叫做递归（recursion）
例如：
#include
int main(void)
{
int m = addNum(3);
printf("m=%d", m);
}
int addNum(int a)
{
a++ ;
if (a <= 5)
{
addNum(a);
}
else
{
return a;
}
}
注意：在使用递归函数时，注意做好判断，不然容易出现死循环 入口函数：
main()是程序的入口函数，所有的程序必须要有
类似于页面加载方法，首先执行此方法
其他的方法需要通过main调用
#include
int main(void)
{
int m =3;
printf("m=%d", m);
return 0; /* 表示函数结束运行，返回0; 返回非零数据表示运行失败*/
} 函数指针：
调用函数的方法
// 写法一 常用的 函数名本身就是指向函数代码的指针，通过函数名就能获取函数地址
print(10)
// 写法二
(*print)(10)
// 写法三
(&print)(10)
// 写法四
(*print_ptr)(10)
// 写法五
print_ptr(10)
#include
int addNum(int a)
{
return a;
}
int main(void) /*调用其他方法时，其他方法要么写在最前面， 或者使用函数原型*/
{
// int m = addNum(3);
// printf("m=%d", m);
int m = (*addNum)(10);
printf("m=%d", m);
}
优点：
可以明确参数是一个函数
参数一就是一个函数
int compute(int (*myfunc)(int), int, int); 函数原型：提前告诉编译器，每个函数的返回类型和参数类型
int twice(int);
int main(int num) {
return twice(num);
}
int twice(int num) {
return 2 * num;
}
注意，函数原型必须以分号结尾。
一般来说，每个源码文件的头部，都会给出当前脚本使用的所有函数的原型。exit函数：
作用：终止程序的运行
前提： #include
返回值(stdlib.h已定义，无需定义)：
EXIT_SUCCESS（相当于 0）表示程序运行成功
EXIT_FAILURE（相当于 1）表示程序异常中止
atexit()函数：
用来登记exit()执行时额外执行的函数，用来做一些退出程序时的收尾工作 说明符：
extern 说明符 ：
extern int foo(int arg1, char arg2);
extern 表示：导入使用，声明此方法未在此文件定义，是从其他文件内引入使用的
int main(void) {
int a = foo(2, 3);
// ...
return 0;
}static 说明符：
1 用于函数内部声明变量时，表示该变量只需要初始化一次，不需要在每次调用时都进行初始化
2 static可以用来修饰函数本身,表示该函数只能在当前文件里使用，如果没有这个关键字，其他文件也可以使用这个函数（通过声明函数原型）
3 用在参数里面，修饰参数数组
int sum_array(int a[static 3], int n) { /* 数组长度至少为3*/
}注意：
static修饰的变量初始化时，只能赋值为常量，不能赋值为变量
局部作用域中，static声明的变量有默认值0
const 说明符：
1 函数内部不得修改该参数变量
void f(const int* p) {
int x = 13;
p = &x; // p本身的地址是允许修改的
*p = 0; //const声明的* p 不能修改，修改之后报错
}void f(int* const p) { //不允许修改p，就使用const定义
int x = 13;
p = &x; // 该行报错
}
/* p和*p 都不允许修改 */
void f(const int* const p) {
}内存管理：
分类：
系统管理：局部变量存放的内存区域（”栈“（stack）），运行结束后自动从内存卸载
用户手动管理：全局变量存放的内存区域（”堆“（heap）），运行结束后不会自动卸载，需要用户手动释放，此现象叫”内存泄漏“（memory leak）
void 指针：
void：不定类型的指针
可以指向任意类型的数据，但是不能解读数据
void 指针与其他所有类型指针之间是互相转换关系
注意，由于不知道 void 指针指向什么类型的值，所以不能用*运算符取出它指向的值内存操作：
分配内存：
malloc：
#include
#include /*内存管理的操作*/
int main(){
/* malloc(分配的内存字节数--非负整数) 任意类型的数据分配内存 返回值：无类型的 void 指针*/
//malloc不会对所分配的内存进行初始化,需要自行初始化后再使用，想要初始化为0，还要额外调用memset()函数
int* p = malloc(sizeof(int));
*p = 12;
if (p == NULL) {
// 内存分配失败
}
printf("%d\n", *p);
int* n = (int*) malloc(sizeof(int)); //强制转换数据为整数类型
printf("n=%d\n",*n);
int* i = (int*) malloc(sizeof(*i));
printf("i=%d\n",*i);
//作用：
//1 为数组和自定义数据结构分配内存
int* t = (int*) malloc(sizeof(int) * 10);
for (int i = 0; i < 10; i++)
t[i] = i * 5;
printf("t==%d",t);
//2 创建动态数组
int m;
int* a = (int*) malloc(m * sizeof(int)); //可以根据变量m的不同，动态为数组分配不同的大小
}
calloc：
#include
#include
#include
int main(){
// calloc(数据类型的值的数量，数据类型的单位字节长度) 分配内存， 返回值：无类型的 void 指针，分配失败时，返回 NULL
//calloc所分配的内存全部初始化为0
int* p = calloc(10, sizeof(int));
printf("p==%d, %d \n",p,*p);
// 等同于
int* n = malloc(sizeof(int) * 10);
memset(n, 0, sizeof(int) * 10);
printf("n==%d, %d \n",n,*n);
} 释放内存：
free：
#include
#include
int main(){
//free(malloc返回的内存地址) 释放malloc函数分配的内存
//分配的地址释放之后，不可操作和再次释放
// 注意：函数调用成功后，一定要释放内存，否则会导致多次调用函数所生成的内存下次无法访问
int* p = (int*) malloc(sizeof(int));
*p = 12;
printf("address=%d",p);
free(p);
} 修改内存：
realloc：
#include
#include
int main(){
//realloc(已经分配好的内存块指针，内存块的新大小，单位为字节) 修改已经分配的内存块的大小，可以放大也可以缩小 , 返回新的内存块的指针,分配失败返回null
// 已经分配好的内存块指针--参数设置为null或者不写，会创建一个新的指针
// 内存块的新大小 --------参数设置为0，会释放内存块
//realloc不会对内存块进行初始化
int* p = calloc(10, sizeof(int));
float* new_p = realloc(p, sizeof(*p * 40));
if (new_p == NULL) {
printf("Error reallocing\n");
return 1;
}else{
printf("win--- \n");
}
} 拷贝内存：
memcpy拷贝：
#include
#include
//自定义复制内存函数：
void* my_memcpy(void* dest, void* src, int byte_count) {
char* s = src;
char* d = dest;
while (byte_count--) {
*d++ = *s++;
}
return dest;
}
int main(){
//memcpy(拷贝地址，被拷贝地址，拷贝的字节数) 前两个参数：不限制指针类型，各种类型的内存数据都可以拷贝
char s[] = "Goats!";
char t[100];
// memcpy(t, s, sizeof(s)); // 拷贝7个字节，包括终止符
int m = my_memcpy(t, s, sizeof(s));
printf("m=%s\n", m); // "Goats!"
return 0;
}
memmove复制：
#include
#include
int main(){
//memmove(拷贝地址，被拷贝地址，移动的字节数) 允许目标区域与源区域有重叠。如果发生重叠，源区域的内容会被更改
char x[] = "Home Sweet Home";
printf("x=%s\n", (char *) memmove(x, &x[5], 10));
} 比较内存：
memcmp：
#include
#include
int main(){
//memcmp(比对者1，比对者2，比较的字节数) 返回值：整数
//相同时返回0，参数一大于参数二时返回大于0，参数一小于参数二返回小于0
// char* s1 = "abc";
// char* s2 = "acd";
// int r = memcmp(s1, s2, 3); // 小于 0
// printf("memcmp result=%d",r);
//比较内部带有字符串终止符\0的内存区域
char s1[] = {'b', 'i', 'g', '\0', 'c', 'a', 'r'};
char s2[] = {'b', 'i', 'g', '\0', 'c', 'a', 't'};
printf ("3=%d \n",memcmp(s1, s2, 3) == 0) ;// true
printf ("4=%d \n",memcmp(s1, s2, 4) == 0) ;// true
printf ("7=%d \n",memcmp(s1, s2, 7) == 0) ;// false
} restrict 说明符 ：
restrict :内存区域只有当前指针一种访问方式，其他指针不能读写该内存,这种指针称为“受限指针”（restrict pointer）