C语言复习笔记

为了能够刷动算法题，重新复习了大一学习的C语言，拾起了许多遗忘的东西以及没有触及的东西
，这就当做笔记用于记忆

#include<stdio.h>
#include<limits.h>

// int main()
// {
//      printf("int 存量大小：%lu \n",sizeof(int)); #lu表示无符号长整形
//      return 0;

// }
// int main()  强制类型转化，浮点型转化整形时四舍五入，整形转化浮点型时数值不变，增加相应精度
// {
//     float f,x=3.6,y=5.2;
//     int i=4,a,b;
//     a=x+y;
//     b=(int)(x+y);
//     f=10/i;
//     printf("a=%d,b=%d,f=%f,x=%f\n",a,b,f,x);
// }



// C变量
// 1.名称可以由字符、数字、下划线组成，必须以字母以及字符串或下划线开头
// 2.变量不带初始化的定义，带有静态存储持续时间的变量会被隐式初始化为null
// 3.extern用在变量或函数的声明前，用来说明变量在别处定义，在此处引用



// C常量
// 常量是固定值，在程序执行期间不会改变，这些固定的值，又叫做字面量
//   \\ \字符
//   \' '字符
//   \" "字符
//   \t 水平制表符
//   \r 回车

//C存储类
// auto 存储类是局部变量默认的存储类
// register 用于定义存储在寄存器中而不是RAM中的局部变量，变量的最大尺寸等于寄存器的大小
// static 指示编译器在程序的生命周期内保持局部变量的存在，static局部变量定义一次后，之后调用将失效
// extern 用来在另一个文件中生命一个全局变量或者函数


//异或运算---相同为0，不同为1
// sizeof 返回变量的大小
// & 返回变量的地址
// * 指向一个变量
// ?: 条件表达式 如果条件为真？则值为x:否则值为Y


// 变量作用域
// 1.在程序中，局部变量和全局变量的名称可以相同，但是在函数中，如果两个名字相同，会使用局部变量值，全局变量不会被使用
// 2.函数的形参被当做该函数内部的局部变量，如果与全局变量同名它们会优先使用
// 3.全局变量保存在内存的全局存储区中，占用静态的存储单元
// 4.局部变量保存在栈中，只有在所在函数被调用时才动态的为变量分配存储单元

// C传递数组给函数
// 1.形式参数是一个指针  void myfunction(int *param)
// 2.形式参数是一个已定义大小的数组 void myfunction(int param[10])
// 3.形式参数是一个未定义大小的数组 void myfunction(int param[])


//C从函数返回数组
// 1.C语言不允许返回一个完整的数组作为函数的参数，另外C不支持在函数外返回局部变量的地址，除非定义局部变量为static变量
// 2.返回数组的首地址


//C指向数组的指针
//数组名是一个指向数组中第一个元素的常量指针，即第一个元素的地址


// C枚举常量
// 枚举语法定义格式为 enum 枚举名 {枚举元素1,枚举元素2,、、、}
// 注意:第一个枚举成员对的默认值为整型为0，后续枚举成员的值在前一个成员上加1
// C枚举变量定义
// 1.先定义枚举类型，在定义枚举变量
// enum day
// {
//     mon=1,tue,wed,thu,fri,sat,sun
// }
// enum day date;
// 2.定义枚举类型的同时定义枚举变量
// enum day
// {
//     mon=1,tue,wed,thu,fri,sat,sun
// }date;
// 3.省略枚举名称，直接定义枚举变量
// enum
// {
//     mon=1,tue,wed,thu,fri,sat,sun
// }

// C指针
// 指针是一个变量，其值为另一个变量的地址，内存位置的直接地址，必须在使用指针存储之前，进行声明
//  定义type *var-name
//  使用一元运算符*返回位于操作数所制定地址的变量的值
//  int *ip指针变量的声明
//  ip=&val 指针变量中存储var的地址
//  内存地址为0表明指针不指向一个可访问的内存位置

// 指向指针的指针
// int main()
// {
//     int var;
//     int *ptr;
//     int **pptr;
//     var=3000;
//     ptr=&var;
//     pptr=&ptr;
//     printf("value of var=%d\n",var);
//     printf("value available at *ptr=%d\n",*ptr);
//     printf("value available at **pptr=%d\n",**pptr);
//     return 0;
// }


// 指针形参改变将改变实参
// #include <time.h>
 
// void getSeconds(unsigned long *par);

// int main ()
// {
//    unsigned long sec;

    
//     sec=332331;
//    getSeconds( &sec );

//    /* 输出实际值 */
//    printf("Number of seconds: %ld\n", sec );

//    return 0;
// }

// void getSeconds(unsigned long *par)
// {
//    /* 获取当前的秒数 */
//    *par = time( NULL );
//    return;
// }



// C从函数返回指针
// C语言不支持在调用函数时返回局部变量的地址，除非定义局部变量为static变量
// 因为局部变量的在运行后地址将收回重利用

// 返回指针变量的形式
// int *function()
// {

// }


// 函数指针
// 函数指针是指向函数，可以像一般函数一样，用于调用参数，传递参数
// 指针变量声明
// typedef int (*fun_ptr)(int,int);//声明一个指向同样的参数，返回值的函数指针类型

// int max(int x,int y)
// {
//     return x>y?x:y;
// }

// int main(void)
// {
//     printf("1");
//     //p是函数指针
//     int (*p)(int,int)=&max;
//     int a,b,c,d;
//     printf("请输入三个数字：");
//     scanf("%d %d %d",&a,&b,&c);
//     //与直接调用函数等价，d=max(max(a,b),c)
//     d=p(p(a,b),c);
//     printf("最大的数字是：%d\n",d);
//     return 0;
// }

//指针回调函数   //将通过指针形参调用指向的函数
// void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
// {
//     for (size_t i=0; i<arraySize; i++)
//         array[i] = getNextValue();
// }
 
// // 获取随机值
// int getNextRandomValue(void)
// {
//     return rand();
// }
 
// int main(void)
// {
//     int myarray[10];
//     populate_array(myarray, 10, getNextRandomValue);
//     for(int i = 0; i < 10; i++) {
//         printf("%d ", myarray[i]);
//     }
//     printf("\n");
//     return 0;
// }

//C结构体
// 1.定义结构
// struct tag
// {
//     member-list;
//     member-list;
// }varible-list;
// tag是结构体标签
// member-list是标准的变量定义
// varible-list结构变量，定义在结构的结尾
// 2.如果两个结构体相互包含，则需要对其中一个结构体进行不完整的声明
// struct B
// struct A
// {
//     /* data */
// };

// struct B
// {
//     /* data */
// };


// #include <string.h>
// struct Books
// {
//     /* data */
//     char title[50];
//     char author[50];
//     char subject[100];
//     int book_id;
// };

// int main()
// {
//     struct Books book1;
//     struct Books book2;
//     strcpy(book1.title,"C programming");
//     strcpy(book1.author,"nuha Ali");
//     book1.book_id=532534;

//     /* Book2详述*/
//     strcpy(book2.title,"telecom billing");
//     strcpy(book2.author,"zara ali");
//     strcpy(book2.subject,"telecom billing1");
//     book2.book_id=546664;
//     printf("book1 title:%s\n",book1.title);
//     return 0;
// }

// C共用体
// 共用体是一种特殊的数据类型，允许在相同的内存存储不同的数据类型，可以定义一个
// 带有多成员的共用体
// 1.定义
// union [union tag]
// {
//     /* data */
//     menber definition;
// }[one or more union varibles];

// union tag 是可选的，每个member definition 是标准的变量定义，比如int i ;
// 在共用体定义定义的末尾，最后一个分号之前，可以指定一个或多个共用体变量

// 2.共用体占用的内存应足够存储共用体中最大的成员
// #include<string.h>
// union Data
// {
//     int i;
//     float f;
//     char str[20];
// };
// int main()
// {
//     union Data data;
//     printf("the size of union:%d\n",sizeof(data));
//     return 0;
// }


// C typedef
// 1.可以使用它来为类型取一个新名字
// typedef unsigned char byte;定义之后byte可作为类型unsigned char的缩写

// C输入输出
// 标准文件
// stdin 键盘
// stdout 屏幕
// stderr 您的屏幕
// 1.getchar()函数从屏幕读取下一个可用的字符，并把它返回为一个整数，这个函数在同一时间只会读取一个单一的字符，可使用循环读取屏幕多个字符
// putchar()字符输出到屏幕，返回相同的字符，这个函数在同一个时间内只会输出单一的字符，可使用循环输出多个字符
// 2.gets()从stdin读取一行到s所指向的缓冲区，直到一个终止符或EOF
// puts()把函数字符串S和一个尾随的换行符写入到stdout
// 3.scanf(const char *format)从标准输入流stdin读取输入，并根据提供的format来浏览输入
// format可以是一个简单的常量字符串，可以分别指定%s,%d,%c,%f来输出或者读取字符串


// C文件读写
// 1.FILE *fopen(const char *filename,const char *mode);
// filename是字符串，用来命名文件，访问模式mode
// r 打开一个已有的文本文件，允许读取文件
// w 打开一个文本文件，允许写入文件，如果文件不存在，则会创建一个新文件，程序将会重头写入内容，如果文件存在，会被截断为零长度
// a 打开一个文本文件，已追加模式写入文件，如果文件不存在，则会创建一个新文件，程序会在已有的文件中追加内容
// r+ 打开一个文本文件，允许读写文件
// w+ 打开一个文本文件，允许读写文件，如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件
// a+ 打开一个文本文件，允许读写文件，如果文件不存在则会创建一个新文件，读取会从文件的开头开始，写入则只能是追加模式
// 2.fclose 关闭文件
// 3.写入文件
// int fputc(int c,FILE *fp);把参数C的字符值写入到fp所指向的输出流中，如果写入成功，返回写入的字符，如果发生错误，则会返回EOF
// int fputc(const char *s,FILE *fp);把字符串S写入到fp所指向的输出流中，写入成功，他会返回一个非负值，如果发生错误，则会返回EOF

// 预定义宏
// _DATE_ 当前日期
// _TIME_ 当前时间
// _FILE_ 当前文件名
// _LINE_ 当前行号
// _STDC_ 当编译器以ANSI标砖编译时，则定义为1