IOS开发之路--C语言存储方式和作用域

//
// main.c
// ScopeAndLifeCycle
//
// Created by Kenshin Cui on 14-7-12.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int a=1;
void changeValue(){
  a=2;
  printf("a=%d\n",a);
}
int main(int argc, const char * argv[]) {
  int b=1;
  changeValue(); //结果：a=2
  printf("a=%d,b=%d\n",a,b); //结果：a=2,b=1 ，因为changeValue修改了这个全局变量
  return 0;
}

//
// 2.1.c
// ScopeAndLifeCycle
//
// Created by Kenshin Cui on 14-7-12.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int a=1; //全局变量存储在静态内存中，只初始化一次

void showMessage(){
  static int b=1; //静态变量存储在静态内存中，第二次调用不会再进行初始化
  int c=1;
  ++b;
  a+=2;
  printf("a=%d,b=%d,c=%d\n",a,b,c);
}

int main(int argc, const char * argv[]) {
  showMessage(); //结果：a=3,b=2,c=1
  showMessage(); //结果：a=5,b=3,c=1
  return 0;
}

//
// 1.3.c
// ScopeAndLifeCycle
//
// Created by Kenshin Cui on 14-7-12.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

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

int main(int argc, const char * argv[]) {
  int a=1;
  auto int b=2;
  printf("a=%d,b=%d\n",a,b); //结果：a=1,b=2 ，a和b都是自动变量，auto可以省略
  
  //需要注意的是，上面的自动变量是存储在栈中，其实还可以存储到堆中
  char c[]="hello,world!";
  long len=strlen(c)*sizeof(char)+1;//之所以加1是因为字符串后面默认有一个\0空操作符不计算在长度内
  char *p=NULL;//可以直接写成：char *p;
  p=(char *)malloc(len);//分配指定的字节存放c中字符串，注意由于malloc默认返回“void *”需要转化
  memset(p,0,len);//清空指向内存中的存储内容，因为分配的内存是随机的，如果不清空可能会因为垃圾数据产生不必要的麻烦
  strcpy(p,c);
  printf("p=%s\n",p);//结果：p=hello,world!
  free(p);//释放分配的空间
  p=NULL;//注意让p指向空，否则p将会是一个存储一个无用地址的野指针
  
  
  return 0;
}

//
// 1.3.c
// ScopeAndLifeCycle
//
// Created by Kenshin Cui on 14-7-12.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
  register int a=1;
  printf("a=%d\n",a);
  return 0;
}

//
// 2.1.c
// ScopeAndLifeCycle
//
// Created by Kenshin Cui on 14-7-12.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

//如果在main函数下面定义了一个变量a，如果在main上面不进行声明是无法在main中使用a的；
//同样如果只进行了extern声明不进行定义一样会报错，因为extern并不负责定义变量a而仅仅是声明一个已经定义过的变量；
//当然如果说在main上面定义int a;去掉main下面的定义同样是可以的，相当于在上面定义，但如果两个地方都定义a的话（main上面的extern去掉），则程序认为上面的定义是声明，只是省略了extern关键字；

//第一种情况，在下面定义，不进行声明，报错
int main(int argc, const char * argv[]) {
  
  printf("a=%d\n",a);
  return 0;
}

int a;

//第二种情况，在上面定义，正确
int a;
int main(int argc, const char * argv[]) {
  
  printf("a=%d\n",a);
  return 0;
}


//第三种情况，在下面定义在上面声明，正确
extern int a;
int main(int argc, const char * argv[]) {
  
  printf("a=%d\n",a);
  return 0;
}

int a;


//第四种情况，只在上面声明（编译时没有问题，因为上面的声明骗过了编译器，但运行时报错，因为extern只能声明一个已经定义的变量），错误
extern int a;
int main(int argc, const char * argv[]) {
  
  printf("a=%d\n",a);
  return 0;
}


//第五种情况,上下同时定义（这种方式是正确的，因为上面的定义会被认为是省略了extern的声明），正确
int a;
int main(int argc, const char * argv[]) {
  
  printf("a=%d\n",a);
  return 0;
}
int a;
//其实下面的情况也是不会出错的
int a;
int a;
int main(int argc, const char * argv[]) {
  
  printf("a=%d\n",a);
  return 0;
}
int a;
int a;

//第六种情况,将全局变量声明为局部变量，但是它的实质还是全局变量，正确
int a;
int main(int argc, const char * argv[]) {
  extern int a;
  printf("a=%d\n",a);
  return 0;
}
int a;

//第七种情况，在函数内部重新定义一个变量a,虽然不会报错，但是两个a不是同一个
int a;
int main(int argc, const char * argv[]) {
  int a;
  printf("a=%d\n",a);//注意这里输出的a其实是内部定义的a，和函数外定义的a没有关系
  return 0;
}
int a;