C语言基础复习总结
大一学的C++，不过后来一直没用，大多还给老师了，最近看传智李明杰老师的ios课程的C语言入门部分，用了一周，每晚上看大概两小时左右，效果真是顶一学期的课，也许是因为有开发经验吧，废话少说，直接把总结贴出来了~
#include <stdio.h>
int main(int argc, const char * argv[])
{
printf("Hello, World!\n");
return 0;
}
＃include是预处理指令，在编译前把尖括号里的内容原封不动地拷贝到对应位置。.h是头文件，里面是库函数的声明（不是实现）。尖括号表明是系统自带的，会去系统目录找，双引号是自己的文件，会先在源程序当前目录找，找不到就去操作系统的path路径找，还找不到才去C函数库里找。
包含关系允许嵌套包含但是不允许递归包含（死循环）。
C语言语法不严格，main函数可以不写返回值，默认返回int，参数可以不要，可以不return。
C语言程序运行的过程：
1.把源代码翻译成目标代码。Xcode是64位编译器。编译成功后生成同名.obj文件（多个c文件对应多个obj文件）。
2.把C语言源文件之间的调用依赖以及C语言函数库链接进来，成为可执行的机器代码。在xcode下生成的是unix可执行文件。
在java当中方法定义没有顺序限制，但是在标准c当中只能后面的函数调用前面的，因为C是从上往下编译的，如果想放在前面，需要声明，声明可以省略参数名，只要类型：
#include <stdio.h>
int sum(int, int);
int main(int argc, const char * argv[])
{
int c = sum(10,3);
printf("%d\n", c);
return 0;
}
int sum(int a, int b)
{
return a+b;
}
一般来说，会把函数声明和定义放在不同文件当中,比如把sum函数的声明放在test.h里，实现放在test.c里，然后在main函数之前引入：
#include "test.h"
反复引用同一个文件是没关系的，可以使用预编译指令做检查机制。但是不要导入.c文件，以免在链接时出现函数重复而报错，C不是面向对象的，函数名不能重复。
printf输出需要使用百分号占位符，.2f是保留两位小数，不是四舍五入。
// My age is 26, height is 1.55, name is 李明杰，sex is 'A'
printf("My age is %d, height is %.2f, name is %s，sex is ‘%c’\n", 26,1.55f,"李明杰",'A');
scanf是阻塞性的函数，等待标准设备输入，需要传变量的地址。
#include <stdio.h>
int main(int argc, const char * argv[])
{
printf("请输入两个整数，用逗号隔开：");
int a,b;
scanf("%d,%d", &a, &b); //传a的地址
printf("%d\n", a+b);
return 0;
}
C语言的类型分四类，一种是空类型viod，一种是int，float，double，char，一种是构造类型，比如数组，struct，union（基本没用），enum，另一种是指针类型void＊。C是强类型语言，指定类型是为了分配适当大小的空间。Char类型不论多少位的编译器，都占一个字节。
C与java不同，局部变量没有初始化使用也不会报错，但默认值不一定是0，是随机数，所以不要不初始化。全局变量则会被默认初始化。
Char类型范围是－128到127，最好不用ascii码的值，直接用’a’，它不是unicode的，也不支持字符串。
类型修饰符：short,long,signed,unsigned，最常用的是修饰int，被修饰的int可以省略，比如只写long，与java不同，这并不代表这是long类型，而是int。不管什么编译器，int至少2个字节。
C语言里没有boolean，关系判断返回1或0的int值，没有－1！任何非0值都位真，只有0才是假，比如if(9)为真。
C语言可以用逗号连接多个表达式，它的返回值是最后一个表达式的值,下面的代码输出12。
#include <stdio.h>
int main(int argc, const char * argv[])
{
int a=9;
int b=10;
int c;
c = (a=a+1,b=3*4);
printf("%d",c);
}
对于一个变量，变量存储单元的“第一个字节”的地址就是该变量的地址，取地址用&，返回数字，习惯用16进制。
#include <stdio.h>
int main(int argc, const char * argv[])
{
char a = 'A';
int b = 66;
printf("%x\n", &a);
printf("%x", &b);
}
数组用来存放“同一种”类型的变量，不能用变量做长度，应该用常量，但是xcode不会报错。系统为数组分配的空间是连续的。
int ages[5];
printf("%d",sizeof(ages));
得到的长度是20，C语言数组名就代表数组地址，所以ages就是个常量，不能赋值。取数组地址的方法有：
printf("%d\n",&ages[0]);
printf("%d\n",ages);
数组可以初始化，比如
int a[2] = {8, 10};
放在后面的元素可以省略，但是可读性不好，比如
int a[2] = {8, };
如果后面已经定义了全部元素则长度可省略，比如
int a[] = {8, 10};
C语言传参是传值，但是传数组（指针）的话则不是，实际传的是地址，所以内容会被改变。
#include <stdio.h>
//接受数组参数，可以不写长度
void test(int array[])
{
array[0] = 9;
}
int main(int argc, const char * argv[])
{
int a[3];
a[0] = 10;
printf("%d\n",a[0]);
test(a); //数组名代表地址，传的是指针
printf("%d\n",a[0]);
}
二维数组是一维数组的集合，是由一维数组组成的一维数组。它在内存中是按行存储的，比如a[0][0]->a[0][1]->a[0][2]->a[1][0]。
取地址的方式有a，a[0]，&a[0][0]。
初始化可以按行：
int a[2][3] = {{1,2,3},{4,5,6}};
也可以都写出来：
int a[2][3] = {1,2,3,4,5,6};
可以部分省略，默认为0:
int a[2][3] = {{1,,3},{4}};
可以省略行数，不能省略列数:
int a[][3] = {1,2,3,4,5};
C语言没有String类型，多个字符用字符数组存储，为了和普通字符数组区分，字符串数组用’\0’结尾，必须写，否则可能会内存溢出，它是一个ascii码为0的字符，是空操作符，表示什么也不干，所以“mj”的长度是3，不是2。通常用下面第二种初始化：
char s1[] = { 'm','j','\0' };
char s2[] = "mj";
打印的方式：
printf("%s\n", s2);
puts(s2);
放在尾部\0是因为输出过程会从字符串地址开始向后找第一个\0，所以必须要有结尾，没有结尾就会一直找下去，输出错乱的东西。
字符串输入的过程会自动在尾巴加\0，例子：
char s[20];
scanf("%s", s); //s就是地址，不需要&s
printf("%s", s);
但是gets是不安全的，原理同上，会把另一个字符串s2里的内容冲掉，例如：
char s2[] = "mj";
char s1[2];
gets(s1);
printf("%s\n", s1);
printf("%s\n", s2);
字符串本身就是数组，如果要存储多个字符串，则需要使用二维数组，比如char names[15][20]表示可以存15个名字。代码：
char names[2][20] = {{"jay"},{"jim"}};
字符串处理的两个方法：
//输出到控制台
putchar('a');
//等待用户输入
char c;
c = getchar();
字符串处理函数声明在string.h当中。
测量字符串的字符长度：
int len = strlen("李明杰");
printf("%d\n", len);
输出9，strlen返回字符串的字符数，不是长度，中文是3个字符。
字符串拷贝：
char left[10];
strcpy(left, "itcast");
printf("%s", left);
从右边的常量拷贝给左边的变量并且自动加\0。
拼接字符串：
char left[10] = {'m','j','\0'};
strcat(left, "ios");
printf("%s", left);
把右边的字符串，接在左边的后面，会去掉左边的“第一个”\0，但是要保证左边字符串的长度足够，否则会内存溢出。
字符串比较：
int delta = strcmp("abc","ABC");
printf("%d", delta);
返回左边减右边的差，一位一位地比ascii码，\0就是0.
指针变量用来保存一个特定类型的变量的地址，如：
char a;
char *b = &a;
*b = 'a';
printf("%c",a);
b是一个char*类变量指向a的地址，第三行*b当中的*是指针运算符，*b表示访问b的值（a的地址）所对应的存储空间。
指针类型所占用的空间只和编译器有关。
其中第二句可以拆分成两句：
char *b;
b = &a;
第二句不能写*b，*是访问符。
指针操作的两个错误：
//错误1：不要直接使用未分配的指针
char *p;
*p=10;
//错误2：不要给指针变量直接赋地址
p = 100;
交换a和b的例子：
void swap(int *v1, int *v2)
{
int temp = *v1;
*v1 = *v2;
*v2 = temp;
}
int main(int argc, const char * argv[])
{
int a = 10;
int b = 9;
swap(&a,&b);
printf("%d %d\n",a,b);
}
因为默认会传临时变量，所以要传地址，参数表用指针类型，调用的时候就要传地址进去。交换的时候也要用星号来取指针变量里的地址对应的值。
用指针可以实现函数多返回值，类似c#的out参数。比如：
int sumAndMinus(int v1, int v2, int *p) {
*p = v1 - v2;
return v1 + v2;
}
int main(int argc, const char * argv[])
{
int a = 10;
int b = 4;
int sum;
int minus;
sum = sumAndMinus(a,b,&minus);
printf("%d %d",sum,minus);
}
数组的名字就是它的地址，所以把指针指向数组的时候，后面两行代码是等价的：
int a[2];
int *p;
p = &a[0];
p = a;
可以用指针遍历数组，如下：
int a[3] = {1,2,3};
int *p = a;
for (int i=0; i<3; i++) {
printf("a[%d]=%d\n",i,*(p+i));
}
对于指针变量来说，p+i当中的i要看p指向的类型，比如指向一个两个字节的类型，i就是两个字节，不是纯粹加一个数字。上面的做法不会改变p所指向的内容，但是如果写*(p++)则会改。
另外，既然数组名就是p所指的，所以*(a+i)也可以，但是*(a++)不可以，数组的首地址是常量不能改。
像下面这样也可以，只是p最终位置改变了：
int *p = a;
for (int i=0; p < a + 3; i++, p++) {
printf("a[%d]=%d\n",i,*p);
}
如果参数表是数组，那么传数组名或指针都可以：
void change(char c[]) {
c[0] = 1;
}
int main(int argc, const char * argv[])
{
char a[3];
change(a);
}
如果参数表是指针，那么也可以传指针：
void change(char *c) {
*c = 1;
}
int main(int argc, const char * argv[])
{
char a[3];
change(a);
printf("%d\n", a[0]);
}
总之，如果形参是数组或指针，则可以传递数组名或指针。
对于一个字符串，遍历的方式有：
char s[7] = "itcast";
for (int i=0; s[i]!='\0'; i++) {
printf("%c\n", s[i]);
}
比较好理解的方法是：
char *p = "itcast";
for (; *p!='\0'; p++) {
printf("%c\n", *p);
}
第一种方式利用数组定义的是字符串变量，但是第二种方式用指针定义的是字符串常量，所以，第二种方法一旦用下面的方式来改写就错了：
char *p = "lmj";
*p = 'f';
总之，char a[] = “lmj”是变量，char *p = “lmj”是常量，严格来说前面应该加上const。
一个函数可以返回一个指针，比如：
char * test() {
return "itcast";
}
函数的名称就代表函数的地址，可以定义指向函数的指针，比如：
#include <stdio.h>
int sum(int a, int b) {
return a+b;
}
int main(int argc, const char * argv[])
{
//定义一个特定返回值和参数表的指针p
//需要占位的是函数名，并且指向sum函数
int (*p)(int, int);
p = sum;
//利用指针变量p取出所指的函数，间接调用
int result = (*p)(1,2);
//也可以直接调用
int result2 = p(5,6);
printf("%d %d", result,result2);
}
可以把函数指针当做参数来使用，类似c#当中传递lambda表达式：
#include <stdio.h>
int calculate(int a, int b, int (*p)(int,int)) {
return p(a,b);
}
int sum(int a,int b){
return a+b;
}
int main(int argc, const char * argv[])
{
int result = calculate(1,2, sum);
printf("%d", result);
}
预处理指令以#开头，是在编译之前执行的，三种常用的预处理指令分别是宏定义、文件包含和条件编译。
宏定义的功能是字符串替换，通常用来定义常量：
#define NUM 6
int main(int argc, const char * argv[])
{
int a[NUM] = {1,2,3,4,5,6};
}
也可以使用带有参数的宏定义：
#define mul(a,b) ((a)*(b))
int main(int argc, const char * argv[])
{
int a = mul(1,2);
printf("%d",a);
}
定义带有参数的宏最好把参数带上括号，因为它的实质是字符串替换。最外层最好也加一个括号，因为宏替换之后，它的整体还会和其他代码进行数学运算。
宏定义没有内存检测，纯粹是字符串替换，所以一些简单的计算，执行起来性能比函数要好。
条件编译指，某段代码，只让它在满足某种条件时才编译。
#include <stdio.h>
#define NUM 10
int main(int argc, const char * argv[])
{
#if NUM > 0
printf("NUM大于0");
#elif NUM == 0
printf("NUM等于0");
#else
printf("NUM小于0");
#endif
return 0;
}
注意预处理指令里的宏NUM只能用预处理指令里定义的。
另外，可以根据有没有定义过宏来判断：
#define NUM 10
int main(int argc, const char * argv[])
{
#ifdef NUM
printf("定义了");
#endif
#ifndef NUM
pringf("没定义");
#endif
return 0;
}
C的变量有不同的存储类型、生命周期和作用域。
局部变量只在函数内有效。全局变量被其他函数共享，从定义的位置到源代码结尾有效。
存储类型：有三个地方可以存变量：运行时堆栈、普通内存和硬件寄存器，它决定了变量的生命周期。
三个地方分别对应自动变量、静态变量和寄存器变量。
被关键字auto修饰的“局部”变量是自动变量，默认所有局部变量都是自动变量，基本不写auto。当执行到自动变量所在的函数时，自动变量会创建，离开函数时会销毁。
静态变量会在程序运行时创建，在程序结束后销毁。所有全局变量都是静态变量。另外有一种被static修饰的局部变量也是静态变量，这种修饰改变了它的生命周期，但是没改变作用域，它的创建时间也是在函数调用的时候。函数内的static变量可以在函数内部进行计数。
存储在硬件寄存器内的变量叫寄存器变量，它被register修饰，性能最高。只有自动变量才能存储在寄存器中，只限存储int、char和指针类型。如果寄存器已满，在运行时会自动转化为自动变量处理。寄存器变量通常是一些频繁使用的变量。寄存器变量的生命周期和自动变量一致。
允许被其他源文件调用的函数是外部函数，函数默认是外部函数，不允许有同名的外部函数，否则会有链接错误。
定义或者提前声明一个外部函数需要用extern，但是默认就是外部的，所以这个关键字一般不写。在C99标准当中，如果一个源文件里没有提前声明外部函数会报编译错误，但是xcode里不会出错。
不允许其他文件访问的函数是内部函数，不同源文件里允许有同名的内部函数。C的static和java中完全不一样，内部函数需要用static关键字修饰，这样在链接的时候其他源文件就无法找到这个static函数了。在同一个源文件中，声明一个static函数也需要加这个关键字。
C语言中一个函数不能使用在函数后面声明的变量，除非在函数前面声明，声明变量的关键字是extern，这个extern其实又可以省略：
extern int a;
int main(int argc, const char * argv[])
{
a = 10;
return 0;
}
int a;
在一个函数内，如果用extern声明了一个变量，那么它使用的还是外部的变量，extern本来就是外部的意思，证明：
#include <stdio.h>
void test();
int main(int argc, const char * argv[])
{
extern int a;
a=10;
test();
}
int a;
void test()
{
printf("%d", a);
}
在C语言中在不同的源文件当中存在同名的全局变量，则这些变量都代表同一个变量。允许被其他文件访问的变量叫外部变量，默认情况下定义的变量都是外部变量。想使用其他文件里的外部变量，需要在前面声明（extern可省）。注意，extern后面的变量，一定是声明，而不是定义！
用static修饰的全局变量叫做内部变量，外部访问不到这个变量（外部的extern声明语句无法看到内部的static变量）。如果说两个文件中的同名变量有一个或者都加了static，则它们不是一个变量。
结构体可以定义在方法内部或外部，如果在内部，则只能在函数内使用这个结构体：
void main(int argc, const char * argv[])
{
//定义结构体类型
struct Student {
int age;
char *name;
float height;
};
//定义结构体变量
struct Student stu = { 27, "mj", 180.3};
printf("%d", stu.age);
}
也可以同时定义结构体并定义变量赋值，在这种情况下结构体的名字可以省略，因为没有意义，类似java的匿名方法：
struct {
int age;
char *name;
float height;
} stu = { 27, "mj", 1.8f};
结构体内可以包含别的结构体，但是不允许包含自己导致递归。需要注意的是，结构体的定义和初始化要写成一句，如果拆成两句会报错。
可以定义指针指向结构体，通过指针有两种方式取结构体内的值：
struct Student stu = { 27, "mj", 180.3};
struct Student *p = &stu;
int a =(*p).age;
int b = p->age;
把结构体当做参数传给函数，传的是值，不是地址,传地址需要指针：
struct Student {
int age;
};
void change(struct Student* stu) {
stu->age = 1;
}
void main(int argc, const char * argv[])
{
struct Student stu = { 27, "mj", 180.3};
struct Student *p = &stu;
change(p);
printf("%d", stu.age);
}
C会把枚举当做整形常量，从0开始，定义枚举：
enum Season { spring, summer, autumn, winter };
enum Season s = spring;
也可以同时定义枚举变量并赋值，和结构体一样，枚举的名称也可以省略。
typedef关键字的作用是给数据类型定义一个别名，比如：
typedef int Integer;
typedef char* String;
void main(int argc, const char * argv[])
{
Integer a = 10;
String name = "itcast";
}
可以给结构体起别名，这样定义变量的时候就能省略struct关键字了，这时建议用匿名的，因为没用：
void main(int argc, const char * argv[])
{
typedef struct {
float x;
float y;
} CGPoint;
CGPoint p = {10, 10};
}
例子：给指向结构体的指针重命名，此时也可以匿名：
typedef struct Point{
float x;
float y;
} * PPoint;
struct Point point = {10,10};
PPoint pp = &point;
事实上最常用的定义结构体和枚举的方式是这样，表意非常明确——给一个匿名的结构体命名：
typedef struct {
float x;
float y;
} Point;
还可以给一个指向函数的指针一个别名：
int sum(int a, int b){
return a+b;
}
void main(int argc, const char * argv[])
{
typedef int (*SumPoint)(int,int);
SumPoint p = sum;
p(1,2);
}
在这里SumPoint就是别名，不用在后面再起别名。
不建议用宏定义来其别名，它纯粹是字符串替换，如果连续声明了两个变量就会有问题了。