C语言自学《八》---- C语言知识总结

时间 2019-11-07

标签 c语言自学知识总结繁體版

原文原文链接

1、函数

什么状况下须要定义一个函数？

经常使用的功能
重复的功能
低效率的代码

一个函数能够没有参数

void  test(void){ //void能够不写
    //函数体中不用写返回函数(return)
}

一个函数能够没有返回值，若是没有定义，默认是返回int类型

test(int a, int b){ 
    //返回值类型能够不写，若是不写，默认为返回int类型
}

在没有接触指针前，函数中的形参是修改不了实参的值的
函数从源文件自上往下执行编译，因此在调用函数以前，须要声明函数
函数内部定义不能和形参同名的变量
默认状况下，不容许两个同名的函数出现
若是函数有声明，没有定义，编译不会报错，连接会报错，由于连接会检测函数是否存在
return函数的做用

退出函数
返回一个具体值给函数调用者

函数不强制要求返回，虽然声明了返回值类型，也无济于事
什么叫作连接？

把项目中全部相关联的”.o”文件和C语言函数库，合并在一块儿，生成可执行文件，期间会检查可能发生的错误，若是出现错误，就会回到编写代码的步骤，修改相应错误代码后，再执行流程

函数的定义和声明

函数的定义放在”.c”文件中
函数的声明放在”.h”文件中

main函数返回值0表明正常退出，返回其余值表明异常退出，系统会记录日志
printf()函数其实也有返回值，它返回字符串的字节数，在当前的编译器中，中文占3个字节2、指针
定义和初始化指针

int a = 10; //定义了一个int类型的变量
int *pa  = NULL; //定义了一个int类型的指针
pa = &a; //将int类型变量a的地址赋值给pa指针，或者说pa指针指向了变量a
*pa = 20; //经过指针简介修改变量a的值，*称为取消引用运算符或间接运算符

2、指针

指针只能指向相同类型的变量而且指针只能存储地址
任何指针都占用8个字节的存储空间，固然也受编译器的影响
经过指针就能够利用形参修改实参的值，由于指针指向的是地址
指针字符串

//使用char数组存储字符串，这个叫作字符串变量
char str1[] = “luoguankun”;
//使用指针存储字符串，它指向字符串的首字母
//这个称为字符串常量，若是再声明一个字符串值同样的指针字符串
//那么他们会指向同一 个字符串，而不会建立一个新的
char *str2 = “luoguankun”;

上面的输出语句中的%s是字符串输出控制格式符
它从第一个字符开始直到遇到’\0’终止符号结束（不包括）

内存

栈——就是那些由编译器在须要的时候分配，在不须要的时候自动清除的变量的存储区。里面的变量一般是局部变量、函数参数等
堆——就是那些由new分配的内存块，他们的释放编译器不去管，由咱们的应用程序去控制，通常一个new就要对应一个delete。若是程序员没有释放掉，那么在程序结束后，操做系统会自动回收
自由存储区——就是那些由malloc等分配的内存块，他和堆是十分类似的，不过它是用free来结束本身的生命的
全局/静态存储区——全局变量和静态变量被分配到同一块内存中，在之前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区
常量存储区——这是一块比较特殊的存储区，他们里面存放的是常量，不容许修改（固然，你要经过非正当手段也能够修改，并且方法不少）

只有拥有’\0’终止符，才说明这是一个字符串，字符是没有的
\0 的ASCII码值为0，也就是false

指针数组

数组就是地址

int *name[5]; 
name[1] //取出元素下标为1的元素(指针)

字符串数组（两种方式定义）

char *name[10] //10个字符串
char name[2][10] //二维字符数组，可存放2行字符串，每行有10个字符

指向指针的函数

//定义了一个加法函数
int sum(int a, int b){

return a+b;
}

//将定义好的指针指向函数
//首先声明一个指针
int (*p)(int,int);     //其中(*p)表明未来指向的函数，(*p)左右分别为返回值类型和形参定义
p = sum; //将指针p指向test函数
p(10,22); //经过指针调用函数，它等于sum(10,22);固然在调用以前别忘了声明函数

可使用sizeof()运算符计算字符串长度（计算的是字节数）

sizeof()的结果类型是size_t类型，它在头文件中用typedef定义为unsigned int类型
sizeof()运算符能够用任何类型作参数，甚至函数

也可使用strlen()函数计算字符串长度

strlen()只能用char*作参数，且必须是以’’\0’'结尾的
要想使用须要引入<string.h>头文件

变量类型

全局变量

定义：在函数外面定义的变量叫作全局变量
做用域：从定义变量的那一行开始，到文件结尾
生命周期：当程序启动开始分配存储空间，到程序退出才会被销毁
初始值若是未定义就为0

局部变量

定义：在函数代码块内部定义的变量
做用域：从定义变量的那一行开始到代码块结束
生命周期：从定义变量开始分配存储空间，代码块结束后就会被回收
初始没有肯定的值

3、结构体

数组只能存储一组同类型的数据，而结构体能够保存一组不一样类型的数据 程序员

定义结构体类型

//如下定义没有分配存储空间，仅仅定义类型 算法

struct Person {
   int age;
   int sex;
   char *name;
};

定义结构体变量 数组

struct Person p;

赋值

p.age = 13; //一种方式

//另外一种方式，初始化的同时进行赋值，同时进行分配存储空间
//结构体的存储空间是最大成员字节数的倍数，称为补齐算法
struct Person p = {13,1,”luoguankun”};

p = {13,1,”luoguankun”}; //这是错误的！只能在定义结构体时赋值

输出结构体中定义的变量值

printf(“age=%d,sex=%d,name=%s”,p.age,p.sex,p.name);

另外一种定义结构体变量的方式

//定义类型的同时定义变量，甚至能够不写类型名称，称为匿名结构体，它不能被重用
//而且变量名不能重复
struct Student{
    int age;
}stu;

类型不能重复定义，例如上面的Student不能被定义两次，变量名也同样不能重复
结构体数组

//定义结构体类型
struct Person{
    int age;
    double height;
    char *name;
}stu;

//定义结构体数组变量并赋值初始化
struct Person stu[3] =
{
    {11,12.1,"o"},

    {12,12.2,"u"},

    {13,12.3,”l"}

};

//循环遍历结构体数组，并打印
for (int i = 0; i < sizeof(stu) / sizeof(stu[0]); i++) {
   printf("age=%d,height=%.1f,name=%s\n",stu[i].age,stu[i].height,stu[i].name);
}

//stu[i] = {4,1.22,”dkdk”}; //这是错误的

stu[i].age = 4; //这样是正确的

指向结构体的指针

//省略类型定义，如上，下面使用结构体变量并赋值初始化
struct Person stu = {11, 1.73, "罗冠坤"}; 

//定义了一个指针p并指向结构体变量stu
struct Person *p = &stu;

//三种输出方法均可以输出数据，做用相同，其中p->成员名的方式较为新颖
printf("age=%d,height=%.2f,name=%s\n",stu.age,stu.height,stu.name);
printf("age=%d,height=%.2f,name=%s\n",(*p).age,(*p).height,(*p).name);
printf(“age=%d,height=%.2f,name=%s\n",p->age,p->height,p->name);

//赋值方法的调用方法相同

嵌套结构体

int main(){

    struct Date{
        int year;   //年
        int month;  //月
       int day;    //日
    };

    struct Student{
        int no; //学号
       //嵌套两个Date来分别表示生日和入学日期
        struct Date birthday;   //生日
        struct Date SchoolDay;  //入学日期
    };

    struct Student stu =
    {
        1,
        {1989,10,24},
        {2009, 9, 1}
    };

    //间接取值，嵌套访问
    printf("学号为：%d\n生日为：%d年%d月%d日\n入学日期为：%d年%d月%d日\n",
    stu.no,stu.birthday.year,stu.birthday.month,stu.birthday.day,
    stu.SchoolDay.year,stu.SchoolDay.month,stu.SchoolDay.day);

return 0;

}

4、预处理指令

全部预处理指令都是以#开头
不带参数的宏定义

//宏名  值;
#define


//宏的变量名所有是大写，结尾不须要写分号
#define  COUNT  6


//还能够取消宏的定义
#undef COUNT

编译器的做用是将原代码文件中的代码翻译成机器可执行的代码，也就是0和1，而预处理指令会在编译器翻译代码以前执行
带参数的宏定义

/*

必定要加括号，不然会出现意想不到的结果好比像下面这样调用

  sum(10,10) * sum(10,10);

至关于下面：

  10+10*10+10   这样替换事后改变了运算顺序，也就改变了预期的运算结果

  因此必定要把全部变量都加上括号

  再好比平方的例子必定要像下面这样写,每一个形参都要加上括号

  #define Square(a)((a)*(a))

*/



#define sum(v1,v2)((v1)+(v2))



int main(void){

    int result = sum(11,10);
    printf("result=%d\n",result); //输出了21

   return 0;
}

宏定义只是单纯的把左边的定义（好比：sum(v1,v2)）替换成右边的（好比：(v1)+(v2)），不作任何运算

在常见的比较简单的函数可使用宏定义，这样比函数效率要高

条件编译

#define A 10

int main(){

//条件编译判断若是用到常量值，好比下面的A
//则必须得是经过宏定义的，由于在编译前已经进行了判断
//条件的括号能够省略    
    #if (A == 10)
        printf("a = 10\n");
    #elif (A == 5)
        printf("a = 5\n");
    #else
        printf("a is other number\n");
    #endif //必定要有#endif结尾

    return 0;

}

防止文件屡次被包含

当进行多文件开发时，某些函数功能，须要在.h文件中进行声明，还要将.h文件包含到某个文件中，当代码量过大时，有可能发生屡次包含，这虽然不会产生错误，可是会影响性能，因此在头文件中能够利用条件编译，防止屡次包含头文件，例如像下面这样定义头文件：函数

/*
解释下面的写法的逻辑:
若是没有定义宏 ABC 
那么就定义一个宏ABC
而且声明sum()函数
若是第二次被包含时，一样会进行判断
此时判断的条件不成立，由于第一次被包含时已经建立了宏变量ABC
因此这样一来，避免了重复包含同一个头文件
ABC宏名称不能和别的头文件中的冲突！因此通常使用当前.h头文件名称命名
*/

// #ifndef等同于#if !define，对应的有#ifdef 等同于 #if define
#ifndef ABC
// ABC通常写成当前头文件的名称，后面的值随便写
    #define ABC 11
    int sum(int,int);
#endif

typedef

定义类型的别名（通常是全局变量，方便被使用），使用typedef之后，会提升开发效率
应用于5个场合

基本数据类型
指针
枚举
结构体
指向函数的指针

应用于基本数据类型

//须要分号
typedef int MyInt;

int main(){
    //声明别名后，能够这样定义int类型变量
    MyInt i = 10;
}

应用于指针

//给指针类型起了一个别名String
type char* String;

int main(){
    String = “luoguankun”;
}

应用于结构体

//定义了一个结构体类型Student
struct Student {
    int age;
};

//给结构体Student起了个别名叫作Mystu
typedef struct Student MyStu;

//或者像下面这样，在定义结构体类型的时候直接起别名，这样更加精简
typedef struct Student {
    int age;
}MyStu;

//若是像上面这样给结构体起了别名，定义结构体变量就变成了下面这样：
MyStu s1;
MyStu s2;
MyStu s3;


//还有一种是没有类型名的结构体
//下面的结构体不能使用本来的方式建立结构体变量
//只能经过下面的方式建立结构体变量，没法用struct Student stu = {10};这种方式建立结构体变量，
//而前面几种两种建立结构体变量的方式均可以
//而这个只能像下面这样建立：
//MyStu stu;
typedef struct {
    int age;
}MyStu;

应用于枚举类型

//如下是没有使用typedef定义别名时的枚举使用
enum Sex {Man, Woman};
enum Sex s = Man;

//如下是使用typedef定义别名后的使用方法
typedef  enum  Sex MySex;
MySex s = man;

//还能够在定义枚举类型的同时定义别名（推荐这样定义）
typedef  enum Sex {Man, Woman} MySex;
MySex s1 = man;

应用与指向函数的指针

//定义一个函数
int sum(int a, int b){
    return a+b;
}

//指向上面函数的指针声明和调用
int (*p)(int, int) = sum;
int result = p(10,20);

//使用typedef为指向函数的指针定义别名
typedef int (*MyPoint)(int, int);

MyPoint p = sum;
int result = p(20,20);

简化指向结构体的指针

//简化前
struct Person{
    int age;
}; 

struct Person p = {20}; 
struct Person *p2 = &p;
printf("age = %d\n”, p2->age);



//简化后
typedef struct Person{
     int age;
} *PersonPoint;

struct Person p = {20};    
PersonPoint p2 = &p;
printf("age = %d\n", p2->age);

5、static和extern对函数的做用

这两个关键字分别表明内部和外部函数

static —— 内部函数，只能被本文件访问，其余文件不能访问，但能够经过外部函数间接访问
extern —— 外部函数(默认)

在多文件开发的状况下，不一样文件中的外部函数不能够重名，内部函数能够同名，但在同一个文件中内外部函数都不能重名
定义完整的外部函数须要在函数前加上extern关键字，也能够省略，由于它是默认的
定义内部函数须要在函数前面加上static关键字
虽然被static关键字修饰的函数不能被外部文件直接调用，但能够间接调用，在外部函数中调用内部函数（条件是要被间接调用的内部函数和外部函数在同一个文件），而且必须在外部函数的上面被声明

6、static和extern对变量的做用

全局变量分为两种：

外部全局变量——默认，类型关键字前面无需加任何修饰符
内部全局变量——被static修饰符修饰

默认状况下，全部的全局变量都是外部变量，不一样文件中的同名变量，都表明同一个变量
内部变量：只能被本文件访问，不能被别的文件访问，不一样文件同名的内部变量，互不影响
static对变量的做用：定义一个内部变量
extern对变量的做用：声明一个外部变量
static对函数的做用：定义和声明一个内部函数
extern对函数的做用：定义和声明一个外部函数（能够省略）

6、static对局部变量的做用 性能

延长局部变量的生命周期直到程序结束
期间并无改变局部变量的做用域
使用场合：

某个变量的值固定不变，而被调用的次数又很是多，就应在变量前加上static修饰符