//第一天:C语言的基础
//进制
//2进制, 10进制, 8进制, 16进制
//注:8进制数前加0, 16进制数前加0x
//进制转换:
//10 -> n: 连除到取余
//n -> 10: 按权求和法(基数, 位权)
//n -> n: 1个8进制位 = 3个2进制位, 1个16进制位 = 4个2进制位
//字节
//1字节 = 8位2进制
//单行注释: //
//多行注释: /* */
//注:注释不参与程序编译, 可以出现在任何位置
//main函数: 是程序入口, 只能有一个
//数据类型
//基本类型: 1.整型: short int long 2.浮点型: float double 3.字符型: char
//构造类型: 1.数组[] 2.结构体struct 3.枚举enum
//指针类型: *
//空类型: void
//变量
//定义: 数据类型 变量名 = 初值
//注: 变量要先定义, 才能使用
//变量名的命名规范
//1.由数字, 字母, 下划线构成, 不能以数字开头
//2.在同一作用域内, 不能重名
//3.不能用系统的关键字(看颜色)
//4.见名知意(不用使用拼音, 汉字, 中英交叉)
//5.小驼峰法
//常量
//1, 19.9, 'c', "abc"
//运算符(单目, 双目, 三目)
//1.赋值运算符: =
//2.算术运算符: +, -, *, /, %, ++, --
//3.复合运算符: +=, -=, *=, /=, %=
//4.逻辑运算符: &&, ||, !
//5.关系运算符: >, >=, <, <=, ==, != (BOOL)
//6.条件运算符: ? :
//表达式 = 变量 + 常量 + 运算符
//语句: 程序执行的最小单元(见到;即语句)
//printf("Hi");
//printf("%d", a);
//格式化输出符
//char %c %d
//short %hd
//int %d
//long %ld
//float %f
//double %lf
//BOOL %d
//字符串 %s
//unsigned int %u
//unsigned long %lu
//八进制 %o
//十六进制 %x
//指针 %p
//以回车结束输入 %[^ ]
//%-10.2f:
//转义字符
//换行
//tab
//% %%
//" "
// \
//scanf("%d", &a);
//注: ""内不能加 , 后面写变量的地址
//第二天: 分支结构
//C语言的三大结构: 顺序结构, 分支结构, 循环结构
//if
//第一种形式
/*
if (<#condition#>) {
<#statements#>
}
*/
//第二种形式
/*
if (<#condition#>) {
<#statements#>
} else {
<#statements#>
}
*/
//第三种形式
/*
if (<#condition#>) {
<#statements#>
} else if (<#expression#>) {
<#statements#>
} else {
<#statements#>
}
*/
//注: 三种形式可以相互嵌套使用
//enum
enum 枚举名{
枚举值1,
枚举值2,
…
}
枚举值:枚举值默认从零开始,也可以指定数值;
枚举值常与switch合用
//switch
/*
switch (<#expression#>) {
case <#constant#>:
<#statements#>
break;
case <#constant#>:
<#statements#>
break;
default:
break;
}
*/
//注:1.switch后的表达式是整型表达式
//2.case后面的值是常量
//3.case和default中需要加break
//4.如果在case中定义变量, 需要case内部添加括号
/*
int a = 10;
switch (a) {
case 10:
{
int b = 100;
break;
}
default:
break;
}
*/
/*
//const用于修饰那一部分不能修改
//判断步骤
//1.去掉数据类型
//2.const后的就是不能修改的部分
int a = 10;
int b = 100;
const int *p1 = &a;//*p1不能修改
int const *p2 = &a;//*p2不能修改
int * const p3 = &a;//p3不能修改
const int * const p4 = &a;//p4和*p4不能修改
*/
/*
int max = 0, a = 5, b = 10;
max = a > b ? a : b;
if (a > b) {
max = a;
} else {
max = b;
}
*/
//第三天:循环结构
//for循环
/*
for (<#initialization#>; <#condition#>; <#increment#>) {
<#statements#>
}
*/
//while循环
/*
while (<#condition#>) {
<#statements#>
}
*/
//do...while循环
/*
do {
<#statements#>
} while (<#condition#>);
*/
//知道循环的次数, 使用for循环
//知道循环结束的条件, 使用while循环
//do...while循环使用比较少
//随机数公式[a, b]
//arc4random() % (b - a + 1) + a
//break: 跳出本层循环
//continue: 跳出本次循环, 加速循环的执行
//return: 跳出函数, 返回数值
//第四天:数组
//用于存储多个相同数据类型的有序队列
//数据类型 数组名[元素个数] = {};
//注: 元素个数可以省略, 由后面赋值来决定元素个数
//数值的使用
//1.数组不能够直接参与运算
//2.数组中的元素可以参与运算
//元素的访问
//1.通过下标访问数组元素
//2.下标从0开始, 到(元素个数 - 1)结束
//遍历数组
//遍历n维数组, 要嵌套n层for循环
//冒泡排序
/*
int array[5] = {12, 20, 3, 48, 5};
for (int i = 0; i < 5 - 1; i++) {
for (int j = 0; j < 5 - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
*/
//字符数组 = 字符串
//打印字符串: %s
//字符串函数
//strlen: 字符串长度
/*
char string[10] = "iPhone";
printf("%lu ", strlen(string));//长度:6
printf("%lu ", sizeof(string));//字节数:10
*/
//strcpy: 字符串拷贝
//strcat: 字符串拼接
//strcmp: 字符串比较
/*
int c = 5;
int array[c] = {};//数组定义时, 元素个数不能使用变量
*/
//第五天: 多维数组
//定义
//数据类型 数组名[维度1][维度2][...] = {};
//字符数组, 一维数组
//字符串, 一维数组
//字符串数组, 二维数组
/*
char string[5][20] = {"zhangsan", "lisi", "asan", "erhu", "guangtouqiang"};
//冒泡排序(a-z)
for (int i = 0; i < 5 - 1; i++) {
for (int j = 0; j < 5 - 1 - i; j++) {
if (strcmp(string[j], string[j + 1]) > 0) {
char temp[20] = {0};
strcpy(temp, string[j]);
strcpy(string[j], string[j + 1]);
strcpy(string[j + 1], temp);
}
}
}
*/
//第六天: 函数
//具有特定功能的代码段
//一个严格的函数包括
//1.函数声明
//2.函数定义
//3.函数调用
//函数定义
/*
返回值类型 函数名(参数类型 参数名, ...) {
}
*/
//注: 1.没有返回值, 使用void
//2.没有参数, 括号不能省略
//3.参数类型相同, 类型不能省略
//4.函数之间是并列的关系, 不能嵌套定义
//函数调用
//函数名(实参, ...)
//实参: 函数调用时的参数
//形参: 函数定义时的参数
//注: 函数调用时, 把实参的值拷贝给形参
//主调函数: 在函数a中调用了函数b, 函数a就称为函数b的主调函数
//局部变量: 定义在函数体内部的变量
//全局变量: 定义在函数体外部的变量
//注: 尽量不要使用全局变量
//函数可以嵌套调用
//递归函数, 一定要有出口
//*.h中写 函数声明
//*.m中写 函数定义
//如果在其他文件使用函数, 需要引入头文件
//数组作为函数的参数
//1.,数组名[],数组的元素个数省略
//2.多添加一个参数, 用于传递数组元素个数
//第七天: 结构体
//结构体是用户自定义的数据类型
//结构体声明
/*
struct <#struct name#> {
<#struct fields#>
};
*/
//注:1.结构体名字用小驼峰法
//2.每一个成员变量以分号结束
//3.结构体声明写在.h中
//结构体变量
//struct 结构体名 变量名 = 初值
//注: 1.结构体变量可以直接参与运算
//2. 结构体变量不能够直接打印
//结构体变量的成员变量
//使用点语法访问
//使用typedef对结构体重命名
//typedef 原结构体名 新结构体名
//注: 新结构体名要是大驼峰法
//结构体所占的字节数
//1.最大数据类型的倍数
//2.交换成员变量的位置, 会影响结构体所占的字节数
//char 1
//short 2
//int 4
//long 4或8
//float 4
//double 8
//指针 4或8
//结构体和数组相互嵌套使用
//1.结构体声明时, 成员变量是数组类型
//2.数组内存放的都是结构体类型的变量(结构体数组)
//第8天: 指针
//内存的地址编号
//&: 取地址运算符
//%p 打印地址
//指针变量: 用于存储地址
//数据类型 *变量名 = NULL
//注:1. 指针变量所占的字节数和数据类型无关, 只有操作系统的位数相关
//2.数据类型决定*p取内容时, 取多少个字节
//3.数据类型决定p + 1时, 跳转多少个字节
//*: 取值运算符
//指针变量被重新赋值, 意味着指针变量重定向
//指针的运用
//指针在数组中的运用
//数组的名字就是数组的首地址
// int a[5] = {1, 2, 3, 4, 5};
//*a a[0]
//*(a + 1) a[1]
//*(a + i) a[i]
// int *p = a;
//p 和 a 的区别
//1. 数组的名字a是一个常量指针, 不能重定向(修改)
//2. sizeof, p: 求指针所占的字节数; a: 求数组所占的字节数
//指针在字符串中的运用
// char string[] = "iOS";
// printf("%s ", string);
// printf("%s ", string + 1);
//
// char *q = string;
// printf("%s ", q);
//第9天: 指针高级
//指针数组: 数组中元素类型是指针类型
int a = 10;
int b = 20;
int c = 30;
int *p[3] = {&a, &b, &c};
//p[0] &a *p
//p[1] &b *(p + 1)
//p[2] &c *(p + 2)
//*p[0] a *(*p)
//*p[1] b *(*(p + 1))
//*p[2] c *(*(p + 2))
//指针作为函数的参数
//作用: 在函数内部修改外部变量的值
//(int array[], int count)
//(int *array, int count)
//指针在结构体变量中的使用
//定义一个结构体指针变量 指向 结构体变量的首地址
//可以用->(指向操作符), 访问结构体的成员变量
//指针在结构体数组中的使用
struct student {
char name[20];
int age;
float score;
};
typedef struct student Student;
Student array[3] = {
{"zhangsan", 18, 59.9},
{"lisi", 20, 69},
{"wangmazi", 40, 30}
};
//array[0].name (*array).name
//array[1].name (*(array + 1)).name
//array[2].name (*(array + 2)).name
//array->name
//(array + 1)->name
//(array + 2)->name
//第10天: 动态内存分配
//内存的五大分区(地址编号由高到底)
//1.栈区(局部变量, 系统控制)
//2.堆区(由开发人员手动申请, 手动释放)
//申请 malloc
//释放 free p = NULL
//3.静态全局区(全局变量和static修饰的变量, 系统控制)
//static变量特点
//a. 存在静态全局区
//b. 只能被初始化一次
//c. 没有赋初值, 默认为0
//4.常量区(常量, 系统控制, 常量区的内容是只读的)
//5.代码区(函数,语句, 系统控制)
//第11天: 函数指针
//函数的名字就是函数的首地址
//函数指针类型确定的步骤
//1.把函数名换(*)
//2.去掉函数体和参数名
//int (*)(int, int)
/*
int printHello(int a, int b) {
}
*/
//函数指针变量
//int (*p)(int, int) = NULL
//注: 变量名写在*后面
//使用typedef重命名函数指针类型
//typedef int (*Type)(int, int)
//注: 新类型名, 写在*后面
//Type p = NULL
//指针指向函数的首地址
//p = printHello;
//printHello(3, 4)
//p(3, 4)
//回调函数: 使用函数指针变量调用函数
//函数指针变量作为函数的参数, 函数可以实现多种功能
//前提: 函数指针类型相同
//宏
//无参宏 只做简单地替换
//有参宏 #define kSum(A,B) ((A)+(B))
//表达式中的每一个参数加括号,整个表达式也要加括号
//条件编译
//三种条件编译
/*
#ifdef 标识符 代码段1 #else 代码段2 #endif
如果 标识符 被 #define 过 ，编译器编译代码段1，否则编译代码段2。
#ifndef 标识符 代码段1 #else 代码段2 #endif
如果 标识符 未被 #define 过 编译器编译代码段1，否则编译代码段2。
#if 常量表达式 代码段1 #else 代码段2 #endif
如果 常量表达式结果 非0 编译器编译代码段1，否则编译代码段2。
三种形式一样,以后主要用于版本控制;
*/
//经前人总结,若不自宫也能成功!!!
版权声明：本文为博主原创文章，未经博主允许不得转载。