这里每天都会提供一些学习的资料和源代码供爱好者学习，希望给予支持，谢谢！

objective-c语言是c的衍生版本，所以在学objective-c之前必须先要有c的基础，也就是说我们应该把所有的c的课程都充分过一遍，这样对我们学习objective-c是有好处的。

而在学习c的同时，应该过早的学习mac下的系统命令，这样对于我们日后接触mac设备增加熟练度。而学习mac的基本系统命令，需要有mac系统，这里笔者介绍给大家的方案是在自己windows系统下装一个mac os虚拟机，选择系统版本的时候应该选择os10.9以上的版本，因为objective-c的开发工具xcode只有在10.9.3下才能运行，所以说对于广大学习者来说，选择10.9以上的系统应该是有备无患。

装了虚拟机之后就是装Xcode编程开发软件

下载Xcode6.3 bate版本的就可以，百度搜索一下，然后用百度云客户端进行下载

在objective-c学习之前，我们应该学习c语言，所以说下来的学习就是以c为作为导论。
下来就让我们学习c语言吧~

第一讲：进制
10 十进制
0b10 二进制
010 八进制
0x10 十六进制

第二讲：计算机二进制存储
1.原码 反码 补码
正数的反码补码和原码相同
负数的反码是符号位不变 各位都取反
负数的补码是反码加1
8位一字节
int 是4字节

第四讲：流程控制语句
1.if语句：逻辑假设
if（）｛
若干语句
｝
else｛｝
或者：
if（）｛｝
elseif（）
｛｝
2.跳转语句：goto
改变程序的运行顺序：
goto ABC；
语句；
ABC：
3.跳转语句：switch
switch（表达式）｛
case 1:
语句；
case 2:
语句二；
default：
语句；
｝
表达式的值为1就执行语句1.表达式的值为2就执行语句2；如果没有值的话就执行语句三；
但是值之后的每个语句都会执行，所以在这里的是加一个break；
就可以进行选择了。
switch（表达式）｛
case 1:
语句； break；
case 2:
语句二；break；
default：
语句；
｝
4，循环语句：while
while（表达式）｛
语句；
｝
先执行表达式 然后再执行语句，再计算表达式 再执行语句；
5.与break相似的是continue
while(i++<10)
if(i++<10)
{
if(i==5)
continue;
语句；
}
continue意思是到i＝5的时候就直接返回到表达式进行计算；
比如可以和while可以配套使用；
比如：
＃include<stdio.h>
int main()
{
int i = 20;
while(i-->0){
if((i+1)%7=0)
continue;
printf("%sd\n",i+1);
}
return 0;
}
这样就实现了跳过输出7的倍数了；
6.do while语句：
do｛
语句；
｝while（表达式）；
执行语句 然后判定表达式 然后再执行语句 当表达式不成立的时候跳出；
continue和break在do while中运用很广泛；
7.for循环语句：
for（语句1；表达式；语句3）
｛语句2；
｝
执行语句顺序是123 然后23表达式；
continue每次跳转都是表达式；
但是在for语句中，它只跳到循环的语句三；
例如：
＃include<stdio.h>
int main(){
int i;
for(i=1;i<=100;i++)
{
if(i%7=＝0)
continue；
printf（“%d\n”,i）;
}
printf("XXX\n");
return;
}
注意一下：continue之时跳到了i＋＋然后再执行之后的语句；

第五讲：数组
int[20] 而a〔〕为无数个元素；
就是a〔0〕到a〔19〕
〔〕中是个表达式；
例如：
＃include<stdio.h>
int main(void){
int a[20];
int i=0;sum=0
while(i<20){
scanf("%d",&a[i]);
i++;
sum+=a[i]; //sum的值加上a〔i〕；
}
printf("%d",sum);
return 0;
}
注意的是：int a[20];
sizeof(a)=80;
sizeof(int[20])=80;
数组第二节：
2.1数组的初始化：
int a〔10〕=｛1，2，3，4，5，6，7，8，9，10｝；
完全初始化；
而当数组赋值 的元素没有这么多的时候。
int a[10]=〔1，2，3〕
没有被初始化的变量默认为0；
比如：
＃include<stdio.h>
int main(void)
{
int a[10]={1,2,3};
int i=-1;
while(i++<9){
printf("a[%d]==%d\n",i,a[i]);
}
return 0;
}
a[3]到之后的a〔9〕的值都为零；
在这里如果咱们把所有的数组初始化为零的时候；
int a〔10〕=｛｝；
这样每个数组的值都为0；
所以把这样的初始化叫做部分初始化；
2.2数组的赋值：
注意一下这样错的：
int a[5];
a[5]={1,2,3,4,5};
只有在定义的时候直接赋值就ok；
遇到这种情况时，我们会想到一个问题，如果当这些值是未知的时候我们该如何赋值？
这时候就需要我们来用到循环赋值；
比如：
＃include<stdio.h>
int main()
{
int a[10];
for(i=0;i<10;i++){
scanf("%d",&a[i]);
}
for(i=0;i<10;i++)
printf("%d\n",a〔i〕);
return 0;
}
所以对于数组来说我们只能对他的每个数组进行分别赋值；
其实像int a[5];
其实可以打印a〔5〕a[6]这些值；
在计算机存储的时候：
像int a〔5〕;计算机只是记得a〔0〕的地址；其余都不记住；因为这些变量在内存中是紧挨着 所以这些地址只要自加减就可以啦；

第六讲：指针：
首先指针是一个变量；
首先先声明一个指针：
＃include<stdio.h>
int main(void)
{
int *p;
return 0;
}
sizeof(p)=8:占8个字节；也就是在内存里8个数字表示；
int a；
int *p=&a;
表示定义一个指针p指向a；也就是说把a的地址存到p中；
比如一个简单的例子：
＃include<stdio.h>
int main()
{
int a=5;
int *p=&a;
*p=8;//a=8;
printf("%d",a);
return 0;
}
p相当于地址，而＊运算就是取数－也就是说找到地址为p的空间然后取那个数，＊p为四个字节，所以取四个字节；最后值为8；
scanf输入函数里面的&，而当我们输入的时候丢掉的话编译会显示：warning:format '%d'expectd type'int *',but argument 2 has type‘int’
就是说期待着int ＊类型，也就是指针类型；int *p=&a;

上面发布的贴全部是自己学习的心得，独创不喜勿喷～明天继续更新！

指针第二讲：
指针式用来存地址的，也就是说它本身就是一个地址！
*p中p是地址，比如：
int *p=&a;
*p=8;
以上相当于a＝8；
注意：地址是常量，指针是变量。
变量才有地址，因为变量是内存的空间，而常量在内存没有空间，所以常量就没有地址！
指针第二讲：
指针一般都和数组搭配学习！
比如：
＃include<stdio.h>
int main(void)
{
int a[10];
int * p =a;//在这里好多人都比较疑惑，不是说要用&取地址么，为什么这里直接＊p＝a了而不是*p=&a;这是因为数组的名称表示数组的首地址；也就是说数组名是数组的首元素地址！
return 0;
}
需要注意的是指针变量加1，其结果相当于加1个其指向的字节数。
int ＊p＝（int*）5;
比如：
int *p=(int*)5;
p++;
所以根据上面所说的p应该等于9；理由是指针变量加1的话，也就是加了int的字节数，而int的字节数是4，所以5+4=9就是最后的结果。
在比如：
char * p=(char*)5;
q++;
综上所述：p的值应该为6；
比如例子：
＃include<stdio.h>
int main(void)
{
int * p =(int *)5;
char *q =(int *)5;
printf("%d %d\n",p+1,q+1);
return 0;
}
在这里会出现warning，是因为整型向指针看齐！所以最后的结果为指针，在打印p＋1和q＋1的时候，所以就应该用到％p，这个表示地址：所以源程序应该写为：
#include<stdio.h>
int main(void)
{
int * p = (int *)5;
char *q = (char *)5;
printf("%p %p\n",p+1,q+1);
return 0;
}
很显然答案为0x9 0x6；
综上所述：数组的元素都会占用它本来定义的字节数的空间：
比如：
#include<stdio.h>
int main(void)
{
int a[10]={};//初始化数组内的所有成员变量，值都为0；
int * p = a;
printf("%d\n",a[0]);//很显然这个值为0，因为上面语句没有任何的赋值语句，只是作了初始化操作；
* p = 8;
* (p+1) = 9;
printf("%d\n",a[1]);//这个最后的结果是9，原因是＊（p+1）的话就是说把地址往后挪了int个字节，也就是说4个字节，而上面已经说的很清楚了，数组的元素都会占用它本来定义的字节数的空间，所以说加了4个字节之后那就成了a〔1〕的地址，所以直接把9赋值给了a〔1〕；
return 0;
}
上面已经说过：咱们在给数组赋值的时候，都是这样的：
for（i=0;i<10;i++）
{
scanf("%d",&a[i]);
}
所以当用到指针的时候，我们不妨就可以这样一个程序：
#include<stdio.h>
int main(void)
{
int a[10] = {};
int * p = a;
for(i=0;i<10;i++)
{
scanf("%d",p+1);
}
for(int j = 0;j<10;j++)
{
printf("%d ",*(p+j));
}
return 0;
}
在这里要说的是代替*(p+i)的有一个中括号运算符：也就是用p〔i〕代替；
p[i]就相当于*(p+i);
举个例子，在咱们写a〔3〕=9；的时候，就是说＊(&a[0]
+3
)=9,也就是说是*(a+3)=9;
之所以这样写的原因是数组名就是首地址；
比如：
#include<stdio.h>
int main(void)
{
int a[5] = {1,2,3,4,5};
printf("%d\n",a[3]);//*(a+3)
printf("%d\n",3[a]);//*(3+a)
return 0;
}
输出结果都为4；
有些人会说：指针和数组一样了么？
其实不然：
数组的元素是个定值，而p的值为一个变量；
所以说得到这样的结论：指针式地址变量。数组名是地址常量；所以数组不能直接赋值；
比如：
#include<stdio.h>
int main(void)
{
int a[5]={};
int *p=a;
a[1]=5;
*(a+1)=5;
*(p+1)=5;
p[1]=5;//这几个式子赋值是一致的；
return 0;
}

指针第三讲：
const 关键字：用来修饰指针变量；
使用方法有:
1.const char * p:通俗的叫*前const：表示p可以改变，*p不可以改变：也就是说地址可以赋值，*p不可以改变；
比如：
#include<stdio.h>
int main()
{
char a='A'
const char *p=&a;
char b = 'B';
p = &b;//但是不可以写为*p=b;
b='C';
printf("%c\n",b);
printf("%c\n",*p);//正是
正确的
，也就是说我们不可以改变*p的值，但是可以间接改变，通过改变它的地址；
return 0;
}
2.char * const p;也就是*后const，表示*p可以改变，但是p的值不可改变；也就是说内存无法改变；
有一种特例：const char * const q = &a;
这种就是表示说q和*q的值都不可以改变。
当然他有自己的用法，我们在之后的课程里会给大家说明白；

第七讲：函数第一讲：
首先开始的时候：
我想输出这样的一个图形：
*
**
***
****
#include<stdio.h>
int main(void)
{
for(int i=0;i<3;i++)
{
for(int j=0;j<=i;j++)
{
printf("*");
}
printf("\n");
}
return 0;
}
还有一种写法：很诡异；大家来想一想：
#include<stdio.h>
int main(void)
{
for(int i=0;i<3;i++)
{
for(int j=0;j<i;j++)
{
printf("*");
}
printf("*\n");
}
return 0;
}
如果说我们把这个例子执行三遍的话，咱们该怎么写：
这里就用到了函数：因为这样写更为简便：
#include<stdio.h>
int main(void)
｛
for(int i=0;i<3;i++)
func();
return 0；
｝
void func(void)
{
for(int i=0;i<3;i++)
{
for(int j=0;j<=i;j++)
{
printf("*");
}
printf("\n");
}
return;
}
之所以写一个函数，就是把一些繁琐的，反复使用的，重复使用的代码，封装成一个函数，调用函数，就会运行这些代码。
这里用到了封装一词。
在这里有一点就是主函数一定要写在自定义函数之后，如果上面的例子写成这样就错了：

最近又是加班，又要打理吧，真的有点力不从心，但是自己还是会继续努力的～明天继续更新～晚安啦 各位！

果断收藏了
　--请跟我念:康纳康纳康纳康纳康纳√

函数第二讲：参数和返回值：
比如这样一个例子：
＃include<stdio.h>
void func(void){
printf(""hello world);
return;
}
int main(void)
{
func();
return 0;
}
这就是一个简单的返回值函数；返回值有多种多样，这里func函数前是void所以它本身的返回值没有类型，是空的，所以就直接return；即可；而当不是void的时候，会是怎样呢！
＃include<stdio.h>
int func(void){
printf(""hello world);
return 90;//返回值顾名思义就是函数调用表达式的值。
}
int main(void)
{
int ret=func();
printf("%d",ret);
return 0;
}
当然函数值的类型和返回值的类型要一致。是int 那都是int；
当然在这里要说的是每个函数都可以调用其他函数来执行，但是要注意的是函数不能调用主函数，也就是说不能调用main函数；值的一提的是不能调用变量的地址，理由是，变量你不知道它的值不知道它如何存储，也就是说你调用的时候是一个未知数，既然是未知数，当然也就是错的。
看下面的例子：
＃include<stdio.h>
void func(int a)//形参
{
printf("%d\n",a);
return;
}
int main(void)
{
func（5）；//实参 穿参就是把用实参给形参赋值；
return 0;
}
下面再看一个例子：
＃include<stdio.h>
int add(int a,int b)
{
return a+b;
}
int main(void)
{
printf("%d\n",add(3,5));
return 0;
}
答案当然很显然是8；注意看你就会发现在形参中当我们定义了a和b后就再不需要定义这两个数字了，也就是说形参是有意义的；

函数第三讲：普通变量的值传递和地址传递
首先看个例子：
#include<stdio.h>
void func(int a)
{
a++;
return;
}
int main(void)
{
int a＝0;
func(a);
printf("%d\n",a);
return 0;
}
答案为0不是1就是说a的值没有发生改变，所以就是说调用函数不能改变main 函数的值；
而当程序这样写的时候直就会发生变化：
#include<stdio.h>
void func(int a)
{
a++;
printf("%d\n",a);
return;
}
int main(void)
{
int a=0;
func(a);
return 0;
}
~ 答案为1；
这是因为这两个函数相当于都属于不同的栈，传a就是传a的值两个函数是由不同a的。就是说传的方式是不同的；
比如看下面的例子：
#include<stdio.h>
void func(int *p)
{
*p=9;
return;
}
int main(void)
{
int a=0;
func(&a);
printf("%d\n",a);//要修给函数里面的值，必须是传变量的地址
return 0;
}
综上所述：也就说如果你想改变一个变量的值，那就是必须要传这个函数的地址，如果传函数的值的话根本就实现不了：
看如下一个函数，交换a和b的值：
#include<stdio.h>
void swap(int * a, int * b)
{
int tmp = *a;
*a = *b;
*b = tmp;
return;
}
int main(void)
{
int a = 3,b = 4;
swap(&a,&b);
printf("%d %d",a,b);
return 0;
}
答案当然吧这个值做了交换，当然是正确的；上面之所以做到了传数是因为传的是地址；

原谅我今天只写了两节，实在是太累啦，早点休息啦，晚安各位！