Men的博客

OC中的内存管理

alloc+init 方式创建对象, 一般情况下在堆上上,使用完一定要释放
手动内存管理
自动内存管理(自动引用计数-ARC)
如何内存管理方式切换到手动内存管理?
工程配置–>TARGETS->Build Setting-> 搜索 counting, 设置为NO

内存管理中常用的方法

alloc+init
//1.alloc+init
//alloc: 为对象申请空间,把这块空间全部初始化为0
//alloc申请的对象一般情况下都在堆空间,必须考虑释放的问题
//init 初始化这个对象
Dog *princess = [[Dog alloc] init];
dealloc+release
retain+retainCount

引用计数这种内存管理方式

//获取对象被使用的次数
NSLog(@”count=%lu”,princess.retainCount);
//以后内存管理中有问题的
//retain: 让对象引用次数+1
//retain的对象也要release
[p release];
NSLog(@”count=%lu”,princess.retainCount);
//释放放在最后
//release作用:
// 如果retainCount>1 说明有多个人在使用这个对象,不会释放,对象引用次数-1
// 如果retianCount==1
// 最后使用的”人”释放这个对象
// 调用dealloc真正释放对象
[princess release];
NSMutableString *str = [[NSMutableString alloc] initWithString:@”的麻烦了看什么地方了开始免费立刻马上离开父母萨洛克没放到里面是打发来看马萨拉蒂方面撒地方可拉伸的佛罗伦萨地方了”];
//特别值得注意的问题
// 最好千万不要在对象release之后使用对象
//什么是释放:
// 释放是失去了这块内存的使用权(内存还在)
// 一旦释放, 别人有可能使用这块内存
// 咱们在使用的就会出现问题
//[princess show];
copy+mutableCopy
//问题:
// retain两个指针, 只有一个对象
// copy复制这个对象
// 效果: 两个指针指向不同的对象
// copy 返回不可变对象
// mutableCopy返回可变对象
NSMutableString *pname = [name mutableCopy];

内存管理原则:黄金法则
如果你对一个对象使用了 alloc,retain,copy/mutableCopy, 使用完这个对象之后需要调用对应的realese或autorelease
代码中alloc和release成对出现的retain和release也是成对出现的

代码中出现的各种内存管理情况

(0)如果在方法内部定义了一个对象指针,指向了alloc申请的对象
需要在方法结束前释放这个对象

init中为对象指针(类的实例变量)的申请对象

需要在dealloc方法中释放 (重点)
//需求: 创建车的同时添加引擎
-(id)init
{
if(self = [super init])
{
//考虑到释放问题
//类中对象指针一般在init中申请对象
// 在dealloc中释放对象
_engine = [[Engine alloc] init];
//NSString *str = [[NSString alloc] init];
//[str release];
}
return self;
}
-(void)dealloc
{
NSLog(@”Car dealloc”);
[_engine release];
//这句放在最后
[super dealloc];
}

对象指针的setter方法

//_engine实现设置方法
-(void)setEngine:(Engine *)engine
{
//以前的写法
//_engine = engine;
//传入的指针和保存指针相同,返回即可
if(_engine == engine)
{
return;
}
//旧的对象不用了, 立即释放
[_engine release];
//多一个指针指向engine对象
//引用次数+1,调用retian方法
_engine = [engine retain];
}

对象指针的getter方法

//_engine实现获取方法
-(Engine *)engine
{
//以前的实现
//return _engine;
//retain: 返回的对象类外的指针指向, 多了一个使用, 引用+1
// autorelease谁使用,谁释放
// 不能用release, 立即使用
return [[_engine retain] autorelease];
}

各种实例变量的property (重点)

//使用property实例变量添加getter和setter
// 一般情况, NSString 使用copy作为属性修饰符
//copy, 把传入的字符串拷贝一个份新的
//字符串,字典,数组用copy最好
@property (copy) NSString *type;
//assign表示直接赋值, 不retain也不copy
// 默认是assign, assgin可以不写
//@property (assign) float price;
@property float price;
//retain表示实现的setter中添加retain,getter也会添加retain
@property (retain) Engine *engine;

//代理设计模式中
// 代理的属性修饰符必须是assgin,不能是retain,否则会引起无法释放的问题
@property (assign) id delegate;

取消线程保护 nonautomic

//nonatomic取消多线程保护
//1.什么是多线程(多任务)
// 迅雷下载(界面响应用户点击,下载数据)
//2.为啥要加这一句啊
// 多线程保护比较耗时, 取消提供代码速度
@property (nonatomic) float speed;

类方法创建对象如何写?

//类方法创建的对象无需释放, 也不能释放
创建对象的方法,类方法
+(id)car
{
//干两件事情
Car *car = [[Car alloc] init];
//if(car)
//{
//设置car的属性
//}
//alloc和autorelease对应起来
return [car autorelease];
}

数组中的添加对象内存管理 NSArray

//数组被释放的时候会给数组中每个对象发送release
[array release];

字符串的内存管理

// 特点: 特立独行,有性格
//字符串常量的引用数是极大值,不需要释放
//总结:
以alloc创建的字符串最后使用release释放
字符串常量和以类方法创建的字符串不需要释放

数据持久化简介

文件: 最常用的最基础的存储数据的方式
plist,xml,json 表示数据的某种格式
数据库: 海量的数据(省上所有人的电话信息)存储到数据库中
SQL Server 2000, mysql, Oracle
云端存储: 数据都存储的网络上, 安全性好, 跨设备,跨平台

plist文件

用途比较多
本质上来说是 Property List file, 属性列表文件
存储格式: 数据都是由字典,数组,字符串构成的
2.2 如何创建plist文件
File->OS X-Resource–> Proerty List
2.3 plist文件的读取和写入
//如何读取这个plist文件???
NSString *path = @”/Users/mac/Desktop/oc7-持久化存储/PlistUseDemo/PlistUseDemo/student.plist”;
//plist根结点只有两种类型, 数组和字典
// 分别使用NSArray和NSDictionary读取plist
NSDictionary *dict = [[NSDictionary alloc] initWithContentsOfFile:path];
//输出所有的班级的信息
//NSArray *classList = [dict valueForKey:@”classes”];
NSArray *classList = dict[@”classes”];
for (NSDictionary *classDict in classList) {
}
// 可以把一个数组或者字典写入到plist中
//参数1: 传入一个路径
//参数2: 表示是否安全的写入
[classList writeToFile:@”/Users/mac/Desktop/classList.plist” atomically:YES];

归档

使用归档, 可以直接把一个对象保存到文件中

//归档的使用
//作用: 对象保存到文件中
//相比plist: plist使用简单, 不能存储自定义对象
// 归档可以存储任意类型对象
NSArray *array = [[NSArray alloc] initWithObjects:@”小二”,@”三少”,@”四娘”,@”跳舞大神”, nil];
//通过归档的形式存储到文件中
//设置文件名
NSString *path = @”/Users/mac/Desktop/people.data”;
//NSKeyedArchiver专门用于归档的类
//参数1: 传入需要保存的对象
//参数2: 传入文件路径
BOOL b = [NSKeyedArchiver archiveRootObject:array toFile:path];
//把对象从文件中恢复出来===解档
//参数1: 传入保存了对象文件
//返回值: 返回保存的对象
// 类型原来存储的是什么类型, 用什么类型接收
NSArray *readArray = [NSKeyedUnarchiver unarchiveObjectWithFile:path];
for(NSString *str in readArray)
{
}

自定义对象的归档和解档

//归档
NSString path = @”/Users/mac/Desktop/dog.data”;
//**** 自定义的对象不能直接归档, 会出现崩溃
//***** 需要告诉系统我们对象应该如何归档
// 自己类中添加一些指定的方法

[NSKeyedArchiver archiveRootObject:huaer toFile:path];

//解档刚才存入的对象
Dog *newDog = [NSKeyedUnarchiver unarchiveObjectWithFile:path];
NSLog(@”–> %@ %@ %f %@”,
newDog.nickname,
newDog.gender,
newDog.weight,
newDog.type);

//告诉系统, 这个对象应该如何编码
// 如果没有加这个方法,自定义对象归档的时候会奔溃

• (void)encodeWithCoder:(NSCoder *)aCoder
  {
  //把类中的对象指定一个key, 编码到文件中
  [aCoder encodeObject:self.nickname forKey:@”nickname”];
  [aCoder encodeObject:self.gender forKey:@”gender”];
  [aCoder encodeObject:[NSNumber numberWithFloat:self.weight] forKey:@”weight”];
  [aCoder encodeObject:self.type forKey:@”type”];

}

//告诉系统, 这个对象应该如何解码
// 如果没有加这个方法,自定义对象解档的时候会奔溃

• (id)initWithCoder:(NSCoder *)aDecoder
  {
  if (self = [super init]) {

    //对数据进行解码操作
    self.nickname = [aDecoder decodeObjectForKey:@"nickname"];
    self.gender = [aDecoder decodeObjectForKey:@"gender"];
    self.weight = [[aDecoder decodeObjectForKey:@"weight"] floatValue];
    self.type = [aDecoder decodeObjectForKey:@"type"];
    
  

  }
  return self;
  }

Json解析

Javascript Object Notation 简写
网络常用一种表示数据或交换数据的格式
4.2 Json数据格式
[]表示一个数组, 对应NSArray
{}表示一个字典, 对应NSDictionary
key:value 表示一个键值对
“str” 表示一个字符串 NSString
90 表示一个数字 NSNumber
, 表示并列的数据
4.3 Json格式的读取和使用
//如何解析JSON, 解析后如何获取其中数据
NSString *path = @”/Users/mac/Desktop/1422带课/oc7-持久化存储/topic.txt”;
//JSON先读取到程序中(NSString,NSData)
NSData *data = [[NSData alloc] initWithContentsOfFile:path];
//OC提供专门用于JSON解析的类
//NSJSONSerialization
//功能: 把NSData类型JSON数据转化为字典或者数组
//参数1: 需要解析的JSON数据
//参数2: 传入一个选项
//参数3: 错误
//返回值: 如果JSON顶层结点是[],用NSArray接收
// 如果顶层结点是{}, 用NSDictionary接收
NSArray *array = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableContainers error:nil];

NSFileManager 文件或目录管理类(重点)

1.1 创建NSFileManager的对象
//创建对象
//默认用于创建对象方法
//defaultManager创建出对象都是同一个对象
//单例模式: 有时候想让让一个类只能创建一个对象
NSFileManager *fm = [NSFileManager defaultManager];
1.2 获取目录下的所有文件和目录
//(2)知道某个目录下都有哪些文件和目录
//细节: 不会显示子目录
NSArray *array = [fm contentsOfDirectoryAtPath:@”/Users/mac/Desktop/dir” error:nil];
//显示所有文件包括子目录
array = [fm subpathsOfDirectoryAtPath:@”/Users/mac/Desktop/dir” error:nil];
1.3 创建目录, 创建文件
实例: 创建 /Users/mac/Desktop/dir/hello
//参数2: 表示是否创建中间目录
BOOL b;
b = [fm createDirectoryAtPath:@”/Users/mac/Desktop/dir/hello” withIntermediateDirectories:YES attributes:nil error:nil];
NSLog(@”b = %d”,b);
b = [fm createFileAtPath:@”/Users/mac/Desktop/dir/saozi.txt” contents:nil attributes:nil];
NSLog(@”b = %d”,b);
1.4 复制文件, 移动文件, 删除文件
//参数1: 源文件
//参数2: 目标文件
b = [fm copyItemAtPath:@”/Users/mac/Desktop/dir/saozi.txt” toPath:@”/Users/mac/Desktop/dir/hanzi.txt” error:nil];
//移动文件
BOOL b = [fm moveItemAtPath:@”/Users/mac/Desktop/dir/saozi.txt” toPath:@”/Users/mac/Desktop/dir/hello/saozi.txt” error:nil];
BOOL b = [fm removeItemAtPath:@”/Users/mac/Desktop/dir/hanzi.txt” error:nil];
1.5 判断文件是否存在
//(5)判断文件是否存在
BOOL b =[fm fileExistsAtPath:@”/Users/mac/Desktop/dir/dict.txt”];

文件读写操作 NSFileHandle

2.1 打开文件
细节：打开应选择的模式；
1.为了写文件fileHandleForWritingAtPath
2.为了读文件fileHandleForReadingAtPath
(1)创建对象打开文件
NSFileHandle *fh = [NSFileHandle fileHandleForReadingAtPath:@”/Users/mac/Desktop/dir/123.txt”];
if(fh == nil)
{
NSLog(@”文件打开失败”);
return 1;
}
2.2 读取文件数据
//(2)读取文件数据
//读取指定长度的数据
//一直读取直到文件末尾
// NSData 表示二进制的数据
NSData *data = [fh readDataOfLength:100];
//读取出得二进制数据转化为字符串
NSString *info =[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
2.3 写文件
//写入数据
NSString *str = @”好吃不过饺子,hao wan bu guo sao zi”;
//转化
NSData *data = [str dataUsingEncoding:NSUTF8StringEncoding];
//清空文件内容
//[fh truncateFileAtOffset:0];
//文件读写位置设置到文件的末尾
[fh seekToEndOfFile];
[fh writeData:data];

2.4 移动文件读写位置
//文件读写位置设置到文件的末尾
[fh seekToEndOfFile];

NSValue和NSNumber的使用

int a=10;
int b=20;
//完成了基本数据类型到对象转化
NSNumber *num1 = [NSNumber numberWithInt:a];
NSNumber *num2 = [NSNumber numberWithInt:b];
NSArray *array = [[NSArray alloc] initWithObjects:num1,num2,nil];
//需求: 把一个结构体变量存储到NSArray中?
//思考: 把一个结构体变量转化为对象 NSValue
typedef struct Person{
int age;
float height;
}Person;
Person zhangsan = {18,1.77};

//作用: 把C的类型的数据转化为NSValue类型
//参数1: 数据的地址
//参数2: 数据的类型
//@encode作用把类型转化为字符串
NSValue *value = [[NSValue alloc] initWithBytes:&zhangsan objCType:@encode(Person)];
NSMutableArray *marr = [[NSMutableArray alloc] init];
[marr addObject:value];

Person newPerson;
//从NSValue中解析出存储的数据
[value getValue:&newPerson];

NSDate的使用

(1)获取当前时间
NSDate *date = [NSDate date];
//时区概念 +8区
(2)时间格式化输出
NSDateFormatter *df = [[NSDateFormatter alloc] init];
//设置时间的格式
[df setDateFormat:@”yyyy/MM/dd HH:mm:ss S”];
NSString *dateString = [df stringFromDate:date];
(3)获取年,月,日
设置需要的格式
(4)计算某个操作所消耗的时间–计算时间差
NSDate *beginDate = [NSDate date];
long sum=0;
for (long i=0; i<1000000000; i++) {
sum = sum+i;
}
NSDate *endDate = [NSDate date];
double interval = [endDate timeIntervalSinceDate:beginDate];

OC是一门面向对象的语言
面向对象: 封装, 继承, 多态

能不能让编译器自动生成getter和setter方法的原型?

使用 @property帮我们生成getter和setter方法的声明
(1)形式1
//以名字name为例
-(void)setName:(NSString *)n;
-(NSString *)name;
(2)形式2
@property NSString * name;

能不能让编译器自动生成getter和setter方法的实现(早期版本)

使用 @synthesize 帮我们生成getter和setter方法的实现
(1)形式1
//以名字name为例
//name的设置方法
-(void)setName:(NSString *)n
{
NSLog(@”setName”);
name = n;
}
//name的获取方法
-(NSString *)name
{
//返回name是实例变量name
return name;
}
(2)形式2
@synthesize name;

实例变量设置为只读的

@property (readonly) NSString *sex;

指定getter方法和setter方法的方法名?

@property (getter = isShow,
setter = changeShow:) BOOL show;

不同类型的实例变量的property如何写

对于字符串和对象有特殊的处理
添加property
nonatomic 作用取消线程保护,提高代码执行速度
@property (nonatomic) int age;
copy 表示拷贝对象
@property (nonatomic,copy) NSString *name;
retin 表示持有对象
@property (nonatomic,retain) Eye *eye;

创建初始化

//参数格式: value1,key1, value2,key2, …..
NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:
@”zhangsan,B,13611112222”, @”zhangsan”,
@”lisi,G,1101101101110”, @”lisi”,
nil];

使用其中对象

NSString *str = [dict objectForKey:@”lisi”];

快速遍历

//细节1: 使用forin获取到的都是key,不是值
//细节2: 使用字典, 存进去是某个顺序, 取出来不一定是这个顺序
for (NSString *key in dict) {
NSString *value = [dict objectForKey:key];
NSLog(@”key = %@, value = %@”,key,value);
}

==NSMutableDictionary==

NSMutableDictionary类继承与NSDictionary

创建对象

NSMutableDictionary *mdict = [[NSMutableDictionary alloc] init];

添加或替换

//细节: 如果这个key不存在, 相当于字典中添加一个对象
//如果key存在, 则会覆盖这个key对应的值
[mdict setValue:@”zhangsan,27” forKey:@”zs”];
[mdict setValue:@”lisi,30” forKey:@”ls”];

移除对象

[mdict removeObjectForKey:@”ww”];
[mdict removeAllObjects];

创建初始化

NSArray *array = [[NSArray alloc] initWithObjects:@”z”,@”l”,@”w”,nil];
NSArray *array2 = [[NSArray alloc] initWithArray:array];
NSString *str1 = [array objectAtIndex:1]; //不要越界,会崩溃

快速遍历

long count = array.count;
for(long i=0; i<count; i++)
for(NSString *s in array)

查找指定对象

long loc = [array indexOfObject:@”lishi”];

==NSMutableArray==

NSMutableArray继承自NSArray, 使用NSArray的所有方法

创建对象

NSMutableArray *marr = [[NSMutableArray alloc] init];
NSMutableArray *marr = [NSMutableArray array];

添加对象

[marr addObject:str1];

插入对象

[marr insertObject:@”zhuge” atIndex:0];

移除对象

[marr removeObject:@”zhuge”];
[marr removeObjectAtIndex:0];

替换对象

[marr replaceObjectAtIndex:0 withObject:@”ouyang”];

排序

[marr sortUsingSelector:@selector(mycompare:)];

创建字符串对象

NSString *str = @”hello world”;
//从C的字符串创建一个字符串对象
NSString *str2 = [[NSString alloc] initWithUTF8String:”tian qi bu cuo o”];
NSString *str2 = [NSString
stringWithUTF8String:”tian qi bu cuo o”];
//从其他数据生成字符串对象
NSString *str3 = [[NSString alloc] initWithFormat:@”zhangsan %d %c”,age,sex];
//从另外一个字符串对象,创建字符串对象
NSString *str4 = [[NSString alloc] initWithString:str3];

计算长度

long length=[str length]

比较字符串

BOOL a=[str1 isEqualToString str2];
int r=[str1 compare str2];

查找子串

NSRstring range=[str rangeOfString substr];

提取字符和字符串

unichar c=[str characterAtInder :4]
NSString *subetring=[str substringWithRange:range];

转换

int num=[str intValue]

从文件生成字符串

NSString *str10=@”/Users/student/Desktopdict.txt”;
NSString *f=[[NSString alloc]initWithContentsOfFile:str10 encoding:NSUTF8StringEncoding error:
nil];

==NSMutableString==

<1> 创建对象
<2> 复制(设置字符串)
<3> 连接(附加)
<4> 插入
<5> 删除
<6> 替换

== 字符串处理相关

<1> 字符串分割 , 使用NSString的componentsSeparatedByString
NSArray *arr = [str componentsSeparatedByString:@” “];
<2> 数组合并为字符串 ,使用NSArray的componentsJoinedByString
NSString *comStr = [arr componentsJoinedByString:@”—“];

Objective-c是c语言的母集合，它的原意就是在原始的c语言的主体上加入面向对象的特性。
1、面向对象和面向过程
面向对象和面向过程是编程的两种思考方式。面向对象，简称OOP，它是以事物为中心，参与事件的事物是核心，完成事件只是事物的一个小任务。面向过程，简称OPP，它是以事件为中心，事件是核心，列出了完成事件的每一个步骤，一步一步完成。也就是面向对象侧重于从问题在寻找客体、客体的作用。客体间的关系即“谁”、“做什么”、“怎么做”，面向过程侧重于问题的分解即“事件怎么做”。
2、类和对象
（1）类是一组具有相同（特征）属性和行为（功能）的事物的集合（抽象）。对象就是类的具体实现。世间万物皆对象。类其实就是一种数据类型，它的变量就是对象。
（2）类的定义
在OC中，类的定义分两部分：接口部分和实现部分；
接口部分（interface）：声明了类与父类的名字、方法是实例变量。接口文件以.h为后缀。
例如 Student.h 接口文件
@interface Student : NSObject //NSObject是继承的父类
{
@public //访问修饰符
//以下是实例变量的声明
NSString * name; //姓名
int age; //年龄
NSString * address;//地址
NSString * hobby; //爱好
}
//是方法的声明
-(void) sayHi; //打招呼的方法
-(void) eat; //吃饭的方法
-(void) walk; //走的的方法
实现部分（implementation）：包含了方法的实现，真正意义上定义了类的行为。实现文件以.m为后缀。
注意：
编译器不要求将接口文件和实现文件的代码放在不同的文件中。每一个类用一对接口/实现源文件是一个良好的习惯。一个文件中可以声明和定义多个类。
如果类之间没有什么关系，最好不要把不同的类放在同一个文件书写。
例如 //Student.m 实现文件
#import
@implementation Student
//以下是方法的实现
-(void) sayHi //打招呼的方法
{
NSLog(@”我是来自%@的%@，今年%d岁，喜欢%@”,address,age,name,hobby);
}
-(void) eat //吃饭的方法
{
NSLog(@“%@也得吃饭。”,name);
}
（3）对象的创建和使用
1>对象的创建
内存分配：为对象动态的分配内存地址。
初始化：在内存中填上的初始值。
例如：Student * stu =[[Student alloc] init];
说明：向类发送alloc消息，就是为该类分配一块足够大内存，用于存放实例变量，同时初始化内存，填上的初始值。
2>对象的赋值使用
例如：//main函数
#import “Student.h”
int main (int argc, const char * argv[])
{
@autoreleasepool {
//创建一个学生对象
Student * student = [[Student alloc] init];
student->name = @”孙悟空”;//为姓名赋值
student->age = 500; //为年龄赋值
student->address = @”傲来国花果山”;//为地址赋值
student->hobby =@”游山玩水”;//为爱好赋值
//调用打招呼的方法
[student sayHi];
}
->赋值必须实例变量的修饰符是@public。实例变量的修饰符还有@protected和@private，系统默认实例变量的类型是@protected，对于这两种类型的实例变量，我们需要调用方法为其赋值或者取值。
广义上讲为实例变量赋值的方法成为设置器，取出实例变量的方法成为访问器。
设置器、访问器说明：
1. 设置器命名: set+首字母大写的实例变量名 如：-(void)setAge:(int)newAge
2. 设置器参数不要与实例变量重名。
3. 读取器:与实例变量名同名，并且返回类型与实例类型一致。
缺点：
实例变量越多，编写就越麻烦。

文件系统 :

在类unix中，一切皆文件，无论是文档，u盘，摄像机，音响等
设备，只要连接到类unix系统，在系统本身看来都可以通过操作
文件的方式来操作该设备。而所做的这些操作自然是在终端中了
文件系统是模仿树的结构设计的。
自然界的树只有一个根，树根连带主干是一部分，主干上面还有
可多的分支，分支上又有小分支和树叶。
类unix上的文件系统也是如此，也有一个根目录（目录即文件夹）
根目录下有一些分支目录，分支目录里还有一些小的分支目录，
小的分支目录里面还可能有一些更小的分支目录和文件，所有的
分支目录都可以看成树枝，所有的文件都可以看成是树叶。

pwd 显示当前目录的绝对路径

所谓绝对路径就是从根目录（／）开始的这个路径
相对路径就是相对与当前的这个路径而言

ls 显示当前目录（文件夹）里的一些文件或目录的名字

这些文件或者目录都是可见的。一般目录里还会有隐藏文件或隐藏目录，这些文件和目
录是以.为开头的。若是想要显示所有文件和目录（包括隐藏的文件和隐 藏的目录）。那么要用到 ls -a 还有一个常用的命令是 ls -l 和 ls -al

cd 切换一个目录

cd命令后可加一个相对路径也可以加一个绝对路径。
咱们每创建一个新目录，那么这个目录里面是会默认生成两个新目录，名字分别是.和 ..。
的意义是当前文件，而..是当前目录的上一级目录（或者管它叫当前目录的父目录）

cp 拷贝一个文件或者目录

touch 新创建一个空文件
$ touch 已存在文件的目录
相当于把该文件时间戳更新，文件内容并未改变
$ touch newfile
newfile就是那个新创建的空文件的名字

rm 删除一个文件，或者删除一个目录

删除一个文件就是
$ rm filename
删除一个目录
$ rm －r dirname

tab键 补全功能:

补全文件或文件夹的名字，也可以补全目录下的相关文件

open 在终端以文件夹窗口的形式来打开某个目录或文件，也可以打开应用程序

小技巧：当以文件夹窗口的形式找到文件或者目录后，想要在终端中打开，很方便的
一个操作就是把该文件或者目录拖拽到终端窗口即可获得其绝对路径

vim 编辑器

1）vim 可以打开一个已经存在的文件，这种情况下它是
vim 文件名
如果vim后面跟的名字的文件并不存在，那么vim进文件之后保存
退出就相当于创建了一个新文件。

vim 有3中模式：命令模式 ， 插入模式（编辑模式），可视模式

（1）命令模式，就是我可以键入各种命令（前提是这些命令都是被支持的）
一般输入命令要用 “：命令名字”
：w 表示保存该文件
：q 表示退出该文件
：q！ 表示强制退出并且不保存该文件
：wq 表示保存并且退出该文件
：wq！ 表示保存修改并且强制退出该文件

（2）编辑模式
当处于编辑模式的时候我们可以任意更改该文件内容
（3）可视模式
一般用于修改代码格式要用到，例如代码风格对齐要用到，用法为：
（4）当用vim打开一个文件的时候它会默认进入到命令模式，如果我要修改该文件那么就需要键入“i”键，切换到编辑模式。那么从编辑模式切换到命令模式我们是用ESC键。如果想要通过命令模式切换到可视模式，需要在命令模式下键入 “v”键。想要从可视模式切回命令模式依然是用ESC键。

命令模式下我们经常会用到一些命令

“a”在当前光标位置后插入文本（内容），并且会自动切入到编辑模式
“o”在当前光标所在行的下一行另起一行，并且切入到编辑模式
“O”在当前光标所在行的上一行另起一行,并且切入到了编辑模式
“x”要删除一个字符那么把光标移动到该字符，然后点下‘x’
“dd”其实是连续按两次‘d’键，作用是删除光标所在行整行内容
“4dd”相当于删除从光标所在行往下数4行内容
“yy”是复制光标所在行一整行内容
“4yy” 相当于复制从光标所在行往下数4行内容
“p”如果误删除了某几行那么我们可以用‘p’键把删除的内容再粘回来
具体做就是在光标的下一行位置插入几行的内容
“u”撤消之前的一步操作,若是想撤消之前多步操作就是多点几回‘u’

光标移动

“$”将光标移动到当前行的行尾
“^”将光标移动到当前行的第一个非空白字符位置
“G”将光标定位到最后一行上
“gg”将光标移动到第一行
“:set number”显示行号
“:set nonumber”把已经显示出的行号去掉

简单搜索

“/string”用于搜索一个字串string。
要查找上次查找的字符串的下一个位置使用“n”命令。
vim编辑器的配置文件，该配置文件的名字是唯一的“.vimrc”。
$ vim .vimrc
syntax on
set number
set showmatch
set tabstop=4
set shiftwidth=4
set softtabstop=4
set smartindent
注意：.vimrc这个文件必须是存放在家目录（不一定是/home那个目录，一般新打开一个终端，命令行会默认在某一个目录下，该目录就是家目录）

格言：

在这个世界上，唯一不变的规律是这个世界一直在变。一定要不断提高
自己以适应这个变化的世界。

一 const 修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。

const关键字的作用主要有以下几点：
（1）可以定义const常量，具有不可变性。 例如：
const int Max=100; int Array[Max];
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { ………} 编译器就会知道i是一个常量，不允许修改；
（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如：
void f(const int i) { i=10;//error! }
（5） 为函数重载提供了一个参考。
class A { ……
void f(int i) {……} //一个函数
void f(int i) const {……} //上一个函数的重载 ……
};
（6） 可以节省空间，避免不必要的内存分配。 例如：
#define PI 3.14159 //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ……
double i=Pi; //此时为Pi分配内存，以后不再分配！
double I=PI; //编译期间进行宏替换，分配内存
double j=Pi; //没有内存分配
double J=PI; //再进行宏替换，又一次分配内存！
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

二 外部变量，局部变量以及extern，static关键字

1）外部变量又叫全局变量，管全局变量叫外部变量是因为该变量在函数外部声明
（1）全局变量在声明的时候初始化，那么该全局变量的值为被初始化的那个值全局变量在声明的时候若未初始化，那么系统会自动把它初始化为0.
（2）全局变量的作用域：是从全局变量声明到该文件的结尾
（3）如果在一个全局变量的作用域内的函数里面声明一个局部变量跟全局变量的名字相同，在该函数内全局变量是不可见的，用的只是那个局部变量。也可以说这个相同名字的局部变量在该变量作用域内会屏蔽掉那个全局变量
注意：全局变量是很危险的，因为任何一个函数都有可能改掉该全局变量，而造成不可预期的错误。可以用const这个关键字来修饰一个全局变量而使其成为一个只读变量，这样可以避免全局变量所遇到到一些危险操作。
2）局部变量：auto自动变量，平时在声明一个变量的时候若是不加该关键字，系统默认成自动变量，例如：
int a;
虽然没有加auto关键字，但是系统已经认为他是auto类型的变量。
（1）局部变量的作用域仅限于该变量在某一个代码块内声明到该代码块退出，当然作用域也是变量的生存周期。例如：

三 extern关键字

（1）当前文件用到其他文件中的全局变量
extern int my_global;
（2）使用当前文件里所没有的函数，而使用的函数是在别的文件里定义的，需要声明
该函数是其他文件里的函数，而在当前文件如下声明：
extern char *my_strcpy(char *str1,const char *str2);
4）static关键字,一般管static修饰的变量叫做静态变量，static修饰的函数叫做静态函数。
static代表什么意思呢？
1）如果是static 修饰的是变量，那么它说明该变量只能在当前文件里用，而外部其他
文件则不能通过外部链接来使用该变量。例如：

/file1.c/

static int my_static_variable=12;

/file2.c/
extern int my_static_variable; //这一条语句符合语法要求，因为任何一
个文件都有权利引用外部链接的一个变量
int main(void)
{
printf(“%d\n”,my_static_variable); //这条语句会有错误，因为这两个
文件里找不到对第二个文件可用的
my_static_variable变量.
return 0;
}
file2.c这种声明方式是没有问题的，但在用my_static_variable时却找不到该变量。
因为在file1.c里面我把my_static_variable 变量声明为了静态变量，表示该变量的
作用域只能在file1.c文件生效，其他文件不能在通过外部链接使用该变量。
2）static修饰函数时，表示该函数只在＝当前文件生效，而通过外部链接是找不到的该
函数的，具体的情况描述同1）相同。

四 随机数相关函数和动态内存分配

1）随机数
srand(time(NULL));
sroand以时间设置一个种子
rand（）
rand（）通过一个算法计算得到一个很大的数如果生成的这个随机数在某个范围内，例如：骰子能表达的数是1-6，那我我用随机数产生的数据应该是1-6，按照下面的方法得到
n＝rand()%6+1；
2）动态内存分配
void 修饰函数表示函数没有返回值
void *修饰返回值表示函数的返回值为任意指针类型（char *,int *,double *,struct book *）
void *malloc(size_t size);
char *p;
p=malloc(100);
if(p==NULL)
{
printf(“malloc failed!\n”);
return -1;
}
malloc执行成功的时候，用完这块内存，我们需要手动的释放掉该内存。因为操作系统不会帮我们释放掉在堆空间申请的内存。程序员可以用free（）函数来释放掉我们手动申请的内存。例如把上面的内存释放掉可以用
下述方法：
free(p);