C入门之一

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

2.

#include <stdio.h>

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

return 0;
}

 

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 = 5;

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

void func(void){
static int i = 5;/*局部静态变量*/
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=5;
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 5

 

6.运算符自增自减

#include <stdio.h>
int main()
{
int c;
int a = 10;
c = a++;
printf("先赋值后运算：\n");
printf("Line 1 - c 的值是 %d\n", c );
printf("Line 2 - a 的值是 %d\n", a );
a = 10;
c = a--;
printf("Line 3 - c 的值是 %d\n", c );
printf("Line 4 - a 的值是 %d\n", a );
printf("先运算后赋值：\n");
a = 10;
c = ++a;
printf("Line 5 - c 的值是 %d\n", c );
printf("Line 6 - a 的值是 %d\n", a );
a = 10;
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[6] = {'H', 'e', 'l', 'l', 'o', ''};

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

return 0;
}

 

这段代码运行报错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[50];
char author[50];
char subject[100];
int book_id;
} Book;

int main( )
{
Book book;

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

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

return 0;
}

 

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 标准编译时，则定义为 1

 

13.预处理器运算符

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

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

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

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

 

14.参数化的宏

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

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

 

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

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