C语言指针，数组，函数总结学习笔记。（非基础）

1、函数（在函数调用时会分配栈帧空间，调用结束后空间销毁）：

函数嵌套，递归。

函数的返回值可以作为参数。

在C语言中，函数名不能重复。

（1）C语言默认函数为外部函数。

（2）static 用于定义内部函数。

（3）局部变量:函数的参数，函数内部的变量

static 可以延长局部变量的生命周期

（4）全局变量:定义在函数外部，仅仅属于其所在源文件。要想在别的源文件使用，需要在使用处加上 extern//即外部引用声明，但未在内存开辟空间，不能赋值。

（5）实参与形参的传递=值传递，被调函数内只改变形参的值，main函数中的实参不改变

2、头文件：

（1）避免头文件重复定义：

#ifdefine 大写头文件

#define 大写头文件

#endefine

（2）头文件也可以嵌套，但不能两个文件交叉。

（3）当自定义头文件时，头文件需要交叉包含，则需要在前面加上 #pragma once。

3、数组：

二维数组初始化：第一维度可以省略，第二维度不能省略。

4、指针：

(1)指针的定义：

int *p=NULL;空指针初始化。

p=＆a;给指针赋值，得到a的地址。

*p=＆a;解引用，得到的是a的值

(2)指针做函数参数：

int fun( *a)；将形参a修改为指针，并接受n1的地址｛

*a=20；将指针a地址的值由10赋值为20

｝

main()｛

int n1=10;将n1赋值为10

fun（＆n1）；将实参n1地址传递给被调函数fun,并用指针a接收｝

（3）const修饰指针：

const int n=10；const定义的常量，不允许修改。

const int *p（int const *p）;const定义的指针，p是一个指向int常量的指针，即*p不可修改，防止p地址内的值*p被篡改。

int *const p；即p是指向int变量的常量，p不可修改。

const int *const p；p不可修改，*p也不可修改。

（4）指针数组：

int *p[10]；定义一个数组，里面存十个指针

（5）数组指针：

int (*p)[10]；是指针，用来存放数组的地址。

 (6) 字符指针：

字符指针只能修改字符串数组，不能修改字符串常量。

(7)函数指针：

void fun (int a)｛

a++;

printf("fun函数被调用：％d",a); ｝

main()｛

void(*p)(int);定义函数指针。

p=fun;将指针指向函数

(*p)(1);通过函数指针调用函数｝

（8）函数指针做函数的参数（调用函数）：

float result（float x，float y，float（*p）（float，float））｛

return（*p）（x，y）｝;

 (9)指针易于混淆的概念：

int *p;

一个指向整形数组的指针。

int **p;

一个指针的指针，它指向的指针指向一个整形变量

int *p[10];

一个有十个指针的数组，该指针指向整形数组。

int (*p)[10];

一个指向有十个整形数据数组的指针。

int *p(int);

一个函数 （不是函数指针），该函数有一个整形参数，返回值为一个指向整型的指针。

int (*p)(int);

一个函数指针，该函数有一个整形的参数，返回值为整形类型。

int (*p[10]）(int);

一个有十个指针的数组，该数组中的指针指向一个函数，该函数有一个整形参数并返回一个整型数。

（10）动态内存分配（用指针生成栈区)：

int *p=(int *)malloc(4000000);在内存中申请空间，指针不能轻易赋值。

free(p);分配空间的释放，如不释放会导致内存泄露（空间不能重复的释放）空间释放后指针p变为野指针，p=NULL,赋值为野指针。

(11)返回指针的函数：

int *fun(int size,int n)｛

return p;｝

int *p1=fun(100,1);

(12)二级指针：

a=1;

int *p=＆a;

int **p2=＆p;

动态分配二维数组用二级指针。

5、结构体

（1）定义：struct student｛｝

 

typedef struct student｛

char name[32];

char sex[8];

int age;

｝STUDENT;结构体定义及关键字声明。

typedef struct student STUDENT;关键字声明。

struct student s;定义结构体变量。

（2）结构体的输入和输出：

scanf("％s％s％d",s.name,s.sex,&s.age);

printf("姓名：%s 性别：％s 年龄：%d\n",s.name,s.sex,s.age);

(3)结构体变量直接赋值：

STUDENT s =｛0｝;

STUDENT s2=｛"Jack","男",20｝;

s=s2;

(4)结构体指针：

STUDENT s=｛"Jack","男",20｝;

STUDENT *p=＆s;定义及赋值。

printf("%s\n",(*p).name);调用结构体指针。

(*p).name=p->name;

（5）结构体指针变量做形参：

void fun(STUDENT *s)｛｝

fun (&s);main函数中调用。

（6）结构体数组初始化及访问：

STUDENT arr[100]=｛0｝;清零。

STUDENT arr[100]=｛｛"Jack","男",20｝,｛"Lucy","女",18｝,｛"Lily","女",18｝｝;初始化。

printf("%s %s %d\n",arr[0].name,arr[0].sex,arr[0].age);结构体指针访问内部元素。

(7)结构体数组遍历：

for(i=0;i<100;i++)｛

printf("姓名：%s 性别：%s 年龄：%d\n",arr[i].name,arr[i].sex,arr[i].age);｝

（8）结构体中包含另外的结构体：

typedef struct date｛

int year;

int month;

int day;

｝DATE;

typedef struct student｛

char name[32];

char sex[8];

DATE birthday;

DATE inschool;

｝STUDENT;定义STUDENT结构体中包含DATE。

STUDENT s =｛"Jack","男",｛1997，1，1｝，｛2017，9，1｝｝;初始化。

printf("出生日期：％d-％d-％d\n",s.birthday.year,s.birthday.month,s.birthday.day);访问包含结构体的结构体。

（9）指针操作包含结构体的结构体：

STUDENT *p=＆s;

printf("出生日期：％d-％d-％d\n",

p->birthday.year,

p->birthday.month,

p->birthday.day);

（10）结构体自引用：

即结构体中包含自身是非法的，类似与递归，

但结构体中包含自身的指针是合法的，

typedef struct test｛

int n;

struct test *p;

｝TEST;定义

（11）共用体

typedef union test｛

int a;

short b;

char c;

｝TEST;三种类型共用同一段字节，由最大长度的类型决定。

TEST t;

t.a=1;

t.b=2;

t.c=3;同一时刻仅有一种类型生效，即t.c生效，共用体TEST占四个字节。

TEST t =｛1｝共用体初始化，类型必须与第一种类型一致。

（12）枚举

typedef enum weekday ｛

monday,tuesday,wednesday,thursday,friday,saturday,sunday

｝WEEKDAY;定义的周一至周日即为weekday的值。monday值默认为0，后续依次加一，也可以自由赋值。

WEEKDAY day;

day =monday;

day =tuesday;定义变量day并赋值周一，周二。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

c语言学习笔记开发语言

发布于2025-01-05著作权归作者所有