第一章节----苹果的发展简史 & C语言

一. 简述

型号:Lisa Macintosh OS X Yosemite
在2012年由Mac OS X--->OS X
iOS6-7的变化过程:拟物化过度向扁平化 Mail Drop中转站
iPhone OS---->iOS
Mac的操作系统是基于Unix的

二. Mac的使用

/根目录 前往--->前往文件夹(按住option可以出现资源库)
finder-->偏好设置-->边栏-->小房子-->再选中小房子-->command+J显示系统文件
command+shift+Go /...进入目录
command+control+F 放大
同一个应用程序的不同文件(两个界面)切换 快捷键 :command + ~
command+shift+3/4 截图 全屏/自动选取

三. 终端的使用

stdlib.h等价于math.h 指调用数学函数
链接 CC+空格-c 文件.c
编译 cc-o 重命名 文件.o
./文件 执行文件
cd/system表示转到根目录下的System文件中
cd system表示转到当前目录下的System文件中
ls /users/mac/desktop
C语言 C89 C90 C99 C11
C语言是一门面向过程的语言,一个C程序只能有一个main函数
CLang编译器和Xcode绑定在一起
~表示根目录
编写程序的4个人步骤: 编写程序-->编译-->链接-->运行
cc 空格-c 空格 源文件.c-->cc 文件.o-->./a.out 使用向上和向下的箭头可以转换当前的编译步骤
.o文件也叫做目标文件
编译和链接合成一步: cc 源文件.c-->./a.out

四. C入门---数据类型

多行注释不要嵌套使用
标志符:区分大小写;不能以数字开头;不可以使用关键字
CPU读取和写入
浮点型定义默认是double型

float score;
score = 100.00f;
printf("score=%.2f\n",score);

浮点型默认保留6位小数 float单精度 double双精度
char d='A'; 存储单位最小bit(位,字)
long long 的占位符是%lld;
Byte(字节) 8bit=1Byte
char中放的字母只能有一个,而且不能是汉字
数值越界指:超过了最大值
用long修饰的整形可以省略int 即long等价于long int;
在64位系统中long long 和long是一样的 没有3个long,short只有一个

short a=1223;
printf("a=%d",a);

有符号 signed int a1=1234;
无符号 unsigned int a2=111100;
int默认是有符号的,signed和unsigned不能省略int unsigned的占位符是%u
获取数据类型存储大小

int a4;
a4=32323;
int size=size of(a4);
printf ("size=%d\n",size);

数据类型的转换:小类型+大类型=大类型
数据类型按大小排列:short,char<int<long<float<double

计算实例:标称的100GB硬盘其实际容量为(100 X 100 X 100 X 100字节)/1024 X 1024 X 1024)=93.1GB 由此可见:产品的容量缩水只要满足计算机的实际容量结果(上下误差应在1%内)
数据类型的强制转化

float c=10.0/3;
printf ("c=%f\n",c);
float c=(float)10/3;
printf ("c=%f\n",c);

在编程中只有两个数据类型相同的数才能做运算
pow(底数,幂次)例如r2,使用需先导入math.h库*
判断:成立为真输出1,相反则输出0

int a=5<4;
printf ("a=%d\n",a);
//通过a的值即可以判断真假

例如:4<2<4 结合方向,从左到右
具体比较:先比较4<2的结果是0,然后再比较0<4结果为1

算数的优先级:算数运算符的优先级>关系运算符的优先级
小括号();中括号[]的优先级比较高
关系运算符指输出结果,即真和假
"=="等于 与 "!="不等于 一般最后比较

五. 函数的引入

三目运算符

int score=80;
int i=score>60? 1:0;
printf ("i=%d\n",i);
//比较真假.真执行1,假执行0;1和0可以替换为其他的方法

scanf函数用来接收键盘上的输入
%p表示地址的占位符,"&"表示取地址符
Ox表示16进制
scanf函数只能存在占位符,不能存在其他字符;

if函数的引入

单个if小括号中的文件为真才会执行花括号里面的内容,非零即为真

if (条件) {
    printf("满足条件输出...");
} else {
    printf("否则输出...");
}

if~else函数:只要满足其中的一个条件,只会执行这个条件下的代码,其他条件都不会执行.
大作用域定义的变量能够在被其包含的小作用域使用,反之则不行
if单独使用时{}是可以省略的,默认是从if语句下面的第一行为作用的范围,建议不要这样使用

switch函数的引用

一般switch函数用来做等值比较

switch (变量) {
    case 常量:
    break;
    
    case 常量:
    break;
    
    ...
    
    default:   //与上面条件都不相等时执行它
    break;
}

判断0~100之间的成绩用switch做可以先除以10再做switch的运算

循环结构一般遵守三个原则
1.定义循环变量 --->控制循环次数
2.设置循环条件 --->循环体,满足条件才会执行
3.更新循环变量

三种循环结构---1.while型循环 在里面可以嵌套使用if语句

先判断在执行

int a=0;
while (a<10) {
printf("hello%d",a);
a++;
}

三种循环结构---2.do-while型循环

先执行后判断

//第一步
int b=0;
do {
    printf("hello %d\n",b);
    b++;        //第三布
} while (b<10);         //第二步

如果将a和b的值都取10,那么执行后a的不输出,b的会输出
while和do-while的区别
1.while是先判断后执行,do-while是先执行后判断
2.当循环条件不满足时,while一次也不执行,但是无论什么情况下do-while至少都会执行一次循环体

三种循环结构---3.for型循环

for(1循环变量(值初始化);2循环条件;4更新循环变量){
3循环体
}
执行顺序:1-2-3-4-2-3-4

for (int i=10;i<10;i++) {
    printf("hello %d\n",i);
}

跳转语句

break中途跳出循环

for (int a=10;a<10;a++){
    if (a ==8) {
        break;  //直接跳出整个循环
    }
    printf("跑了%d圈\n",a);
}       

continue继续从中途退出加入

for (int a=0;a<10;a++) {
    if (a==8) {
        continue;   //跳出本次循环,不会跳出整个循环
    }
    printf("%d\n",a);   
}   

六. 变量

定义:数据类型 变量名 =初始值;
数组:数据类型 数组名[元素个数] =初始值;
一般情况下如果数组没有存满,没存的一般都填充0
数组的几种方式
1.int arr[3]={2,3,4};
2.int arr[5]={2,3};
3.int arr[]={2,4,5} 这种情况下系统默认开辟三个
数组越界:访问不存在的数据,一般尽量避免
数组的遍历

int a[3]={1,2,3};
//sizeof函数用来计算数组中的元素个数
int count=sizeof(a)/sizeof(int);
for (int i=0;i<10;i++) {
    int value=a[i];
    printf("%d\n"value);
    printf("a[%d]=%d\n",i,value);
}

二维数组:int a[3][2]={{2,4},{4,6},{3,2}};
字符串:用双引号引起来的内容就叫字符串,且尾部有一个"\0",表示字符串的结束
字符串的初始化
1.char a[5]={'w','x','h','l','\0'};
2.char b[5];
b[0]='w';
b[1]='x';
b[2]='h';
b[3]='l';
b[4]='\0';
3.char c[5]="wxhl";
4.char *d="wxhl";

二维数组的遍历

int arr[2][3]={{1,2,3},{2,3,4}};
for (int i=0;i<2;i++) {
    for (int j=0;j<3;j++) {
        printf("a[%d][%d]=%d\n",i,j,arr[i][j]);
    }
}   

字符串的遍历

char *str="wxhl";
int len=strlen(str);    //strlen函数是求字符串中的字符个数
for (int i=0;i<len;i++) {
    char c=str[i];
    printf("%c\n",c);
}

打印字符串

char str[]={'w','x','\0'};
printf("%c\n",c);

七. 指针

指针:一块内存地址
定义指针:数据类型 变量名 =初始值

int *point=&a;
printf("point=%p\n"point);

point存的变量a的地址,*point是point指针变量的地址
通过指针可以修改变量的值 *point=20;
第一个指针指的是数据类型,第二个指针指的是指针运算符,实质表示访问指针指向的地址所在的内存空间

所有的指针变量:8字节
指针一旦指定某个变量,除非改变指针指向的地址,否则指针一直指向这块内存空间

八. 函数

1.函数声明

''#include''作用是:把文件名为< >中的拷贝到当前文件
可以实现某个功能的代码(程序)段
返回值类型 函数名(形式参数)

int main (int argc,char const *argv[])
{
    /* code */
    return 0;   0和int对应
}

函数的定义和调用

// 1.定义
int sum(int a,int b){
    int s=a+b;
    return s;
}

// 2.函数的调用
int a=sum(2,4);
printf("a=%d\n",a);

1.没有返回值,没有参数的函数

void printf(){
    printf("hello\n");
    return; //  如果没有返回值 (空类型 void) return可以省略
}

2.调用函数,先走函数调用的地方,函数调用完之后会回到调用的地方,函数可以重复调用

//没有返回值带参数
void ask(int a){
    printf("查询学号为%d的成绩\n",a);
}

3.函数名必须唯一,不能重复.遵守驼峰标志符
4.函数不能嵌套定义
5.一个函数可以没有返回值,但需用void类型,实参可以给形参赋值
声明函数
告诉编译器函数已经定义过,
返回值类型 函数名(形参)
1.在声明函数时形参可以省略,()不能省略;
2.声明函数写在int main()上面;
3.声明函数最好写在函数调用的前面,最好写在int main()上面
4.用const修饰的变量会编程常量,不能对他进行修改

2.Rand( ),产生随机数函数

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

int t=time(0);
rand(t);
for (int i=0;i<10;i++) {
    int result=rand()%100;
    printf("result=%d\n",result);
}

随机数种子函数.根据时间的不同产生不同的随机数种子,进而产生不同的随机数

宏定义后面不接;
宏写在字符产里面不会被替换

#define PI 3.14
#undef PI  结束宏定义

3.函数的调用

1.嵌套调用
2.递归调用:函数本身调用本身(自己掉用自己)容易造成死循环

九.结构体,枚举

局部变量,仅限于{}
不能先赋值再定义
全局变量定义在函数外面的变量
全局变量都是静态变量,自动变量都是局部变量,局部变量不一定是自动变量

自动变量用auto修饰,局部变量默认用auto修饰
生命周期:从定义开始的地方,到函数或者代码块执行完毕

静态变量用关键字static修饰
生命周期:伴随这整个应用程序始终

自动变量
硬件寄存器,在CPU里

寄存器变量:本身就是自动变量,效率高,只能修饰自动变量
register int c=100;
只限于int,char,浮点型和指针类型使用

extern修饰的函数就是外部函数,可以被其他文件访问,默认就是extern修饰
static修饰的函数是内部函数,只能当前文件访问
extern修饰变量时,只能声明变量,不是定义变量
static修饰全局变量,就是内部变量,只能被当前文件访问

结构体
1.定义结构体

struct Person {
    char *name;
    int age;
    double weight;
}

2.使用:数据类型 变量名=初始值

struct Person  ps1; //先定义后赋值
    ps1.name="Wiz";
    ps1.age=20;
    ps1.weight=110;

①定义时直接赋值
strcut Person ps2={"Wiz",32,110};
②取值

char *name=ps1.name;
printf("ps1.name=%s\n",_name);
printf("%s  %d  %.2f",ps2.name,ps2.age,ps2.weight);

定义一个结构体的同时定义变量

struct Dog {
    char *name;
    char *color;
} dog;  //或者直接添加多个对象,用逗号隔开,最后加分号
dog.name="小黑";
dog.color="白色";
printf("%s %s\n",dog.name,dog.color);

①结构体自己不能定义自己递归调用
②一般名字不能想同
③在结构体中定义其他结构体
结构体所占的内存空间是最大成员变量的整数被之和--->"内存对齐"

定义一个结构体指针

struct Person *point=&ps2;
struct Person ps2={"li4",34,120};

指针运算符,通过指针修改结构体成员变量的值
point->name="zhao4";
访问结构图成员变量的值
char *name=point->name;
struct2.name=alloc(20); //给空间
需要<stdlib.h>库
alloc手动分配内存

enum weather wea=sunny;
enumweather 数据类型
取别名:typedef 本名 别名;

十.指针函数与函数指针

只需要记住后两个字,是什么就是什么

1.指针函数

int * test(int *p) {
    return p;
}

2.函数指针

1.创建函数
函数名称也是一个指针,指向的是本函数在内存中的地址

int sum(int a,int b) {
    NSLog(@"result=%d",a+b);
    return a+b;
}

函数指针可以调用函数,也可以作为参数传递到函数中

int getSum(int (*p)(int a,int b),int c,int d) {
    int result=p(c,d);   //等同于sum(1,1);
    return result;
}

int main(int argc, const char *argv[]){
    @autoreleasepool {
    //2.创建函数指针
    //返回值 (*指针名) (参数列表)
    int (*p)(int a,int b);
    
    //3.使用函数指针指向函数在内存中的地址
    p=sum;
    
    //4.调用函数
    sum(10,20);
    
    //5.使用函数指针来调用函数
    p(10,20);
    (*p)(10,10);
    
    //函数指针把函数作为参数传递到函数中
    int (*p1)(int a,int b);
    p1=sum;
    
    int lastResult=getSum(p1,1,1);
    NSLog(@"lastResult=%d",lastResult);
    }
    return 0;
}