C入门之一

1.stdio.h不要写错成studio.h

2.

 #include <stdio.h>

 int main()
 {
 /* 我的第一个 C 程序 */
 printf("Hello, World! \n");

 return ;
 }

printf字符串必须用双引号，不然就报错hello.c:5:9: warning: character constant too long for its type

3.在C语言中，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。
http://blog.csdn.net/gao1440156051/article/details/48035911

4.define和const的区别
http://blog.sina.com.cn/s/blog_79b01f6601018xdg.html

 #define 宏名称 宏值

 const 数据类型 常量名 = 常量值;

(1) 编译器处理方式不同
　　define宏是在预处理阶段展开。
　　const常量是编译运行阶段使用。
(2) 类型和安全检查不同
　　define宏没有类型，不做任何类型检查，仅仅是展开。
　　const常量有具体的类型，在编译阶段会执行类型检查。
(3) 存储方式不同
　　define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。
　　const常量会在内存中分配(可以是堆中也可以是栈中)。

(4)const 可以节省空间，避免不必要的内存分配。 例如：
#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定义的常量在内存中有若干个拷贝。

(5) 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

5.c程序中可用的存储类
-> auto
-> register
-> static
-> extern

static的示例：

 #include <stdio.h>

 /*函数声明*/
 void func(void);
 static int count = ;

 main(){
 while(count--){
 func();
 }
 return ;
 }

 void func(void){
 static int i = ;/*局部静态变量*/
 i++;
 printf("i is %d and count is %d\n", i, count);
 }

extern示例：

 //extern_main.c内容
 #include <stdio.h>

 int count;
 extern void write_extern();

 main(){
 count=;
 write_extern();
 }

 //extern_support.c内容
 #include <stdio.h>

 extern int count;

 void write_extern(void){
 printf("count is %d\n", count);
 }

 //执行
 [root@localhost test]# gcc extern_main.c extern_support.c
 [root@localhost test]# ./a.out
 count is 

6.运算符自增自减

 #include <stdio.h>
 int main()
 {
 int c;
 int a = ;
 c = a++;
 printf("先赋值后运算：\n");
 printf("Line 1 - c 的值是 %d\n", c );
 printf("Line 2 - a 的值是 %d\n", a );
 a = ;
 c = a--;
 printf("Line 3 - c 的值是 %d\n", c );
 printf("Line 4 - a 的值是 %d\n", a );
 printf("先运算后赋值：\n");
 a = ;
 c = ++a;
 printf("Line 5 - c 的值是 %d\n", c );
 printf("Line 6 - a 的值是 %d\n", a );
 a = ;
 c = --a;
 printf("Line 7 - c 的值是 %d\n", c );
 printf("Line 8 - a 的值是 %d\n", a );
 }

 /*
 先赋值后运算：
 Line 1 - c 的值是 10
 Line 2 - a 的值是 11
 Line 3 - c 的值是 10
 Line 4 - a 的值是 9
 先运算后赋值：
 Line 5 - c 的值是 11
 Line 6 - a 的值是 11
 Line 7 - c 的值是 9
 Line 8 - a 的值是 9
 */

7.位异或运算：
a^=b等价于a = a^b，其中^是位异或运算，即将a与b的对应位进行异或运算，同为0或者同为1时，对应位结果为0；否则为1。
比如，假设，a的值为二进制的1010，b的值为二进制的1100，那么a^b = 0110

8.c字符串

 #include <stdio.h>

 int main ()
 {
 char greeting[] = {'H', 'e', 'l', 'l', 'o', ''};

 printf("Greeting message: %s\n", greeting );

 return ;
 }

这段代码运行报错error: empty character constant，原因是单引号要有个空格。empty character constant这个英文的意思就是提示空字符。

9.typedef vs #define
- typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
- typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

 #include <stdio.h>
 #include <string.h>

 typedef struct Books
 {
 char title[];
 char author[];
 char subject[];
 int book_id;
 } Book;

 int main( )
 {
 Book book;

 strcpy( book.title, "C Programming");
 book.book_id = ;

 printf( "Book title : %s\n", book.title);
 printf( "Book book_id : %d\n", book.book_id);

 return ;
 }

10.文件读写

 FILE *fopen( const char * filename, const char * mode );
 int fclose( FILE *fp );
 int fputc( int c, FILE *fp );
 int fputs( const char *s, FILE *fp );
 int fprintf(FILE *fp,const char *format, ...)
 int fgetc( FILE * fp )
 char *fgets( char *buf, int n, FILE *fp )
 int fscanf(FILE *fp, const char *format, ...) 

11.c预处理器

 指令    描述
 #define    定义宏
 #include    包含一个源代码文件
 #undef    取消已定义的宏
 #ifdef    如果宏已经定义，则返回真
 #ifndef    如果宏没有定义，则返回真
 #if    如果给定条件为真，则编译下面代码
 #else    #if 的替代方案
 #elif    如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码
 #endif    结束一个 #if……#else 条件编译块
 #error    当遇到标准错误时，输出错误消息
 #pragma    使用标准化方法，向编译器发布特殊的命令到编译器中

12.预定义宏

 宏    描述
 __DATE__    当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。
 __TIME__    当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。
 __FILE__    这会包含当前文件名，一个字符串常量。
 __LINE__    这会包含当前行号，一个十进制常量。
 __STDC__    当编译器以 ANSI 标准编译时，则定义为 

13.预处理器运算符

 宏延续运算符（\）:
 一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（\）.

 字符串常量化运算符（#）:
 在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。在宏中使用的该运算符有一个特定的参数或参数列表

 标记粘贴运算符（##）:
 宏定义内的标记粘贴运算符（##）会合并两个参数。它允许在宏定义中两个独立的标记被合并为一个标记

 defined() 运算符：
 预处理器 defined 运算符是用在常量表达式中的，用来确定一个标识符是否已经使用 #define 定义过。如果指定的标识符已定义，则值为真（非零）。如果指定的标识符未定义，则值为假（零）。

14.参数化的宏

CPP 一个强大的功能是可以使用参数化的宏来模拟函数。例如，下面的代码是计算一个数的平方：

 int square(int x) {
 return x * x;
 }

我们可以使用宏重写上面的代码，如下：

 #define square(x) ((x) * (x))