C语言学习笔记

简介

C语言是一种通用的高级语言 由Thompson和Ritchie开发
优点：
1、代码量小 2、执行速度快 3、功能强大 4、编程自由
缺点：
1、实现周期长 2、可移植析性差 3、对于自由、经验不足易出错 4、对平台库依赖多

helloworld

1、helloworld程序

#include <stdio.h>//导入一个文件 stdio.h std 是一个标准库 .h头文件
//<>表示导入系统文件 ""表示导入自定义文件
//int 数据类型 整型 如果出现在函数中表示函数的返回值
//main 程序的主函数 程序有且只有一个主函数 ()里面表示函数的参数
int main()
{
    //{} 函数体 代码体 程序体
    //printf 是stdio.h系统提供的函数 表示在标准输出设备上打印字符串
    //\n是一个转义符 表示换行
    printf("hello world!\n");
    return 0;
}

2、system：在已经运行的程序中打开一个外部的程序

#include <stdlib.h>
int main(void)
{
    //cmd命令 calc 计算器 notepad 记事本 mspaint 画图板
    system("calc");
    return 0;
}

3、C语言编译过程
预处理：宏定义展开，头文件展开，条件编译（编译库的选择等），删除注释
编译：检查语法，将预处理后的文件编译生成汇编文件
汇编：将汇编文件生成目标文件（二进制文件）
链接：C语言写的程序是需要依赖各种库的，所以编译之后还需要把库链接到最终的可执行程序中去

数据类型

常量与变量

关键字
关键字详解
1、数据类型
char short int long float double unsigned
signed struct union（联合体） enum void
2、控制语句
if else switch case default for
do while break continue goto return
3、存储类
auto extern(声明） register static const
4、其他
sizeof(数据类型在内存大小）
typedef（定义数据类型）
volatile （防止编译器优化）
基本类型
char 字符型 1字节
int 整型 2或4字节
float 单精度浮点型 4字节
double 双精度浮点型 8字节
常量
含义：在程序运行过程中 其值不能改变的量
定义：#define NUMBER 7 定义一个常量NUMBER
const int var = 5;定义一个int类型的常量 var
字符常量：
\b 退格键 \f 换页符 \n 换行符
\r 回车 \t 水平制表符 \v 垂直制表符
变量
含义：在程序运行过程中 其值可以改变的量
定义：int number；定义一个整型变量，变量名为number
声明：extern int i;声明一个整型变量i 不需要建立存储空间
int i ；声明也是定义
进制转换
十进制转二进制
除二取余法

二进制转十进制
把二进制数按权展开、相加即得十进制数。

二进制转八进制

八进制转二进制

运算符

算数运算符
四则运算（+ - * /）和取模（%）自增++ 自减(-- )
关系运算符
相等（==）不等（！=）大于（>）小于（<)
大于等于（>=） 小于等于（<=）
逻辑运算符
与（&&）或（||）非（！）
位运算符
按位与（&）
按位或（|）
异或（^）
取反 (~)
二进制左移(<<)
二进制右移(>>)
杂项表达式
返回变量的大小（sizeof()）
返回变量的地址（&）
指向一个变量（ ）
条件表达式（?:）
优先级
https://www.runoob.com/cprogramming/c-operators.html

输入输出

标准文件 文件指针 设备
标准输入 stdin 键盘
标准输出 stdout 屏幕
标准错误 stder 您的屏幕
scanf() 函数从键盘读取并且格式化
printf() 输出一个字符串
putchar() 输出一个字符
printf格式输出

打印格式 数据类型
%d int
%f floaat
%lf double
%c char
char * 字符串
int getchar(void) 从屏幕读取一个字符病返回一个整数
int putchar(int c) 把字符输出到屏幕上，并返回相同的字符
char *gets(char *s) 函数从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF。
int puts(const char *s) 函数把字符串 s 和一个尾随的换行符写入到 stdout。

#include <stdio.h>
int main( )
{
   char str[100]; 
   printf( "Enter a value :");
   gets( str );//读取输入的文本，按下回车键时结束 
   printf( "\nYou entered: ");
   puts( str );//将str中的内容输出到屏幕上
   return 0;
}

判断

if 语句

if(boolean_expression)
{
   /* 如果布尔表达式为真将执行的语句 */
}

if-else语句

if(boolean_expression)
{
   /* 如果布尔表达式为真将执行的语句 */
}
else
{
   /* 如果布尔表达式为假将执行的语句 */
}

switch语句

 char grade = 'B';
 
   switch(grade)
   {
   case 'A' ://grade = A时
      printf("很棒！\n" );
      break;//跳出循环
   case 'B' :grade = B时
   case 'C' :grade = C时
      printf("做得好\n" );
      break;
       default :
      printf("无效的成绩\n" );
   }

循环

while语句

 /* while 循环执行 */
   while( a < 20 )
   {
      printf("a 的值： %d\n", a);
      a++;
   }

do-while 语句

 /* do 循环执行，在条件被测试之前至少执行一次 */
   do
   {
       printf("a 的值： %d\n", a);
       a = a + 1;
   }while( a < 20 );

for语句

/* for 循环执行 */
   for( int a = 10; a < 20; a = a + 1 )
   {
      printf("a 的值： %d\n", a);
   }

循环控制语句：
break:终止循环
continue:停止本次循环，开始下一次
goto : 将控制转移到被标记语句，不建议使用

函数

定义：

//return_type 返回值类型 function_name 函数名 parameter list 参数列表 
return_type function_name( parameter list )
{
	//函数体
   body of the function
}

声明：

//不需要函数体
return_type function_name( parameter list );

调用
传值调用

// 函数定义
void swap(int x, int y)
{
   int temp;
   temp = x; // 保存 x 的值 
   x = y;    //把 y 赋值给 
   y = temp; // 把 temp 赋值给 y  
   return;
}
//传值调用
swap(a, b);
//a,b的值并没有改变

引用调用

// 函数定义
void swap(int *x, int *y)
{
   int temp;
   temp = *x; // 保存 x 的值 
   *x = *y;    //把 y 赋值给 
   *y = temp; // 把 temp 赋值给 y  
   return;
}
//引用调用
swap(&a, &b);
//a,b的值发生改变

数组和字符串

1、定义：
在内存中连续的相同类型的变量空间

//声明数组
//数据类型 数组名[元素个数]
int arr[10];
//声明和初始化
//数据类型 数组名[元素个数] = {值1 ,值2 ,值3}
//数组名是一个指向数组首地址的常量
int arr[10] = {9,4,2,1,8,5,3,6,10,7};
//数组下标   数组名[下标]
//数组下标是从0开始的到数组元素个数-1
printf("%d\n",arr[0]);
//数组遍历
for(int i = 0; i < 10;i ++)
{
printf("%d\n",arr[i]);
}

2、存储方式和大小
连续存储在内存中，大小与数据类型相关
3、字符数组和字符串
字符串实际上是使用null和\0终止的一维字符数组
\0为字符串结束标志

//定义字符数组存储字符串
char ch[10] = "book";

操作：

char ch1[10] = "book";
char ch2[10] = "book2";

//复制ch1 到 ch2
strcpy(ch2,ch1);
//连接
strcat(ch1,ch2);
//返回长度
strlen(ch1);
//判断是否相同
strcmp(ch1,ch2);

指针

**内存：**内部存储器，用来暂时存储数据和程序
指针：

//定义指针变量存储变量地址  int* 为指针类型
//在32位操作系统下，所有的指针类型存储的都是内存地址，内存地址都是一个无符号十六进制整型数
int* p;
int a = 10;
p = &a;
//*为取值运算符，通过指针间接改变变量的值
*P = 100;
//野指针  指针变量指向一个未知的空间
int* p = 100;//程序中允许存在野指针
//操作系统将0-255作为系统占用，不允许访问操作
//操作野指针对应的内存空间可能报错

//空指针是指内存地址编号为0的空间
//操作空指针对应的空间一定会报错
int* p = NULL;

//万能指针
int a = 10;
//可以接收任意类型变量的内存地址
//在通过万能指针修改变量的值时 ，需要找到变量对应的指针类型
void* p = &a;

//const修饰指针变量
const int a = 10;
int *p = &a;
//指针间接修改常量的值
*p = 100;
int a = 10;
const int* p = &a;//const 修饰指针类型
//可以修改指针变量的值，不可以修改指针指向内存空间的值
*p = 200;//不能修改
int* const p = &a;//const修饰指针变量
//可以修改指针指向内存空间的值，不可以修改指针变量的值
*p = 200;//可以修改
const int* const p = &a;//const修饰指针类型和变量
//都不可以修改
//const 离谁近，谁不能修改

//多级指针，多一个*,降一个维度

数组和指针：

int arr[] = {1,2,3,4,5,6,7,8,9,10};
//数组名是一个常量，不允许赋值
//数组名是数组收元素的地址
int* p;
//指向数组的指针
p = arr;
//p是变量， arr是常量
//p是一个指针   4个字节大小
//arr是一个数组   40个字节大小
p++;//以指针类型为单位相加，p为int类型，

//两个指针相减  得到的结果是两个指针的偏移量
//所有的指针类型相减，结果都是int类型
int step = p - arr;//结果为0

指针运算

//指针运算以指针类型为单位
int a[10] = {1,2,3,4,5,6,7,8,9,10};
int* p = a;
p++;//指针相加，自增
p--;//指针相减，自减

内存管理

数据存储位置
栈区：
指针，数组，局部变量
数据区：
全局变量 常量
内存模型
代码区：
程序执行二进制码（程序指令） 共享，只读
数据区：
1、初始化数据区（data）
2、未初始化数据区(bss)
3、常量区
栈区：
系统为每一个程序分配一个临时的空间
局部变量，函数信息，函数参数，数组
栈区大小为：1M
堆区：
存储大数据，图片，音乐，视频
手动开辟 malloc
手动释放 free
堆空间开辟和使用：

//开辟堆空间  连续空间
int* p = (int*)malloc(sizeof(int));
//使用堆空间
*p = 123;
printf("%d\n",*p);
//释放堆空间
free(p);
p = NULL;

内存操作函数：

//开辟堆空间  连续空间
int* p = (int*)malloc(sizeof(int)*10);
//memset()重置内存空间的值
meset(p,0,40);//40个字节，重置为0

//内存拷贝
int arr[] = {1,2,3,4,5,6,7,8,9,10};
int* p = (int*)malloc(sizeof(int)*10);
//将arr拷贝到堆区
//目标和源不能重叠
memcpy(p,arr,sizeof(int)*10);
//将arr拷贝到堆区
//目标和源重叠时，安全
memmove(p,arr,sizeof(int)*10);

//比较内存中的值
int arr1[] = {1,2,3,4,5,6,7,8,9,10};
int arr2[] = {1,2,3,4,5};
int value = memcmp(arr1,arr2,20);
// 返回值：相等为0，大于 >0，小于 <1