c语言_知识点总结

1.变量的作用域

从定义变量的那一行代码开始，一直到所在的代码块结束

2.代码块的作用

及时回收不再使用的变量，为了提升性能

3.交换两个变量

（1）temp = a ;

a = b ;

b = temp ;

 （2）不利用第三方变量（面试，有印象）

a = b - a;

b = b - a;

a = b + a;

  （3）使用位异或运算符交换两个变量的值

a = a ^ b; // a^b^a == b

b = a ^ b;

a = a ^ b;

1.内存寻址由大到小，优先分配内存地址比较大的字节给变量

2.变量越先定义，内存地址就越大

3.如果scanf参数中以空格隔开，实际输入可以以空格、tab、回车作为分隔符

4.一个变量一定先进行初始化，才能使用

参数注意点:

1.形式参数：定义函数时函数名后面中的参数,简称形参

2.实际参数：调用函数式传入的具体数据，简称实参

3.实参个数必须等于形参个数

4.函数体内部不能定义和形参一样的变量

5.如果是基本数据类型作为函数形参，纯粹是值传递，修改函数内部形参的值，并不会影响外面实参的值

6.一个函数可以没有形参，也可以有无限多个形参

return的作用：

1>退出函数

2>返回一个具体值给函数调用者

1.默认情况下，不允许有函数的名称一样

2.函数不能嵌套定义

3.函数不能重复定义，但是可以重复声明

4.如果有函数的声明，没有函数的定义

1>编译可以通过，因为编译器只会检测语法合不合理，并不会检测函数有没有定义

2>链接报错，因为链接的时候会检测函数是否定义

%d\%i  	十进制形式输出整数
%c		输出字符
%p 		输出地址
%zd  	unsigned long
%f 		输出小数
%o 		八进制形式输出整数// 八进制（0开头）
%x 		十六进制形式输出整数// 十六进制（0x或者0X开头）
// 		二进制(0b或者0B开头)

 signed和unsigned的区别：
 signed == signed int 最高位要当做符号位（正数、0、负数）
 unsigned ==unsigned int 最高位不要当做符号位（0、正数）

1.常量区：存放一些常量字符串

 2.堆：对象

 3.栈：存放局部变量

 

 定义字符串的2种方式

 1> 利用数组

 char name[] = "ios";

 * 特点：字符串里面的字符是可以修改的

 * 使用场合：字符串的内容需要经常修改

 

 2> 利用指针

 char *name = “iOS”;

 * 特点：字符串其实是一个常量字符串，里面的字符是不能修改

 * 使用场合：字符串的内容不需要修改，而且这个字符串经常使用

一、基本数据类型
1.int
<span style="white-space:pre">	</span>1> long int、long：8个字节  %ld
<span style="white-space:pre">	</span>2> short int、short：2个字节 %d %i
<span style="white-space:pre">	</span>3> unsigned int、unsigned：4个字节 %zd
<span style="white-space:pre">	</span>4> signed int、signed、int：4个字节 %d %i
2.float\double
<span style="white-space:pre">	</span>1> float ：4个字节 %f
<span style="white-space:pre">	</span>2> double：8个字节 %f
<span style="white-space:pre">	</span>3.char
<span style="white-space:pre">		</span>1> 1个字节 %c %d
<span style="white-space:pre">		</span>2> char类型保存在内存中的是它的ASCII值
<span style="white-space:pre">		</span>'A' --> 65

二、构造类型
1.数组
1> 只能由同一种类型的数据组成
2> 定义：数据类型 数组名[元素个数];

2.结构体
1> 可以由不同类型的数据组成
2> 先定义类型，再利用类型定义变量

三、指针类型
1.变量的定义
<span style="white-space:pre">	</span>int *p;
2.间接操作变量的值
<span style="white-space:pre">	</span>int a = 10;
<span style="white-space:pre">	</span>p = &a;
<span style="white-space:pre">	</span>*p = 20;

四、枚举类型
使用场合：当一个变量只允许有几个固定取值时

void (*p)();
// (*p)是固定写法，代表指针变量p将来肯定是指向函数
// 左边的void：指针变量p指向的函数没有返回值
// 右边的()：指针变量p指向的函数没有形参

 根据变量的作用域，可以分为：
 1.局部变量：
 1> 定义：在函数（代码块）内部定义的变量(包括函数的形参)
 2> 作用域：从定义变量的那一行开始，一直到代码块结束
 3> 生命周期：从定义变量的那一行开始分配存储空间，代码块结束后，就会被回收
 4> 没有固定的初始值
 
 2.全局变量
 1> 定义：在函数外面定义的变量
 2> 作用域：从定义变量的那一行开始，一直到文件结尾(能被后面的所有函数共享)
 3> 生命周期：程序一启动就会分配存储空间，程序退出时才会被销毁
 4> 默认的初始值就是0

// 1.定义结构体类型
1.定义结构体变量的3种方式
1> 先定义类型，再定义变量（分开定义）
struct Student
{
    int age;
};
struct Student stu;

2> 定义类型的同时定义变量
struct Student
{
    int age;
} stu;
struct Student stu2;

3> 定义类型的同时定义变量（省略了类型名称）
struct
{
    int age;
} stu;

// 2.根据结构体类型，定义结构体变量
struct Person p = {20, 1.55, "jack"};
p.name= "chenliang";
/* 错误写法
 struct Person p2;
 p2 = {30, 1.67, "jake"};

// 结构体所占用的存储空间 必须是 最大成员字节数的倍数
 2.结构体类型的作用域
 1> 定义在函数外面：全局有效（从定义类型的那行开始，一直到文件结尾）
 2> 定义在函数（代码块）内部：局部有效（从定义类型的那行开始，一直到代码块结束）

 1.指向结构体的指针的定义
 struct Student *p;
 2.利用指针访问结构体的成员
 1> (*p).成员名称
 2> p->成员名称

// 如果结构体作为函数参数，只是将实参结构体所有成员的值对应地赋值给了形参结构体的所有成员
// 修改函数内部结构体的成员不会影响外面的实参结构体

 1.所有的预处理指令都是以#开头
 2.预处理指令分3种
    1> 宏定义
    2> 条件编译
    3> 文件包含
 3.预处理指令在代码翻译成0和1之前执行
 4.预处理的位置是随便写的
 5.预处理指令的作用域：从编写指令的那一行开始，一直到文件结尾，可以用#undef取消宏定义的作用
 6.宏名一般用大写或者以k开头，变量名一般用小写

 外部函数：定义的函数能被本文件和其他文件访问
 1> 默认是外部函数
 2> 不允许有同名的外部函数
 3>extern（外部函数定义，声明）（可省）
 
 内部函数：定义的函数只能被本文件访问，其他文件不能访问
 1> 允许不同文件中有同名的内部函数
 2>static（内部函数定义，声明）

全局变量分2种：
外部变量：定义的变量能被本文件和其他文件访问
1>extern(声明外部变量)
1> 默认情况下，所有的全局变量都是外部变量
1> 不同文件中的同名外部变量，都代表着同一个变量

内部变量：定义的变量只能被本文件访问，不能被其他文件访问
1> 不同文件中的同名内部变量，互不影响
2>static(定义一个内部变量)

extern void test()//extern完整定义（声明）一个外部函数
{
    printf("34");
}
static void test2()//内部函数
{
    printf("chen");
}

3。MAC常用命令
pwd
cd
ls      //-a 为显示隐藏文件
cp     //复制文件是要在前面加“－r” //cp -r text text1
rm     //删除文件夹须要“-r”
mv      //更改文件名 mv text text.c (不须要-r)
mkdir  // mkdir text
touch  // touch 1day.c

4。vim编译器 <span style="font-family: Arial, Helvetica, sans-serif;">常用命令</span>
        // 正常模型，编辑模型 （esc切换到正常模型）
i       //从光标之前插入文本
a       //－－－－后－－－－
o       //到下面另取一行，进行插入
O       //从当前行到上面一行起
x       //将光标移到该字符下按“x”
dd      //删除当前行
u       //撤销上一次操作
:w      //保存
:q!     //丢失所有修改并退出
:wq     //保存-->退出
:e!     //放弃所有修改并重新载入该文件的内容
$       //当前行行未
^       //－－－第一个非空白字符上
G       //最后一行
gg      //第一行
:set number  //设置行号
:set nonumber
/       //搜索
yy      //复制        3yy（复制三行）
dd      //剪切        3dd（剪切三行）
p       //粘贴


运算符优先级
()  []      //括号
+   -     //正负号
++  --  !   //自加自见
*   /   %   //乘除，取余
+   -       //加减
<<  >>  <   <=  //移位运算
&       //按位与
^           //按位亦或
|       //按位或
&&      //逻辑与
||          //逻辑或
?:          //三目
=   +=  -=  *=  /=  %=      //赋值
&=   |=   <<=   >>=   >>>=  //位赋值

c程序的组成

c程序＝数据结构（数据）＋算法（对数据操作的方法）

数据结构：数据的组织形式

1:数据之间没有直接的联系（变量int a, int b）

2:数据之间呈现一对一的联系（数组，链表，栈，队列）

3:数据之间呈现一对多的联系（树）

4:数据之间呈现多对多的联系（图）

算法：对数据操作的方法

gcc编译器：将c语言编写程序翻译成二进制语言

1:预处理：将预处理命令转换成纯粹c语句

gcc -E hello.c -o hello.i

2:编译：将c程序转换成汇编程序

gcc -S hello.i -o hello.s

3:汇编：将汇编程序转换成二进制

gcc -c hello.s -o hello.o

4:链接：链接函数库，函数库中有函数的实现

gcc hello.o -o hello

变量的完整定义

  修饰符 存储类型 符号类型 数据类型 变量名

变量名：内存中为该变量开辟的存储空间的名字

变量：存储数据

数据类型：决定了变量的大小

符号类型：signed(有符号),unsigned(无符号)，最高位是否用来存储数 据

存储类型：决定了变量保存在哪里

auto:动态存储（栈）

static:静态存储（数据段）

register:寄存器存储

extern:外部声明，只是声明不开辟存储空间

修饰符：const（不变的）volatile（易变的，编译器优化）

typedef struct //Student(可省,不省保留struct以前写法)

{

    int age;

    char[20] name;

}MyStu;

int main()

{

    MyStu stu ={23,"hcenliang"};

}

enum Sex{Man,Woman};

int main()

{

    enum Sex s = Man;

    enum Sex s1 = Woman;

}

typedef  enum Sex Sex;

int main()

{

    Sex s = Man;

    Sex s1 = Woman;

}

typedef enum {Man,Woman}Sex;

typedef int (*MyPoint)(int ,int);

int minus(int a ,int b)

{

    return a-b;

}

int sun(int a , int b)

{

    return a+b;

}

int main()

{

  //  int (*p)(int ,int) = sun;

   // int (*p1)(int ,int) = minus;

    MyPoint p = sun;

    MyPoint p1 = minus;

}

typedef struct Person * PersonPoint;

struct Person

{

    int age;

};

typedef struct Person

{

    int age;

} *PersonPoint;

int main()

{

    struct Person p ={23};

    struct Person p1 = &p;

    PersonPoint p = &p;

}

extern void test()//extern完整定义（声明）一个外部函数

{

    printf("34");

}

static void test2()//内部函数

{

    printf("chen");

}

static double pi = 3.14;