---------------------- Java培训、.Net培训、Android培训、IOS培训、期待与您交流！ ----------------------
1. C语言关键字
a. C语言关键字的定义和特征:
关键字就是C语言提供的有特殊含义的符号，也叫做“保留字”,一般在编译器中都会给关键字着色，而且都是小写.
b. C语言的关键字:
auto double int struct break else long switch
case enum register typedef char extern return union
const float short unsigned continue for signed void
default goto sizeof volatile do if while static
2. 标示符
a. 什么是标示符:
标示符是为了与关键字区分开，一些有程序员定义的符号和名称。
b. 标示符的作用:
(1) 区分作用 : 标示符为了区分某些东西而定义的一些字符
(2) 提高可读性 : 一般标示符用于 函数名称 和 变量名称 的定义,为了提高可读性,一般都会起一些有意义的名称
c. 命名规范:
(1) 一般由 26个大小写字母，数字，下划线组成
(2) 严格区分大小写(比如:Foo 和 foo 是两个不同的标示符)
(3) 不能以数字开头
(4) 不能使用关键字命名
(5) 尽量起一些有意义的名字
(6) 如果表示符含有两个不同的英文单词要使用驼峰标识(比如:getName,getAge ...)
3.注释
a. 什么是注释 :
注解,解析。一般程序员都会给某段代码或者某个变量添加注释,这样做可以方便程序员之间的交流和提高代码的可读性，注释中可以包含任何语言，注释中的内容不参与编译。
b. 注释分类:
(1) 单行注释 : // 这是单行注释
(2) 多行注释 :
/*
这是
多行注释
*/
4. 数据类型:
a. 什么是数据:
数据是应用的灵魂,应用生产的目的是为了帮助我们更方便地管理数据，因此数据是我们使用计算机过程中经常看到的 字符数据，图片数据，视频数据 等待。
b. 数据类型 :
(1) 静态数据 :
一般持久化在硬盘中
更改需要用户手动操作
读取效率低
(2) 动态数据 :
在程序运行过程中动态创建的数据,一般存储在内存中
随着计算机的关闭内存中的数据会消失
读取效率高
(3) 动态数据和静态数据之间的转化
一般程序员比较关心的是动态数据
静态数据会加载到内存中变成动态数据，然后经过用户的操作在持久化到硬盘中,这个过程构成了静态和动态数据之间的转化
(4) 数据的大小单位
数据都是由0和1组成的(一个0或者一个1表示1位)
数据大小单位都是以字节为单位(1 byte = 8 bit)
(5) 常用的数据单位和转换:
1 KB = 1024 B，1 MB = 1024 KB，1 GB = 1024 MB，1 TB = 1024 GB
5. C语言的基本数据类型:
a. 分类 和大小(xcode编译器中的大小) :
(1) 基本数据类型 :
| 类型 | 关键字 | 大小 |
| 整型 | int | 4 byte |
| 浮点型 | float | 4 byte |
| double | 8 byte | |
| 字符型 | char | 1 byte |
(2) 空类型(void) : sizeof(void) = 1byte
(3) 指针类型 (void *) ： 在64位编译器中 : sizeof (void *) = 8 byte
(4) 构造体类型 :
注 : 对于构造体的内存分配,为了存取效率高,构造体的内存分配会依据占用内存最大的基本数据类型的最大的为单位
| 类型 | 关键字 | 大小 |
| 数组 | [] | 数组长度*数组类型大小 |
| 结构体 | struct | 占用内存最大的成员大小*成员数量 |
| 共用体 | union | 占用内存最大的成员大小 |
| 枚举 | enum | 4 byte |
6. 常量
a. 常量定义 :
表示一些固定的常量.
b.分类 :
(1) 整型常量(int 类型) :
整数范围内 : 如 10 ， 11 100 等等
(2) 浮点型常量(float/double) :
一般都为double类型的常量 : 10.5 , 11.7 等等
int size = sizeof (10.5);
printf("%d",size); // 输出为8,double类型大小为8
float类型常量表示: 10.5f , 11.5f ...
int size = sizeof (10.5f);
printf("%d",size); // 输出为4,float类型大小为4
(3) 字符串常量 :
一般表示方法 ; char *str = "hello world";
字符串常量一般以'\0'结尾,代表字符串结束标志
c. 常量存放地方:
(1) 一般常量存放在常量区: 每一个常量在内存中只有一份
int *a = 1;
int *b = 1;
printf("%d", a == b); // 打印结果为1,代表一个常量在内存只有一份,它们可以被多个变量引用
char *s1 = "abc";
char *s2 = "abc";
printf("%d", s1 == s2); // 打印结果为1
7. 变量
a. 变量 :
当一些数据经常改变就需要变量来存储了 (int a = 10;)
b. 变量的生命周期 和 变量的作用域:
| 变量类型 | 生命周期 | 作用域 |
| 全局变量 | 程序退出时候回收 | 默认全局有效,对于static策略则文件内有效 |
| 局部变量 | 大括号 {} 结束时候被回收 | 大括号 {} 内有效 |
c. 变量内存寻址方式 :
一般变量内存寻址方式为从大到小寻址 (分配类存地址从大到小分配)
// 如果 a 的地址减去 b 的地址则证明寻址方式是从大到小
int a = 1;
int b = 1;
printf("a 的地址:%p\n", &a); // a 的地址:0x7fff5fbff94c
printf("b 的地址:%p\n", &b); // b 的地址:0x7fff5fbff948d. 变量与常量区别 :
(1) 变量存储可以有多份,而常量只有一份
(2) 变量存储数据是独立的,而常量是共享的。
8. scanf函数介绍
a. 简介 :
stdio.h中声明的一个函数，因此使用前必须加入#include <stdio.h>。调用scanf函数时，需要传入变量的地址作为参数，scanf函数会等待标准输入设备（比如键盘）输入数据，并且将输入的数据赋值给地址对应的变量
b. 用法 :
// 逗号,
scanf("%d,%d,%d", &a, &b, &c); // 输入格式：10,14,20
// 井号#
scanf("%d#%d#%d", &a, &b, &c); // 输入格式：10#14#20
// 字母x
scanf("%dx%dx%d", &a, &b, &c); // 输入格式：10x14x20c. 注意点 :
（1）
scanf("%d %d %d", &a, &b, &c); // 3个%d之间是用空格隔开的，我们在每输入一个整数后必须输入一个分隔符，分隔符可以是空格、tab、回车
scanf(“%d\n”, &a); // scanf的第一个参数中不要包含\n,这将导致scanf函数无法结束 (2)
int main()
{
// 定义一个指针用来接收用户输入
char src[100];
// 用来标志是否要退出循环
char flag ;
// 开启循环与用户交互
while ( 1 ) {
printf("请输入一个字符,按0退出,按其他字符进入英文句子转化:");
// 由于gets函数已经清空了回车了,因此在输入前不需要再次清理缓冲区
flag = getchar();
// 由于 上面getchar 会把回车落在缓冲区,影响下面gets函数使用因此要清理此回车
getchar();
if ( flag != '0' ) {
printf("请输一段英文句子:\n");
// scanf函数遇到回车空格TAB键就会停止读取缓冲区数据,因此要使用gets函数来替代
//scanf("%s",src);
// gets函数输入后会舍弃缓冲区里面的回车因此不需要清空缓冲区
//gets(src);
// gets()函数接收的输入大小不受限制，如果超出范围则溢出到其他内存中,非常危险
// warning: this program uses gets(), which is unsafe.
// fgets则不会溢出,它还可以接收刷掉最后那个回车,但接收一个回车对测试影响也不大吧
fgets(src, sizeof(char)*100, stdin);
printf("英文句子: &s\n",src);
} else {
// 如果输入为0则终止循环
break;
}
}9. 流程控制
a. 简介 ：
开发中业务逻辑非常复杂,为了实现不同情况下的不同需求,C语言提供了一系列流程控制结构，因此掌握流程控制是开发中的必经之路。常用的流程控制结构有以下几种:
顺序结构：默认的流程结构。按照书写顺序执行每一条语句。
选择结构：对给定的条件进行判断，再根据判断结果来决定执行哪一段代码。
循环结构：在给定条件成立的情况下，反复执行某一段代码。
b. 选择结构 - if
(1) 如何使用 :
1) if ( 表达式 ) { 语句; } ，一般表达式返回值是0，为假,否则为真。
2) if ( 表达式 ) { 语句1; } else { 语句2; }
3) if ( 表达式 ) { 语句1; } else if ( 表达式 ) { 语句2; } else { 语句3; }
(2) 示例代码 :
// 1) 简单判断 : if ( 表达式 ) { 语句; }
int a = 1;
if ( a >0 ){
printf("a = %d >0",a);
}
// 2) if ( 表达式 ) { 语句1; } else { 语句2; }
int a = 1;
if ( a > 0 ){
printf("a > 0");
} else {
printf("a <= 0");
}
// 3) if ( 表达式 ) { 语句1; } else if ( 表达式 ) { 语句2; } else { 语句3; }
int a = 1;
if ( a > 0 ){
printf("a > 0");
} else if ( a ==0 ){
printf("a == 0");
} else {
printf("a < 0");
}
// 复合条件使用 :
int a = 1;
if ( a >0 || a ==0 ){
printf("a >= 0");
} else {
printf("a < 0");
}
// 对于非0值或者非空值都代表为真
int a = 1;
if ( a ){
printf("a 为非 0");
} else {
printf("a 为 0");
}
// char* str = "abc";
char *str = NULL;
if ( *str ){
printf("非空字符");
} else {
printf("空字符");
}c. 选择结构 - switch
(1) 如何使用 :
switch(表达式) { case 数值1: break; … default: break;}
(2) 示例代码 :
// case作用 : 比较 a的值与给定的值是否相等，如果相等则执行case一下的语句
// break作用 : 跳出判断结构
int a = 10;
switch (a) {
case 0:
printf("这是一个0");
break;
case 5:
printf("这是一个5");
break;
case 10:
printf("这是一个10");
break;
default:
printf("什么也不是");
break;
}d. 循环结构-while , for
(1) 如何使用 :
while(表达式) { 语句1; } // while (1) { 死循环; }
do { 语句1; } while(表达式);
for ( 表达式1; 条件 ; 表达式2 ) { 循环体; } // 死循环 for(;;);
(2) 示例代码 :
// while(表达式) { 语句1; }
int i = 1;
while( i < 100 ){
printf("%d\n",i);
i++;
}
// do { 语句1; } while(表达式);
int i = 1;
do {
printf("%d\n",i);
i++;
} while (i < 100 );
// for ( 表达式1; 条件 ; 表达式2 ) { 循环体; }
for( int i = 1 ; 1 < 100 ; i++){
printf("%d\n",i);
} (3) for 和 while 比较 :
可以互换,但for可以对变量进行及时回收。
10. 函数
a. 函数简介:
任何程序代码段都有她们指定功能，因此我们可以用特定的名称对他们功能进行描述,这样结合起来代码段我们称它们为程序函数。
好处 :
方便代码重用;
提高代码可读性；
定义格式 :
返回值类型 函数名(形式参数列表)
{
函数体
}
b. 使用示例 :
// 函数声明
int sum (int,int);
int main(){
// 函数调用
int sum = sum (1,1);
return 0;
}
// 函数定义
int sum (int a,int b){
return a + b;
} c. 总结
(1) 参数名不能跟函数内的局部变量同名
(2) void可以省略return
(3) 可以多次使用return
(4) return后面不能有其他语句
(5) 函数的弱语法
1) 如果没有写返回值类型，默认是int
2) 如果写了返回值，可以不返回
3) 调用一个没有定义过的函数
(6) .h文件写函数的声明
(7) .c文件写函数的定义
(8) 要想别人的函数，请包含对应的.h文件
11. 预处理指令
a. 简介
编译器特性,指的是在编译之前进行一些处理。预处理指令都是以#开头
主要有以下三方面内容 : (1) 宏定义 (2) 文件包含 (3) 条件编译
b. 宏定义
宏定义作用简单来说就是文本替换。宏名的书写习惯一般都是大写以便跟变量区分开。
(1) 不带参数的宏定义 :
#define 宏名 字符串
#define PI 3.14
// 计算圆的周长
int main (){
int r = 2;
float rith = 2 * PI * r; // 在编译之前PI会替换为3.14
printf("半径为 : %d 的圆周长为 : %f",r ,rith);
return 0;
} (2) 带参数的宏 :
#define 宏名 ( 参数列表 ) 字符串
为了增加代码的健壮性 带参数的宏定义一般这样写 :
#define 宏名 (参数1,参数2) ( (参数1)..(参数2) )
#define SUM ( a , b ) ( ( a ) + ( b ) )
int main () {
int sum = SUM( 1 , 1 ) * 2;
printf("( 1 + 1 ) * 2 = %d",sum);
return 0;
} (3) 取消宏定义
#undef 宏名
#define PI 3.14；
int main(){
// 正确写法
float pi = PI;
#undef PI
// 宏定义在上一行已经失效了,因此以下代码不能在使用该宏名
// float pi1 = PI;
return 0;
} (4) 函数 与 宏 的去区别 :
1) 宏定义是在编译前完成的，因此不设计存储空间的分配，参数类型匹配，参数传递，返回值问题
2) 函数调用在程序运行时候执行, 而宏替换只在编译处理阶段进行，所以带参数的宏比函数具有更高的执行效率。
c. 条件编译
(1) 简介
在很多情况下，我们希望程序的其中一部分代码只有在满足一定条件时才进行编译，否则不参与编译(只有参与编译的代码最终才能被执行)，这就是条件编译。
#if 条件1
...code1...
#elif 条件2
...code2...
#else
...code3...
#endif 1> 如果条件1成立，那么编译器就会把#if 与 #elif之间的code1代码编译进去（注意：是编译进去，不是执行，很平时用的if-else是不一样的）
2> 如果条件1不成立、条件2成立，那么编译器就会把#elif 与 #else之间的code2代码编译进去
3> 如果条件1、2都不成立，那么编译器就会把#else 与 #endif之间的code3编译进去
4> 注意，条件编译结束后，要在最后面加一个#endif，不然后果很严重(自己思考一下后果)
5> #if 和 #elif后面的条件一般是判断宏定义而不是判断变量，因为条件编译是在编译之前做的判断，宏定义也是编译之前定义的，而变量是在运行时才产生的、才有使用的意义
例子 :
#define A = 10;
int main (){
#if A > 10
printf("A > 10");
#elif A == 10
printf("A == 10"); // 程序运行结果
#else
printf("A < 10");
#endif
return 0;
} (2) #if defined() 和 #if !defined()
a. #if 后面可以用来判断某个宏是否被定义过, 比如 :
#if defined( A )
语句; // 如果 宏A 被定义过了，这一行不会被编译
#endif
// 判断条件也可以取反
#if !defined( A )
语句; // 如果 宏A 没有被定义过，这一行就会被编译
#endif b. #ifdef 和 #ifndef
#ifdef 和 #if defined() 的用法一样
#ifndef 和 #if !defined()的用法一样
#ifdef A // == #if defined()
语句; // 如果 宏A 被定义过这这一行就不会被编译
#endif #ifndef A // == #if !defined()
语句; // 如果 宏A 没有被定义过，这一行就会被编译
#endif d. 文件包含 #include
(1) 简介
文件包含使用频率比较高,它可以将一个文件的全部内容拷贝到另外一个文件中
(2) #include <文件名>
直接根据文件名到C语言函数库偷文件所在的目录寻找
(3) #include "文件名"
系统会先在当前目录下寻找如果找不到，在到系统的path路径中查找，最后才到C语言函数头文件所在目录查找
(4) 重复包含问题 :
文件包含的作用简单来说是存文本复制，但很容易会发生重复包含问题 :
// 文件 a.h
void test(); // 声明了一个函数 // 文件 b.h
#include "a.h"
void test2(); // 声明函数 // 文件 main.m
#include "a.h"
#include "b.h"
/*
编译预处理之后会变成这样子 :
void test();
void test();
void test2();
这样test函数会被声明两次,降低编译效率
*/
int main(){
..code..;
return 0;
} 利用条件编译来解决重复包含问题 :
// a.h
#ifndef _A_H_
#define _A_H_
void test();
#endif // b.h
#ifndef _B_H_
#define _B_H_
#include "a.h"
void test2();
#endif // 文件 main.m
#include "a.h"
#include "b.h"
/*
编译预处理之后会变成这样子 :
#ifndef _A_H_
#define _A_H_
void test();
#endif
#ifndef _B_H_
#define _B_H_
#include "a.h"
void test2();
#endif
由条件编译的作用来看这样就不会导致文件的重复包含问题
*/
int main(){
..code..;
return 0;
}12. extern , static 和 函数
首先了解,外部函数和内部函数概念:
外部函数 : 如果在当前文件中定义的函数允许其他文件访问、调用，就称为外部函数。C语言规定，不允许有同名的外部函数。
内部函数 : 如果在当前文件中定义的函数不允许其他文件访问、调用，只能在内部使用，就称为内部函数。C语言规定不同的源文件可以有同名的内部函数，并且互不干扰。
a. extern 和 函数 :
// a.h
#ifndef _A_H_
#define _A_H_
extern void test(); // 函数默认都是extern ,因此这个函数声明相当于 : void test();
#endif
// a.c
void test()
{
printf("调用了test");
} // main.c
#include "a.h"
int main(){
test(); // 由于 a.c 中函数声明为extern 因此次函数调用成功
return 0;
} b. static 和 函数
// a.h
#ifndef _A_H_
#define _A_H_
void test();
#endif
// a.c
static void test() // 把test函数声明为文件内部访问
{
printf("调用了test");
} // main.c
#include "a.h"
/*
由于 a.c 中函数声明为static
编译是检查语法的,因此编译可以通过
而链接的时候把多个文件合成一个可执行文件这时候就会出错,因为 a.c 把 test 函数声明为文件内部访问
*/
int main(){
test();
return 0;
} c. 总结 :
a. static
(1) 在定义函数时，在函数的最左边加上static可以把该函数声明为内部函数(又叫静态函数)，这样该函数就只能在其定义所在的文件中使用。如果在不同的文件中有同名的内部函数，则互不干扰。
(2) static也可以用来声明一个内部函数
b. extern
(1) 在定义函数时，如果在函数的最左边加上关键字extern，则表示此函数是外部函数，可供其他文件调用。C语言规定，如果在定义函数时省略extern，则隐含为外部函数
(2) 在一个文件中要调用其他文件中的外部函数，则需要在当前文件中用extern声明该外部函数，然后就可以使用，这里的extern也可以省略。
13. extern , static 和 变量
在12中我们已经了解了 extern , static 对函数的作用了,那么这两个关键字对变量的作用是不是一样呢?答案是否
a. extern 对于变量的作用 ----声明一个全局变量
/*
这种情况编译器是不会报错的,
而且一下所有a都是同一个变量
*/
int a;
int main(){
a = 5;
return 0;
}
int a;
//
/*
这种情况编译器是不会报错的,
而且一下所有a都是同一个变量
*/
int a;
int a;
int a;
int main(){
a = 5;
return 0;
}
int a;
int a;
int a;
//
/*
还有一点要注意的是，可以将全局变量声明为局部变量后使用
而且一下所有a都是同一个变量
*/
int a;
int main(){
extern int a; // 声明一个全局变量,如果把extern 去掉的话
a = 5; // 这两行的a就是一个局部变量了
return 0;
}
int a;
//
/*
对于多文件中都存在相同的全局变量,
如果这些文件都要一块合成目标文件的话,这些变量都代表同一个变量
但对于多个文件用extern 声明同一个全局变量,一定至少有一个文件把这个局部变量定义好,否则没人去定义编译器会报错
*/
// a.c
int a; // 或者是extern int a
void test(){
printf("a = %d\n",a);
}
// main.c
#include "a.h"
int a; // 或者是extern int a ,但至少有一个文件把这个变量定义出来
int main(){
a = 10;
test(); // 打印结果 : a = 10
return 0;
}
b. static 对函数的作用 -----声明和定义一个文件私有的全局变量
/*
由于a.c中的a变量为私有的
那么main.c中的变量a没有权限访问a.c中的变量a
因此打印结果为0
*/
// a.c
static int a; // 全局变量初始值都为0
void test(){
printf("a = %d\n",a);
}
// main.c
#include "a.c"
int a; // 如果把 此句改为 : extern int a; 那么编译会报错因为在这个文件中没有找到a的定义不能对a进行赋值
// 如果不想报错在这个文件中的任何一处地方把a定义出来
int main(){
a = 10;
test(); // 打印结果为0
return 0;
}c. 总结
(1) extern可以用来声明一个全局变量，但是不能用来定义变量
(2) 默认情况下，一个全局变量是可以供多个源文件共享的，也就说，多个源文件中同名的全局变量都代表着同一个变量
(3) 如果在定义全局变量的时候加上static关键字，此时static的作用在于限制该全局变量的作用域，只能在定义该全局变量的文件中才能使用，跟其他源文件中的同名变量互不干扰
13. typedef
a. 简介
typedef可以为各种数据类型定义一个新的名称(别名)。
#include <stdio.h>
typedef char * String;
int main(){
String str = "hello";
printf("%s",str);
return 0;
} b. typedef 和 #define 区别 :
typedef 示例代码:
// a.c
/*
编译运行成功
*/
#include <stdio.h>
typedef char * String;
int main(){
String str = "hello";
String s1,s2; // 相当于 : char * s1; char *s2;
s1 = "hello";
s2 = "world";
printf("%s %s\n",s1,s2); // 结果 : hello world
printf("%s",str);
return 0;
}#define 示例代码:
// b.c
/*
编译失败
*/
#include <stdio.h>
#define String char *
int main(){
String str = "hello";
String s1,s2; // 相当于 : char * s1，s2; < == > char *s1; char s2;
s1 = "hello";
s2 = "world"; // 不能把字符串赋值给字符变量
printf("%s %s\n",s1,s2);
printf("%s",str);
return 0;
} 因此区别为:
(1) #define 在编译前执行,相当于文本替换, 而typedef在编译时执行,把taypedef定义的新类型名称来当做一种类型来使用
(2) 对于指针类型不能用#define来连续定义变量否则很容易出问题
c. typedef 的使用 :
#include <stdio.h>
// 基本类型
typedef int Integer;
typedef Integer NewInteger; // 还可以为已经定义过的类型进行在定义
// 指针类型
typedef char * String;
// 结构体类型
typedef struct {
int x;
int y;
} Point;
// 枚举类型
typedef enum {
Sunday,
Monday,
Tuesday,
Thursday,
Friday,
Staturary
} WeekDay;
// 函数指针
void test(){
printf("test\n");
}
typedef void (*myTest)();
int main(){
// 基本类型
MyInteger i = 10;
printf("i = %d\n",i);
// 指针类型
String str = "hello world";
printf("str = %s\n",str);
// 结构体类型
Point p = {10,20};
printf("p = {%d,%d}\n",p.x,p.y);
// 枚举类型
WeekDay today = Sunday;
printf("today = %d\n",today);
// 函数指针
myTest t = test;
t();
return 0;
}16. 运算符优先级表
17. ASCII码对照表
---------------------- Java培训、.Net培训、Android培训、IOS培训、期待与您交流！ ----------------------
详情请查看：http://edu.csdn.net/heima
763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
