C语言-指针基本知识

#include <stdio.h>
// pointer
int main() {
 int num = 1;
 //过程:找num,num找地址,地址取值
 printf("num's value=%d,num's address=%p\n",num,&num);//输出地址%p, &num = 取出Num的地址
 //指针ptr->num的地址(且类型为int)
 int *ptr = &num; //指针自身也有地址!
 printf("ptr1's address=%p\n",&ptr);//取ptr指针本身的地址
 printf("num's address=%p\n",ptr);//取ptr指针存放的地址.其中ptr可以写成&*ptr
 //综上:
 // num = 1 ; &num = num的地址; &ptr = ptr自身的地址; ptr = num的地址;
 //取出 指针ptr所指向的值.即num的值
 printf("num's address=%d\n",*ptr);
 return 0;
}

指针 应用案例

#include <stdio.h>
int main() {
 int num = 999;
 printf("num's value = %d\n",num);
 printf("num's address = %p\n",&num);
 //用指针修改num的值
 int *ptr = &num;
 *ptr = 1000;
 printf("num's value = %d\n",num);
 printf("num's address = %p\n",&num);
 return 0;
}

转义字符 应用案例

姓名 年龄 成绩 性别 爱好
XX XX XX XX XX

#include <stdio.h>
// point
int main() {
 char name[10] = "Lucy";//字符数组,可以存放字符串
 short age = 23;
 float score = 78.5;
 char gender = 'M';
 char hobby[20] = "Basketball,soccer";
 printf("name\tage\tscore\tgender\thobby\n %s\t%d\t%.2f\t%c\t%s",name,age,score,gender,hobby);
 return 0;
}

计算器 应用案例

#include <stdio.h>
// point
int main() {
 int num1,num2;
 printf("put num1");
 printf("put num2");
 num1 = 30;
 num2 = 20;
 printf("*****************************\n\tSmall cal\n*****************************\n");
 printf("num1+num2=%d\n",num1+num2);
 printf("num1*num2=%d\n",num1*num2);
 printf("num1/num2=%d\n",num1/num2);
 printf("num1-num2=%d\n",num1-num2);
}

const和#define的区别

#define 常量名 常量值;
#define Pi 3.14
const 数据类型 常量名=常量值;
const double pi = 3.14;

#include <stdio.h>
#define A 1
#define B A+3 //B=4
#define C A/B*3 //C=1/4*3
int main(){
 //define是一个简单(直接)的替换过程
 // C = A/A+3*3 其中A=1;
 printf("c=%d", C); //问c=?
 // 所以 C = 10;
 return 0;
}

#include <stdio.h>
#define A 1.0 //如果是1,c=0,如果是1.0,c=0.75
#define B (A+3) //B=4
#define C A/B*3 //C=1/4*3
int main(){
 //define是一个简单的替换过程
 // C = A/A+3*3 其中A=1;
 printf("c=%.2f", C); //问c=?
 // 所以 C = 10;
 return 0;
}

#include <stdio.h>
const double pi = 3.14;
const double pi = ×ばつ
#define pi2 3.14 
#undef pi2 3.14 //取消pi2的定义
#define pi2 3.145
√

#include <stdio.h>
#define Debug
int main(){
#ifdef Debug //如果定义过Debug
 printf("defined Debug");
#endif
#ifndef Debug //如果没有定义过Debug
 printf("undefined Debug");
#endif
}

scanf

#include <stdio.h>
// point
int main() {
 char name[10] = "";//字符数组,可以存放字符串
 int age = 0;
 double sal = 0.0;
 char gender = ' ';
 //put information
 printf("Please put name:");
 //scanf("%s",name); 表示接受一个字符串存放到name数组中
 scanf("%s",name);
 printf("Please put age:");
 //因为我们将得到输入存放到age变量指向地址,因此需要加&
 scanf("%d",&age);
 printf("Please put salare:");
 //接收一个double时,格式参数%lf
 scanf("%lf",&sal);
 printf("Please put sex(m/f):");
 scanf("%c",&gender);//有问题 输出sal时按下回车,会将回车作为字符代入gender
 scanf("%c",&gender);//这个是等待用户输入
 printf("\nname %s age %d sal %.2f gender %c", name, age,sal,gender);
 return 0;
}

枚举

#include <stdio.h>
int main(){
 enum DAY{
 MON=1,TUE=2,WED=3,THU=4,FRI=5,SAT=6,SUN=7
 };//这里DAY就是枚举类型,包含了7个枚举元素
 //enum DAY 是枚举类型,day就是枚举变量int a
 enum DAY day; 
 day = WED; //给枚举变量day赋值,值就是某个枚举元素
 printf("%d" ,day);// 3
 return 0;
}

//遍历
#include <stdio.h>
enum DAY{
 MON=1,TUE,WED,THU,FRI,SAT,SUN
}day ;//如果没有给赋值编号,就会按照顺序自动赋值
int main() {
 for (day = MON; day <= SUN; day++) {
 printf("Enum element:%d \n", day);
 }
 return 0;
}

#include <stdio.h>
int main(){
 enum SEASONS {SPRING=1,SUMMER,AUTUMN,WINTER};//定义枚举类型 SEASONS
 enum SEASONS season;//定义了一个枚举变量 SEASON
 printf("Put your favorate season:(1.spring, 2. summer, 3. autumn 4 winter): " );
 scanf("%d",&season);
 switch (season){
 case SPRING:
 printf("your favorate season is spring");break;
 case SUMMER:
 printf("your favorate season is summer");break;
 case AUTUMN:
 printf("your favorate season is autumn");break;
 case WINTER:
 printf("your favorate season is winter");break;
 default:
 printf("你没有选择你喜欢的季节");
 }
}

函数

function.c //源文件
//内容
定义函数
cal(){
 函数体
 
};
add(){
 函数体
 
};
function.h //头文件
//内容
声明函数
cal();
add();
//其中.c中含函数
//其中.h只含有函数名
Test.c 源文件
//内容
#include "function.h" //引入头文件
1.可以使用头文件中声明的函数
2.便于管理和维护

#include "function.h" 
#include "function.h" 
#include "function.h" 
#include "function.h" 
//效果同下
#include "function.h" 

函数调用

#include <stdio.h>
void test(int n){
 int n2 = n + 1;
 printf("n2 = %d",n2);
}
int main(){
 int number = 6;
 test(number);
 return 0;
}

函数调用的规则
1. 当调用(执行)一个函数时,就会开辟一个独立的空间(栈)
2. 每个栈空间是相互独立
3. 当函数执行完毕后,会返回到调用函数位置,继续执行
4. 如果函数有返回值,则将返回值赋给接收的变量
5. 当一个函数返回后,该函数对应的栈空间也就销毁
计算器内存
栈: 
 test栈 <--|
 n->[6] |
 n2->[n+1=7] |
 |-- printff("n2 = %d",n2); |
 | |
 | main栈 |
 | number->[6] |
 | test(number) --|
 |--> return 0 ;
 

函数递归

#include <stdio.h>
void Recursion(int n){
 if(n>2){ //递归出口
 Recursion(n-1);
 }
 printf("n=%d\n",n);
}
int main(){
 int number = 6;
 Recursion(number);
 return 0;
}
output:
n=2
n=3
n=4
n=5
n=6

计算器内存
栈: 
 
 Recursion栈 <----| 
 n->[2] |
 if(n>2) //不满足 |
 printf("n=%d\n",n);//输出2 | 
 |
 |---> Recursion栈 | 
 | n->[3] |
 | if(n>2) |
 | Recursion(2) ---------|
 | //printf("n=%d\n",n);等待运行
 |
 | Recursion栈 <----| 
 | n->[4] | 
 | if(n>2) |
 |------------ Recursion(3) | 
 //printf("n=%d\n",n);待运行 |
 |
 |---> Recursion栈 | 
 | n->[5] |
 | if(n>2) |
 | Recursion(4) ---------| 
 | //printf("n=%d\n",n);待运行
 |
 | Recursion栈 <----| 
 | n->[6] | 
 | if(n>2) |
 |------------ Recursion(5) | 
 //printf("n=%d\n",n);待运行 |
 |
 main栈 | 
 number->[6] | 
 Recursion(number) ---------| 
 return 0 ;
 

函数递归需要遵守的重要原则:

void f3(int n){
 n++; //复制再修改
}
void f3(int*p){
 (*p)++; //直接对原来的数修改
 //p就是n地址所存的值,*取值符
}
void main(){
 int n = 9;
 //f2(n); //9
 f3(&n);
 printf("main函数中 n=%d",n);//10
}

函数参数的传递方式值传递和引用传递使用特点:

多个参数

#include <stdio.h>
#include <stdarg.h>
//num表示传递的参数个数
//...表示可以传递多个参数,和num一致对应
int MultiParemeter(int num,...){ //可变函数,即参数的个数可以不确定,使用...表示
 int i, totalSum=0; //totalSum一定要初始化
 int val = 0;
 va_list v1; //v1实际是一个字符指针,从头文件里可以找到
 va_start(v1, num); //使v1指向可变列表中第一个值,即num后的第一个参数
 printf("*v(first parameter) = %d\n",*v1);
 for(i = 0; i < num; i++){ //num 减一是为了防止下标超限
 val = va_arg(v1, int); //该函数返回v1指向的值,并使v1向下移动一个int的距离,使其指向下一个int
 printf("val = %d\n", val);
 totalSum += val;
 }
 va_end(v1); //关闭v1指针,使其指向null
 return totalSum;
}
void main(){
 int totalSum = MultiParemeter(4,10,60,30,-10);
 printf("%d",totalSum);
}
output:
*v(first parameter) = 10
val = 10
val = 60
val = 30
val = -10
90

交换值

#include <stdio.h>
//请编写一个函数swap(int *n1, int *n2)可以交换n1和n2的值
//说明
1.函数名为swap
2.形参是两个指针类型int*
void swap(int *n1, int *n2){
 int temp =*n1; //表示将n1这个指针指向的变量的值赋给temp
 *n1 = *n2; //表示将n这个指针指向的变量的值赋给n1这个指针指向的变量
 *n2 = temp; //表示将temp值赋给n2这个指针指向的变量
}
void main(){
 int n1 = 1;
 int n2 = 2;
 swap(&n1,&n2);
 printf("main n1 = %d n2 = %d",n1,n2);
}

swap栈 //*代表取值
n1 --------------------> [0x1122] 0x1144
n2 --------------------> [0x1133] 0x1155
//int temp =*n1;
-----> temp = 1
//*n1 = *n2; 
-----> n1 = 2;
//*n2 = temp;
-----> n2 = 1;
main栈
n1 ==================== [1] 0x1122
n2 ==================== [2] 0x1133
swap(&n1,&n2)

Static

局部变量使用static修饰

#include <stdio.h>
void fn(){
 int n = 10;//普通变量,每次执行都会初始化,n在栈区
 printf("n=%d", n);
 n++;
 printf("\nn++=%d\n", n);
}
void fn_static(){
 static int n = 10;//静态局部变量,放在静态存储区,全局性质空间
 printf("static n=%d", n);
 n++;
 printf("\nn++=%d\n", n);
}
int main() {
 fn_static();
 fn_static();
 return 0;
}
output:
static n=10
n++=11 
//因为static定义的变量只会初始化一次,第一次10,第二次并不会重新定义为10,而是使用上一次计算后的11
static n=11
n++=12

全局变量使用static修饰

file.c
int num = 10;//普通全局变量
static int num2= 20;//静态全局变量,只能在本文件中使用,而不能在其它文件使用
file2.c
#include <stdio.h>
//在一个文件中,使用另外—个文件的全局变量,使用extern引入即可
extern int num;
extern int num2; //报错:因为静态全局变量,只能在本文件中使用,而不能在其它文件使用
void main() {
 printf("num=%d num2=%d", num, num2);
}

函数使用static修饰

file.c
#include <stdio.h>
void fun1(void){//普通函数
 printf("hello from fun1.\n");
}
static void fun2(void){//静态函数
 printf("hello from fun2.\n");
}
file2.c
#include <stdio.h>
extern void fun1(void);
extern void fun2(void);
//报错:因为静态全局变量,只能在本文件中使用,而不能在其它文件使用
void main() {
 fun1();
 fun2(); 
 }
output:
hello from fun1

file.c
#include <stdio.h>
void fun1(void){//普通函数
 printf("hello from fun1.\n");
}
static void fun2(void){//静态函数
 printf("hello from fun2.\n");
}
file2.c
#include <stdio.h>
extern void fun1(void);
void fun1(){
} //报错:不同的文件可以使用相同名字的静态函数,互不影响
void fun2(){
};
void main() {
 fun1();
 fun2(); 
 }
output:
hello from fun1

系统函数

字符串

#include <stdio.h>
#include <string.h>
int main(){
 char src [50] = "abcdeff";
 char dest [50] = "abcdeff";
 char *p = src;
 char *q = dest;
 printf("str.len=%d\n", strlen(p));
 // || (上面更容易理解一点)
 /*char src[50], dest[50];//定义了两个字符数组(字符串),大小为50
 char * str = "abcdff";
 printf("str.len=%d", strlen(str));*/
 //表示将"hello"拷贝到src,src本来是abcdeff,拷贝后是Kioo = 4,拷贝字符串会将原来的内容覆盖
 strcpy(src,"Kioo");
 printf("str.len=%d\n", strlen(p));
 //表示将"hello"拷贝到src,src本来是abcdeff,拷贝后是hello world! = 12,拷贝字符串会将原来的内容覆盖
 strcpy(dest, "hello world!");
 printf("str.len=%d\n", strlen(q));
 //llstrcat是将src字符串的内容连接到dest ,但是不会覆盖dest原来的内容,而是连接!!
 strcat(dest, src);
 printf("the last string array:desk = %s", dest);
 return 0;
}
output:
str.len=7
str.len=4
str.len=12
the last string array:hello world!Kioo

时间

#include <stdio.h>
#include <time.h>
void test() { //运行test函数所需时间
 int i = 0;
 int sum = 0;
 int j = 0;
 for (i; i < 77777777; i++) {
 sum = 0;
 for (j = 0; j < 10; j++) {
 sum += j;
 }
 }
}
int main(){
 time_t curtime; //time_t是<time.h>中结构体类型
 time(&curtime); //time()完成初始化任务
 // ctime返回一个表示当地时间的字符串,当地时间是基于参数timer
 printf("Current time = %s", ctime(&curtime));
 //先得到执行test前的时间
 time_t start_t, end_t;
 double diff_t; //存放时间差
 printf("Program start...\n");
 time(&start_t);//初始化得到当前时间
 test(); //执行test
 //再得到执行test后的时间
 time(&end_t);
 diff_t = difftime(end_t, start_t);//时间差,按秒ent_t - start_t
 printf("test expend %.2f Second",diff_t);
 //然后得到两个时间差就是耗用的时间
 return 0;
}
output:
Current time = Wed Jan 20 18:20:26 2021
Program start...
test expend 2.00 Second
//如果把j<10改成j<100,test expend 19.00 Second,几乎是2的10倍

数学

#include <stdio.h>
#include <math.h>
int main(){
 double d1 = pow(2.0,3.0);
 double d2 = sqrt(5.0);
 printf("d1=%.2f\n" , d1);
 printf("d2=%.2f", d2);
 return 0;
}
output:
d1=8.00
d2=2.24

基本数据类型和字符串类型的抟换

#include <stdio.h>
//基本类型转字符串类型
int main(){
 char str1[20]; //字符数组 即字符串
 char str2[20];
 char str3[20];
 int a=20984,b=48090;
 double d=14.309948;
 sprintf(str1,"%d,%d\n",a,b);
 sprintf(str2,"%.2f\n",d);
 sprintf(str3,"%8.2f\n",d); //8.2% 一共有8位,小数点占2位,不够的用空格补齐
 printf("str1=%s,str2=%s,str3=%s",str1,str2,str3);
}
output:
str1=20984,48090
,str2=14.31
,str3= 14.31 //空格代表不足8位,补足

#include <stdio.h>
#include <stdlib.h>
//字符串类型转基本数据类型
int main(){
 char str[10] = "123456";
 char str2[10]="12.67423";
 char str3[2]= "ab";
 char str4[4]= "111";
 //说明
 int num1 = atoi(str); //将str转成整数
 short s1 = atoi(str4); //将str转成整数
 double d = atof(str2); //将str转成浮点数
 char c = str3[0]; //获取到str3这个字符串(字符数组)的第一个元素
 printf("num1=%d s1=%d d=%f c=%c",num1,s1,d,c);
}
output:
num1=123456 s1=111 d=12.674230 c=a

注意事项

#include <stdio.h>
#include <stdlib.h>
//字符串类型转基本数据类型
int main(){
 char str[10] = "hello";
 int num1 = atoi(str); //将str转成整数
 printf("num1=%d",num1);
}
output:
num1=0

预处理命令基本介绍

具体要求:
开发一个c语言程序,让它暂停5秒以后再输出内容"helo,尚硅谷!~",并且要求跨平台,在Windows和Linux下都能运行,如何处理
提示
1. Windows平台下的暂停函数的原型是void Sleep(DWORD dwMilliseconds),参数的单位是"毫秒",位于<windows.h>头文件。
2. Linux平台下暂停函数的原型是unsigned int sleep (unsigned int seconds),参数的单位是"秒",位于<unistd.h>头文件
3. #if、#elif、#endif就是预处理命令,它们都是在编译之前由预处理程序来执行
#include <stdio.h>
#if _WIN64//如果是windows平台,就执行#include <windows.h>
#include <windows.h>
#elif _linux_ //否则不是windows平台,就执行#include <unistd.h>
#include <unistd.h>
#endif
int main() {
 //不同的平台下调用不同的函数
 #if _WIN64//识别windows平台
 Sleep(5000); //5000毫秒
 #elif _linux_//识别linux平台
 sleep(5);/5秒
 #endif
 puts("hello,world");
 return 0;
}

宏定义

#define叫做宏定义命令,它也是c语言预处理命令的一种。所谓宏定义,就是用一个标识符来表示一个字符串,如果在后面的代码中出现了该标识符,那么就全部替换成指定的字符串

快速回顾
#define N 100
int main(){
 int sum = 20+ N; //N->100
 printf("%d\n" , sum); 
 return 0;
}
小结:
1)int sum= 20+N,N被100代替了。
2)#define N 100就是宏定义,N为宏名,100是宏的内容(宏所表示的字符串)。在预处理阶段,对程序中所有出现的"宏名",预处理器都会用宏定义中的字符串去代换,这称为"宏替换"或"宏展开"。
3)宏定义是由源程序中的宏定义命令#define完成的,宏替换是由预处理程序完成的

宏定义的形式

#include <stdio.h>
//宏定义,宏名M,对应的字符串(n*n+3*n)
#define M (n*n+3*n)
int main(){
 int sum, n;
 printf("Input a number: ");
 scanf("%d",&n);
 sum = 3*M+4*M+5*M;//宏展开? 3*(n*n+3*n)+4*(n*n+3*n)+5*(n*n+3*n)
 printf("sum=%d\n", sum);
 return 0;
}
output:
Input a number:3
sum=216

#include <stdio.h>
#define PI 3.14159
int main(){
 printf("PI=%f",PI);
 return 0;
}
#undef PI //取消宏定义
void func(){
 //code
 printf("PI=%f",PI);//错误,这里不能使用到PI了,编译器中PI为红色
}

#include <stdio.h>
#define OK 100
int main(){
 printf("OK\n"); //"..OK.."不会被宏替换
 return 0;
}

#define PI 3.1415926
#define S Pl*y*y /* PI是已定义的宏名 */
printf("%f", S);
//在宏替换后变为:
printf("%f,3.1415926*y*y);

#define UINT unsigned int
void main(), {
 UINT a, b; //宏替换 
}

带参数的宏定义

#include <stdio.h>
/* 1. MAX就是带参数的宏
2. (a,b)就是形参
3. (a>b) ? a: b是带参数的宏对应字符串,该字符串中可以使用形参
*/
#define MAX(a,b) (a>b)? a : b
int main(){
 int x , y, max;
 printf("input two numbers: ");
 scanf("%d %d" ,&x,&y);
 
 //说明
 //1. MAX(x,y);调用带参数宏定义
 //2.在宏替换时(预处理,由预处理器),会进行字符串的替换,同时会使用实参,去替换形参
 //3.即MAX(x, y)宏替换后(x>y)? x:y
 max = MAX(x, y);
 printf("max=%d\n" , max);
 return 0;
}

#include <stdio.h>
#include <stdlib.h>
#define SQ(y)y*y //带参宏定义
int main(){
 int a, sq;
 printf("input a number: ");
 scanf("%d", &a);
 sq = SQ(a+1);//宏替换a+1*a+1 而不是(a+1)*(a+1)
 printf("sq=%d\n", sq);
 system("pause");
 return 0;
}
output:
input a number:30
 sq=61
请按任意键继续. . .

带参宏定义和函数的区别

#include <stdio.h>
#include <stdlib.h>
int SQ(int y){ //函数,求y的平方
 return ((y)*(y));
}
int main() {
 int i = 1;
 while (i <= 5) {
 printf("%d^2= %d\n", (i-1), SQ(i++)); //i-1是因为i++先执行,执行完了i就变成了2
 // ||
 //printf("%d^2= %d\n", i, SQ(i));
 //i=i+1;
 }
 return 0;
}
output:
1^2= 1
2^2= 4
3^2= 9
4^2= 16
5^2= 25
//下面代码有问题
#include <stdio.h>
#define SQ(y) ((y)*(y))
int main(){
 int i=1;
 while(i<=5){ //这里相当于计算了1,3,5的平方
 //讲入循环3次
 //1 * 1 = 1, 3 * 3 = 9, 5 * 5 = 25
 // SQ(i++)宏调用展开((i++)*(i++))
 printf("%d^2= %d\n",i, SQ(i++)); //1*2 3*4 5*6
 }
 return 0;
}
output:
3^2= 2
5^2= 12
7^2= 30

预处理命令

| 空指令,无任何效果

数组

#include <stdio.h>
int main() {
 char array[6] = {'h', 'e', 'l', 'l', 'o'};
 char str[3] = {'h', 'e', 'l'};//修改版本 char str[4] = {'h', 'e', 'l','0円'};
 char str2[] = {'a','c','k};//这个后面系统也不会自动添加"0円',即同上str[3],
 
 //0円 表示字符串结束,之后的未知
 //输出array,系统会这样处理
 //从第一个字符开始输出,直到遇到0,円表示该字符串结束
 //printf("%s", array); 不出问题是因为array有六个空间,只使用了5个,默认在最后加上0円 
 printf("%s", str);
 //
}
output:
helhello //这里是因为最后没有0円结尾,所以会继续往后面遍历,直到在o后面检测到了0円
 内存 array:
|----| |----| |----| |----| |----| |----| |------|
|h | |e | |l | |l | |o | |0円 | |unkown| 
|----| |----| |----| |----| |----| |----| |------|
 内存 str:
|----| |----| |----| |------| |------| |------|
|h | |e | |l | |unkown| |unkown| |unkown|
|----| |----| |----| |------| |------| |------|
结论:如果在给某个字符数组赋值时,(1)赋给的元素的个数小于该数组的长度,则会自动在后面加'0円',表示字符串结束,(2)赋给的元素的个数等于该数组的长度,则不会自动添加'0円'

char arr[]="hello"
 内存 array:
|----| |----| |----| |----| |----| |----| |------|
|h | |e | |l | |l | |o | |0円 | |unkown| 
|----| |----| |----| |----| |----| |----| |------| //默认加上'0円'

字符数组指针

#include <stdio.h>
void main() {
//使用一个指针 p,指向一个字符数组
 char *p="hello";
 printf("pointer p->%s", p);
}
output:
pointer p->hello
 内存 array:
 
指针本身的地址0x1122 数组的地址0x1166 0x1167 0x1168 0x1169 0x116a 0x116b //数组是连续空间
 p -> 0x1166 ------> |----| |----| |----| |----| |----| |----| 
 |h | |e | |l | |l | |o | |0円 | 
 |----| |----| |----| |----| |----| |----| 

使用字符指针变量和字符数组两种方法表示字符串的讨论

char str[6]; //str实际是一个常量
str -> |----| |----| |----| |----| |----| |----| 
 | | | | | | | | | | | | 
 |----| |----| |----| |----| |----| |----| 
str="hello";//错误
str[0] = 'i';//ok

#include <stdio.h>
void main() {
 char *p="hello"; //1
 printf("p's intrinsical address:%p p->%p\n", &p, p);
 p="hello,world"; //2
 printf("p's intrinsical address:%p p->%p\n", &p, p);
 printf("pointer p->%s", p);
}
output:
p's intrinsical address:000000000061FE18 p->0000000000404000
p's intrinsical address:000000000061FE18 p->000000000040402A 
 //即用指针赋值的,所指向的地址不同
 //用指针赋值,也就是开辟另一个内存空间赋值,再把原来的回收销毁
 //p本身的地址不会变
pointer p->hello,world
intrinsical address:000000000061FE18
 |
 | 
 p -> |----| |----| |----| |----| |----| |----| //p->0000000000404000 = 1
 | | | | | | | | | | | | 
 |----| |----| |----| |----| |----| |----| 
 p -> |----| |----| |----| |----| |----| |----| //p->000000000040402A = 2 
 | | | | | | | | | | | | 
 |----| |----| |----| |----| |----| |----| 

二维数组 n维数组 //本质一维数组

#include <stdio.h>
int main() {
 int a[3][4]; //int a[3][3]= {{0,0,1},{1,1,1},{1,1,3}};
 for(int i =0;i<3;i++){
 for(int j = 0;j<4;j++){
 a[i][j] = 0; //二维数组全部赋值0
 }
 }
 //int a[4][6]={{0,0,0,0},{0,0,0,0},{0,0,0,0}}
 for(int i =0;i<3;i++){ //输出二维数组
 for(int j = 0;j<4;j++){
 printf("%d",a[i][j]);
 }
 printf("\n");
 }
 
 //二维数组的内存布局
 printf("Two-dimensional array a : first element address=%p\n", a);
 printf("Two-dimensional array a : a[0]addres=%p\n", a[0]);
 printf("Two-dimensional array a :[0][0]address=%p\n", &a[0][0]);
 //这三个是一样的
 printf("Two-dimensional array a :[O][1]addres=%p\n", &a[0][1]);
 //这个元素的地址是在前一个加上4个字节,int占四个字节
 
 //将二维数组的各个元素的地址输出及每行第一个元素的地址
 for (int i = 0; i < 3; i++) {
 printf("a[%d]address=%p\n", i, a[i]);
 for (int j = 0; j < 4; j++) {
 printf("a[%d][%d]address=%p\n", i, j, &a[i][j]);
 }
 printf("\n");
 }
 return 0;
}
a -> |----| |----| |----| |----|
 | | | | | | | | 
 |----| |----| |----| |----|
 
 |----| |----| |----| |----| 
 | | | | | | | | 
 |----| |----| |----| |----| 
 
 |----| |----| |----| |----| 
 | | | | | | | | 
 |----| |----| |----| |----| 
output:
0000
0000
0000
Two-dimensional array a : first element address=000000000061FDE0
Two-dimensional array a : a[0]addres=000000000061FDE0
Two-dimensional array a :[0][0]address=000000000061FDE0
Two-dimensional array a :[O][1]addres=000000000061FDE4
a[0]address=000000000061FDD0
a[0][0]address=000000000061FDD0
a[0][1]address=000000000061FDD4
a[0][2]address=000000000061FDD8
a[0][3]address=000000000061FDDC
//C + 4 =わ 12 +たす 4 =わ 16 =わ 0;
a[1]address=000000000061FDE0
a[1][0]address=000000000061FDE0
a[1][1]address=000000000061FDE4
a[1][2]address=000000000061FDE8
a[1][3]address=000000000061FDEC
//C + 4 =わ 12 +たす 4 =わ 16 =わ 0;
a[2]address=000000000061FDF0
a[2][0]address=000000000061FDF0
a[2][1]address=000000000061FDF4
a[2][2]address=000000000061FDF8
a[2][3]address=000000000061FDFC
Process finished with exit code 0

二维数组实例

#include <stdio.h>
int main(){
 int map[3][3]= {{0,0,1},{1,1,1},{1,1,3}};
 //sizeof(map) = 整个数组的大小 9*4 = 36
 //sizeof(map[0] = map中第一行的大小 3*4 = 12
 int rows = sizeof(map) / sizeof(map[0]);//整个数组的大小/第一行的大小
 printf("rows=%d\n",rows);
 int cols = sizeof(map[0]) / sizeof(int);//第一行的大小/类型大小
 printf("cols=%d\n",cols); //12/4=3
 //遍历二维数组
 for(int i = 0;i < rows;i++) {
 for (int j = 0; j < cols; j++) {
 printf("%d ", map[i][j]);
 }
 printf("\n");
 }
 //计算二维数组的和
 for(int i = 0;i < rows;i++) {
 for (int j = 0; j < cols; j++) {
 sum = sum + map[i][j];
 }
 }
 printf("sum = %d",sum);
 return 0;
 }
 
output:
rows=3
cols=3
001
111
113
sum = 9

二维数组注意事项

1. 可以只对部分元素赋值,未赋值的元素自动取"零"值
#include <stdio.h>
int main(){
 int a[4][5]= {{1},{2},{3},{1}};
 int i,j;
 for (i= 0; i<4; i++){
 for (j = 0; j<5 ; j++){
 printf("%d ",a[i][j]);
 }
 printf("\n");
 }
}
output:
1 0 0 0 0
2 0 0 0 0
3 0 0 0 0
1 0 0 0 0
2. 如果对全部元素赋值,那么第一维的长度可以不给出。比如:
int a[3][3]={1,2,3,4,5,6,7,8,9};
可以写为:
int a[][3]= {1,2,3,4,5,6,7,8,9};
不可以是 int a[3][]= {1,2,3,4,5,6,7,8,9};
3. 二维数组可以看作是由一维数组嵌套而成的;如果一个数组的每个元素又是一个数组,那么它就是二维数组。
二维数组a[3][4]可看成三个一维数组,它们的数组名分别为a[0]、a[1]、a[2]。
这三个一维数组都有4个元素,如,一维数组a[0]的元素为a[0][0]、a[0][1]、a[0][2]、a[0][3]

断点调试

变量的变化情况
#include <stdio.h>
int main(){
 int sum = 0;
 int i;
 for(i = 0; i < 10; i++) {
 sum += i;
 printf("i=%d\n", i);
 printf("sum=%d\n", sum);
 }
 printf("quit for\n");
}
数组越界异常
#include <stdio.h>
int main(){
 int arr[]={1,2,3,4,5};
 int i = 0;
 int len = sizeof(arr) / sizeof(int);
 for(i = 0; i<= len; i++){ //数组最大小标应该是len-1
 printf("arr[%d]=%d\n", i, arr[i]);
 }
}
output:
arr[0]=1
arr[1]=2
arr[2]=3
arr[3]=4
arr[4]=5
arr[5]=0 //越界 
函数体调用
#include <stdio.h>
double cal(int num1,int num2,char oper){
 double res = 0.0;
 switch(oper) {
 case '+' :
 res = num1 + num2;
 break;
 case '-':
 res = num1 - num2;
 break;
 case '*':
 res = num1 * num2;
 break;
 case '/':
 res = num1 / num2;
 break;
 default :
 printf("你的运算符有误~");
 }
 return res;
}
int main(){
 int n1 = 10;
 int n2 = 40;
 char oper ='+';
 double res = cal(n1,n2,oper);
 printf("res=%.2f", res);
 }

指针

#include <stdio.h>
int main(){
 int var[]={10,20,30};
 int i,*ptr;
 //正向遍历
 ptr = var;
 for(i=0;i<3;i++){
 printf("var[%d] address=%p\n",i,ptr);
 printf("value: var[%d]=%d\n",i,*ptr);
 ptr++;
 }
 //反向遍历
 ptr = &var[2];
 //若这里没有&,则Incompatible integer to pointer conversion assigning to 'int *' from 'int'; take the address with &
 //但是正向遍历是可以的,因为数组名就是首地址,即var代表的是一个地址
 for(i=3;i>0;i--) {
 printf("ptr address %p\n", ptr);
 printf("value:var[%d]=%d\n", i - 1, *ptr);
 ptr--;
 }
 return 0;
}
output:
var[0] address=000000000061FE04
value: var[0]=10
var[1] address=000000000061FE08
value: var[1]=20
var[2] address=000000000061FE0C
value: var[2]=30
//注 var[i]的地址和ptr地址是相同的
ptr address 000000000061FE0C
value:var[2]=30
ptr address 000000000061FE08
value:var[1]=20
ptr address 000000000061FE04
value:var[0]=10

指针数组

#include <stdio.h>
int main(){
 int var[]={10,20,30};
 int i, *ptr[3];
// for ( i = 0; i< 3; i++){
// printf("array address=%p\n",&var[i]); //数组的地址
// }
// for ( i = 0; i< 3; i++){
// printf("ptr[%d] address=%p\n",i,&ptr[i]); //指针本身的地址
// }
 for ( i = 0; i< 3; i++){
 ptr[i] = &var[i]; //把数组的地址分别赋值给数组指针中的地址1,地址2,地址3
 }
 for ( i = 0; i < 3; i++){
 printf("value of var[%d]=%d\n", i, *ptr[i] );//遍历指针数组,再用取值
 printf("array address=%p\n",ptr[i]); //指针数组存放的地址
 printf("ptr[%d] address=%p\n",i,&ptr[i]); //指针本身的地址
 }
 return 0;
}
自身地址 0x1133 0x1137 0x113B
var -> |----| |----| |----| 
 | 10 | | 20 | | 30 | 
 |----| |----| |----| 
 
自身地址 0x1122 0x1126 0x112A
ptr -> |-----| |-----| |-----| 
 |地址1| |地址2| |地址3| 
 |-----| |-----| |-----| 
赋值后
自身地址 0x1122 0x1126 0x112A
ptr -> |------| |------| |------| 
 |0x1133| |0x1137| |0x113B| 
 |------| |------| |------| 
output:
value of var[0]=10
array address=000000000061FE10
ptr[0] address=000000000061FDF0
value of var[1]=20
array address=000000000061FE14
ptr[1] address=000000000061FDF8
value of var[2]=30
array address=000000000061FE18
ptr[2] address=000000000061FE00
//数组地址相差4,指针地址相差8?

#include <stdio.h>
int main(){
 //指针数组
 char *books[] = {
 "one","two","three"
 };
 int i,len =3;
 for(i=0;i<len;i++){
 printf("books[%d] -> %s\n",i,books[i]);
 //注books[i],而不是*books[i]
 //如果是加*
 //应该是
 //int num = 10;
 //int *ptr = &num;
 //printf("num = %d\n",*num);
 }
 
 //数组
 char book[] = {"onetwothree"};
 for(i=0;i<11;i++){
 printf("book[%d]=%c\n",i,book[i]);
 }
 return 0;
}
output:
books[0] -> one
books[1] -> two
books[2] -> three
book[0]=o
book[1]=n
book[2]=e
book[3]=t
book[4]=w
book[5]=o
book[6]=t
book[7]=h
book[8]=r
book[9]=e
book[10]=e

多重指针

pointer2 pointer1 Variable
|--------| |--------| |-------|
|address2| ----> |address1| ----> | value |
|--------| |--------| |-------|
 二级指针 一级指针
 
通过pointer1取值则*pointer1
通过pointer2取值则**pointer2(*pointer2 = address1)

#include <stdio.h>
int main (){
 int var;
 int *ptr; //一级指针
 int **pptr; //二级指针
 int ***ppptr;//三级指针
 var = 3000;
 ptr = &var; //var变量的地址赋值给ptr
 pptr = &ptr; //把ptr的地址赋值给pptr
 ppptr = &pptr;//把pptr的地址赋值给ppptr
 //var的地址,var存放变量
 printf("var's address =%p,var =%d\n",&var,var);
 
 //ptr指针本身的地址,ptr存放的地址
 printf("ptr's intrinsical address =%p,ptr's address=%p,*ptr = %d\n",&ptr,ptr,*ptr );
 
 //pptr指针本身的地址,pptr存放的地址
 printf("pptr's intrinsical'= %p,pptr's address=%p,**pptr = %d\n",&pptr,pptr,**pptr);
 
 //ppptr指针本身的地址,ppptr存放的地址
 printf("ppptr's intrinsical'= %p,ppptr's address=%p,***pptr = %d\n",&ppptr,ppptr,***ppptr);
 return 0;
}
output:
var's address =000000000061FE1C,var =3000
//var的地址,var存放变量
ptr's intrinsical address =000000000061FE10,ptr's address=000000000061FE1C,*ptr = 3000
//ptr指针本身的地址,ptr存放的地址
pptr's intrinsical'= 000000000061FE08,pptr's address=000000000061FE10,**pptr = 3000
//pptr指针本身的地址,pptr存放的地址
ppptr's intrinsical'= 000000000061FE00,ppptr's address=000000000061FE08,**pptr = 3000
//ppptr指针本身的地址,ppptr存放的地址
pptr 地址:000000000061FE08 ptr 地址:000000000061FE10 var 地址:000000000061FE1C
|----------------| |----------------| |-------|
|000000000061FE10| ----> |000000000061FE1C| ----> | 3000 |
|----------------| |----------------| |-------|
 二级指针 一级指针
 
 |
 |
 |
 ppptr 地址:000000000061FE00
|----------------| 
|000000000061FE08| 
|----------------| 
三级指针 

传递指针(地址)给函数

//传地址或指针给指针变量
#include <stdio.h>
void test2(int *p); //函数声明,接收int *
int main(){
 int num=90;
 int *p = &num; //将num的地址赋值给p
 test2(&num); //传地址 第一种 num----->[90] 自身地址:0x1122 取用num自身地址:0x1122
 printf("\nmain(),num=%d" , num);
 test2(p); //传指针 第二种 p-----> [0x1122] 自身地址:0x1133 取用p存放的地址
 printf("\nmain(),num=%d" , num);
 return 0;
}
void test2(int *p){ //函数体
 *p += 1; //*p = num的值,*取值
}
output:
main(),num=91 //调用第一种方法
main(),num=92 //调用第二种方法
内存:
text2栈:
p-----> [0x1122] 自身地址:0x1166
main栈:
num----->[90] 自身地址:0x1122 //调用text2后num----->[91]
p-----> [0x1122] 自身地址:0x1133

//传数组给指针变量
//数组名本身就代表该数组首地址,因此传数组的本质就是传地址。
#include <stdio.h>
//函数声明:函数在主函数下面
double getAverage(int *arr,int size);
double getAverage2(int *arr,int size);
int main() {
 /*带有5个元素的整型数组*/
 int balance[5] = {10, 20, 30, 40, 50};
 double avg;
 /*传递一个指向数组的指针作为参数*/
 avg = getAverage2(balance, 5);
 /*输出返回值*/
 printf("Average value is: %f\n", avg);
 return 0;
}
//arr是一个指针
double getAverage(int *arr, int size) {
 int i, sum = 0;
 double avg;
 for (i = 0; i < size; ++i) {
 //arr[0] = arr + 0 int的字节
 //arr[1] = arr + 1 int的字节(4)
 //arr[2] = arr + 2 int的字节(8)
 //....
 
 sum += arr[i]; //数组下标
 //printf("arr 1 address is %p\n",&arr[i]);
 //printf("arr 2 address is %p\n",arr);
 }
 avg = (double) sum / size;
 return avg;
}
//arr是一个指针
double getAverage2(int *arr, int size) {
 int i, sum = 0;
 double avg;
 for (i = 0; i < size; ++i) {
 sum += *arr; 
 arr++; //指针的自增运算
 //printf("arr 1 address is %p\n",&arr[i]);//错误的,
 //这里的arr是指针,如果这的arr[i] 改成arr[0]正确了
 
 printf("arr 1 address is %p\n",&arr[0]);
 //||
 printf("arr 2 address is %p\n",arr);
 }
 avg = (double) sum / size;
 return avg;
}
output:
两种方式的地址不一样
getAverage 
arr 1 address is 000000000061FE00
arr 1 address is 000000000061FE04
arr 1 address is 000000000061FE08
arr 1 address is 000000000061FE0C
arr 1 address is 000000000061FE10
//&arr[i] 取出每一个的地址
arr 2 address is 000000000061FE00
arr 2 address is 000000000061FE00
arr 2 address is 000000000061FE00
arr 2 address is 000000000061FE00
arr 2 address is 000000000061FE00
//arr全部一样是因为这种方式是通过数组下标来遍历,所以取地址只会取第一个的地址,所以不会改变
Average value is: 30.000000
getAverage2
arr 1 address is 000000000061FE04
arr 1 address is 000000000061FE0C
arr 1 address is 000000000061FE14
arr 1 address is 000000000061FE1C
arr 1 address is 000000000061FE24
//&arr[i] 取出每一个的地址 但是为什么是+8?
arr 2 address is 000000000061FE04
arr 2 address is 000000000061FE08
arr 2 address is 000000000061FE0C
arr 2 address is 000000000061FE10
arr 2 address is 000000000061FE14
//通过指针的自增来取地址
Average value is: 30.000000
改正后:
arr 1 address is 000000000061FE00
arr 2 address is 000000000061FE00
arr 1 address is 000000000061FE04
arr 2 address is 000000000061FE04
arr 1 address is 000000000061FE08
arr 2 address is 000000000061FE08
arr 1 address is 000000000061FE0C
arr 2 address is 000000000061FE0C
arr 1 address is 000000000061FE10
arr 2 address is 000000000061FE10
getAverage2栈
arr----->[0x1122] 自身地址0x1133 //arr指针存放的是数组balance第一个元素的地址
main栈
balance ----> {10[0x1122], 20, 30, 40, 50};
avg = getAverage2(balance, 5);

返回指针的函数

#include <string.h>
#include <stdio.h>
char *strlong(char *str1, char *str2){
 printf("str1's lenth is %d,str2's lenth is%d\n", strlen(str1), strlen(str2));
 if(strlen(str1) >= strlen(str2)){
 return str1;
 }else{
 return str2;
 }
}
int main(){
 char str1[30], str2[30], *str;
 printf("Please input 1st str:");
 gets(str1); // get = scanf
 printf("Please input 2nd str:");
 gets(str2);
 str = strlong(str1, str2);
 printf("Longest string: %s ", str);
 return 0;
}
output:
Please input 1st str:hello
Please input 2nd str:world
str1's lenth is 5,str2's lenth is5
Longest string: hello

#include <string.h>
#include <stdio.h>
int *func(){
 int n = 100; //局部变量
 return &n;
}
int main(){
 int *p = func(); //func返回指针
 int n;
 n = *p;
 printf("value = %d\n", n);//不一定能输出100,因为func栈在使用之后会被删除,那么指针p->func栈中n的地址(整个func栈被销毁)无效
 //根据下面第二点,如果没人使用func函数栈这块内存可以访问到n值
 // 但如果有人使用func函数栈这块内存,那么就访问不到n值
 return 0;
}
output:
Process finished with exit code -1073741510 (0xC000013A: interrupted by Ctrl+C)
//报错

#include <string.h>
#include <stdio.h>
int *func(){
 static int n = 100; //如果这个局部变量是static性质的,那么n存放数据的空间在静态数据区
 return &n;
}
int main(){
 int *p = func(); //func返回指针
 int n;
 n = *p;
 printf("value = %d\n", n);//输出100
 return 0;
}
output:
value = 100 //解决第一点的问题

-------------------------------------------------
| 计算机内存 |
| |
| 栈区---局部变量 |
| |
| 堆区---malloc函数动态分配的数据,放在堆 |
| |
| 静态存储区/全局区---全局变量 |
| ---静态数据 |
| |
| 代码区---存放代码 |
-------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
int *Array(){
 static int arr[10];//存放于静态数据区
 int i = 0;
 for(i=0;i<10;i++){
 arr[i] = rand();
 }
 return arr;
}
int main(){
 int *p = Array();//p 指向Array生成的数组的首地址(即第一个元素的地址)
 int i = 0;
 for (int i = 0; i < 10; ++i) {
 printf("%d\n",p[i]);
 //printf("%d\n",*(p+i));
 }
 printf("array address is %p",p);
 return 0;
}
output:
41
18467
6334
26500
19169
15724
11478
29358
26962
24464
array address is 0000000000407040

函数指针 (指针函数的指针)

函数指针的定义

returnType (*pointerName)(param list);
1) returnType为函数返回值类型
2) pointerName 为指针名称
3) param list为函数参数列表
4)参数列表中可以同时给出参数的类型和名称,也可以只给出参数的类型,省略参数的名称
5)注意( )的优先级高于*,第一个括号不能省略,如果写作returnType *pointerName(param list);就成了函数原型,它表明函数的返回值类型为returnType *(指针类型)

用函数指针来实现对函数的调用,返回两个整数中的最大值.
#include <stdio.h>
int max(int a, int b);
int main(){
 int x, y, maxVal;
 int (*pmax)(int, int) = max;
 //函数指针:
 //名字 pmax
 //int 表示 该函数指针指向的函数是返回int类型
 //(int, int) 表示 该函数指针指向的函数形参是接受两个int
 //在定义函数指针式,也可以写上形参名。如 int (*pmax)(int a, int b) = max;
 printf("Input two numbers:");
 scanf("%d %d",&x, &y);
 
 maxVal = (*pmax)(x, y);//= maxVal = pmax(x, y);
 //(*pmax)(x, y)通过函数指针调用 函数
 
 printf("Max value: %d\n", maxVal);
 
 printf("function's address is %p",&pmax);
 //函数的地址
 printf("pointer's address is %p",pmax);
 //函数指针的地址
 return 0;
}
int max(int a, int b){
 return a>b ? a : b;
}
output:
Input two numbers:20
30
Max value: 30
function's address is 00000000004015DF
//函数的地址
pointer's address is 000000000061FE08
//函数指针的地址

-------------------------------------------------
| 计算机内存 |
| |
| 栈区---局部变量 |
| |
| 堆区---malloc函数动态分配的数据,放在堆 |
| |
| 静态存储区/全局区---全局变量 |
| ---静态数据 |
| |
| 代码区---存放代码 |
-------------------------------------------------
代码区:
int max(int a, int b){
 return a>b ? a : b;
}
栈区:
int (*pmax)(int, int) = max;
pmax(指针)->函数(max函数)

回调函数(函数指针套娃)--callback

#include <stdio.h>
#include <stdlib.h>
//回调函数
//int (*f)(void)
//f = 函数指针,它可以接受的函数是:返回int,没有形参
//f 在这里被initarray调用,充当了回调函数的角色
void initArray(int *array, int arraySize, int (*f)(void)) {
 int i;
 for (i = 0; i < arraySize; i++)
 array[i] = f();//通过函数指针调用getNextRandomvalue f() = (*f)()
}
//获取随机值
int getNextRandomvalue(void){
 return rand();//rand 系统函数,返回一个随机整数
 }
int main(){
 int array[10], i; //定义一个int型数组和int
 //调用initArray函数
 //传入一个函数名 getNextRandomvalue(地址),需要函数指针接受
 initArray(array, 10, getNextRandomvalue);
 //输出复制后的数组
 for (i = 0; i < 10; i++) {
 printf("%d\n", array[i]);
 }
 return 0;
}
output:
41
18467
6334
26500
19169
15724
11478
29358
26962
24464

空指针

int *p = NULL; √
int *p; ×ばつ

动态内存分配

-------------------------------------------------
| 计算机内存 |
| |
| 栈区---局部变量 |
| |
| 堆区---malloc函数动态分配的数据,放在堆 |
| |
| 静态存储区/全局区---全局变量 |
| ---静态数据 |
| |
| 代码区---存放代码 |
-------------------------------------------------

内存动态分配的相关函数

1. 头文件#Include <stdlib.h> 声明了四个关于内存动态分配的函数
2. 函数原型void * malloc (usigned int size) //m emory alloc aiton
 malloc = m + alloc 
 
- 作用――在内存的动态存储区(堆区)中分配一个长度为size的连续空间。
- 形参size的类型为无符号整型,函数返回值是所分配区域的第一个字节的地址,即此函数是一个指针型函数,返回的指针指向该分配域的开头位置。
- malloc(100);开辟100字节的临时空间,返回值为其第一个字节的地址
3. 函数原型void *calloc (unsigned n,unsigned size)
- 作用――在内存的动态存储区中分配n个长度为size的连续空间,这个空间一般比较大,足以保存一个数组
- 用calloc函数可以为一维数组开辟动态存储空间,n为数组元素个数,每个元素长度为size.
- 函数返回指向所分配域的起始位置的指针;分配不成功,返回NULL。
- p = calloc(50,4);// 开辟50*4个字节临时空间,把起始地址分配给指针变量p
4. 函数原型: void free (void *p)
- 作用――释放变量p所指向的动态空间,使这部分空间能重新被其他变量使用。
- p是最近一次调用calloc或malloc函数时的函数返回值
- free函数无返回值
- free(p);//释放p所指向的已分配的动态空间
5. 函数原型void *realloc (void *p, unsigned int size)
- 作用――重新分配malloc或calloc函数获得的动态空间大小,将p指向的动态空间大小改变为size(后面直接加空间),p的值不变,分配失败返回NULL
- realloc(p,50);//将p所指向的已分配的动态空间改为50字节
6. 返回类型说明
C 99标准把以上malloc,calloc,realloc函数的基类型定为void类型,这种指针称为无类型指针(typeiesspointer),即不指向哪一种具体的类型数据,只表示用来指向一个抽象的类型的数据,即仅提供一个纯地址,而不能指向任何具体的对象。
void指针类型(不能用*)
C 99允许使用基类型为void的指针类型。可以定义一个基类型为void的指针变量(即void *型变量),它不指向任何类型的数据。请注意:不要把"指向void类型"理解为能指向"任何的类型"的数据,而应理解为"指向空类型"或"不指向确定的类型"的数据。在将它的值赋给另一指针变量时由系统对它进行类型转换,使之适合于被赋值的变量的类型。例如:
int a = 3; //定义a为整型变量
int * pl = &a; //pl指向int型变量
char * p2; //p2指向char型变量
void * p3; //p3为无类型指针变量(基类型为void型)
p3=(void * )pl; //将p1的值转换为void *类型,然后赋值给p3
p2=(char * )p3, //将p3的值转换为char *类型,然后赋值给p2
printf("%d", * pl); //合法,输出a的值
p3= &a; 
printf("%d", * p3); //错误,p3是无指向的,不能指向a
说明:当把void指针赋值给不同基类型的指针变量(或相反)时,编译系统会自动进行转换,不必用户自己进行强制转换(仅限C99) 。例如:
p3= &a;
相当于"p3=(void * )&a;",赋值后p3得到a的纯地址,但并不指向a,不能通过*p3输出a的值。

实例

#include <stdio.h>
#include <stdlib.h>
int main() {
 void check(int *); //函数声明:因为函数在下面
 int *p, i;
 p = (int *) malloc(5 * sizeof(int)); //在堆区开辟20个字节的空间-即5个int
 //C99下等同于p = malloc(5 * sizeof(int));
 for (i = 0; i < 5; i++)
 scanf("%d", p + i);
 check(p);
 free(p);//销毁堆区
 return 0;
}
void check(int *p) {
 int i;
 printf("failing grade:"); //不及格的成绩
 for (i = 0; i < 5; i++) {
 if (p[i] < 60) {
 printf(" %d ", p[i]);
 }
 }
}
栈
check 栈
p----->[0x1122] 本身地址0x1199
mian 栈
p----->[0x1122] 本身地址0x1199
i----->[]
堆
地址:0x1122
20个字节-> 5个int
|----| |----| |----| |----| |----| 
|90 | |80 | | 30 | |20 | |60 | 
|----| |----| |----| |----| |----| 
output:
90
80
30
20
60
failing grade: 30 20

动态分配内存注意事项

指针一览

结构体

传统方法:不利于数据的管理和维护,猫的三种属性是一个整体,传统方法拆开了这种联系。
//单变量
void main(){
 char cat1Name[10] = "小白";
 int car1Age = 3;
 char car1Colar[10] = "白色;
 //....
}
//数组
void main(){
 char *catsName[2] = {
 "小白",
 "小花"
 }
 int *catsAge[2] = {
 3,
 100
 }
}
//结构体
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Cat{ //结构体
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
};
int main() {
 //使用结构体创建变量
 struct Cat cat1; // 类型于 struct Cat = int, cat1 = num
 struct Cat cat2;
 //给结构体的各个成员赋值
 cat1.name = "lucy";
 cat1.age = 3;
 cat1.color = "white";
 cat2.name = "lily";
 cat2.age = 100;
 cat2.color = "black";
 //输出两只猫的信息
 printf("the frist cat:name = %s,age = %d, color = %s\n",cat1.name,cat1.age,cat1.color);
 printf("the twice cat:name = %s,age = %d, color = %s\n",cat1.name,cat1.age,cat1.color);
 //输入名字,输出其他信息 含部分错误->已调试完成
 char Name[] = "";
 scanf("%s",Name);
 printf("%s\n",Name);
 //比较字符串是否相等,不能直接使用==
// if(Name == cat1.name)
// printf("lucy :name = %s,age = %d, color = %s\n",cat1.name,cat1.age,cat1.color);
 if(strcmp(Name, cat1.name) == 0)
 printf("cat: \nname = %s,age = %d, color = %s\n",cat1.name,cat1.age,cat1.color);
 else if(strcmp(Name, cat2.name) == 0)
 printf("cat: \nname = %s,age = %d, color = %s\n",cat2.name,cat2.age,cat2.color);
 else
 printf("no this cat");
 return 0;
}

结构体和结构体变量的区别和联系

int num1 ; //int 是数据类型,而num1 是一个具体的int变量 
struct Cat cat1;//struct Cat 是结构体数据类型,而cat1 是一个struct Cat变量 

结构体内存布局

struct Cat cat1;
cat1.name = "lucy";
cat1.age = 3;
cat1.color = "white";
计算机内存
cat1 ----->|-------|
 |char * | name
 |-------|
 |int 3 | age
 |-------| 
 |char * | color
 |-------|

声明结构体

struct 结构体名称 {
 成员列表;
};
如
struct Cat{ //结构体
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
 //..
 //成员可以是结构体(套娃)
};
1)从叫法上看:有些书上称为成员,有些书说结构体包含的变量
2)成员是结构体的一个组成部分,一般是基本数据类型、也可以是数组、指针、结构体等。比如我们前面定义Cat结构体的int,age就是一个成员。

注意事项细节说明

#include <stdio.h>
struct Cat{ //结构体
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
};
int main() {
 struct Cat cat1;
 printf("the frist cat:name = %s,age = %d, color = %s\n",cat1.name,cat1.age,cat1.color);
 return 0;
}
output:
Process finished with exit code -1073741819 (0xC0000005)//异常

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Cat{ //结构体
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
};
int main() {
 struct Cat cat1; // 类型于 struct Cat = int, cat1 = num
 struct Cat cat2;
 
 cat1.name = "lucy";
 cat1.age = 3;
 cat1.color = "white";
 cat2.name = "lily";
 cat2.age = 100;
 cat2.color = "black";
 //修改cat1中信息不影响cat2信息
 return 0;
}

创建结构体和结构体变量

struct Cat{ //结构体
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
};
struct Cat cat1, cat2;
//定义了两个变量cat1和cat2,它们都是cat类型,都由3个成员组成
//注意关键字struct不能少

struct Cat{ //结构体
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
}cat1,cat2;
//在定义结构体Cat的同时,创建了两个结构体变量cat1,cat2

struct { //没有写Cat
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
}cat1,cat2;
cat1.name = "lucy";
cat1.age = 3;
.....
//该结构体数据类型,没有名。即匿名结构体
//cat1,cat2就是该结构体的两个变量
//但只能使用cat1,cat2这两个变量

成员的获取和赋值

struct Cat{ 
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
}cat1,cat2;
//分别赋值
cat1.name = "lucy";
cat1.age = 3;
cat1.color = "white";
//统一整体赋值
//1.创建结构体的时候直接赋值
struct Cat{ 
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
}cat1 = {"lucy",3,"black"};
//2.在main函数里创建并赋值
struct Cat{ 
 char * name; //名字 指针->字符串
 int age; //年龄
 char * color; //颜色
};
void main(){
 //在定义结构体变量时,需要一一对应。
 struct Cat cat1 = {"lucy",3,"black"};//√
 struct Cat cat2;
 cat2 = {"lucy",3,"black"×ばつ
 
}

实例

#include <stdio.h>
struct Dog{ //结构体
 char * name;//char name[10]
 int age;
 double weight;
};
char * information(struct Dog dog){
 static char info[50];//局部静态变量,如果不使用static,将会在information函数栈销毁时,找不到所对应的变量
 sprintf(info,"name=%s,age=%d,weight=%.2f\n",dog.name,dog.age,dog.weight);
 //sprintf 发送格式化输出到 str 所指向的字符串。
 dog.name = "lucy"; //由于是值传递,不会对主函数中小狗的名字产生影响
 return info;
}
int main() {
 struct Dog dog= {"jack",3,20}; //创建结构体变量
 char * info = NULL;
 info = information(dog); //结构体默认是值传递
 printf("dog's information = %s",info);
 printf("dog's name = %s",dog.name); //名字依然是jack,不是lucy
 return 0;
}

盒子案例

#include <stdio.h>
struct Box{ //结构体
 int length;
 int weight;
 int height;
 int volume;
};
void Volume(struct Box box){
 int volume = box.weight*box.length*box.height;
 box.volume = volume;
 printf("this box's volume = %d",box.volume);
}
int main(){
 //struct Box box = {2,3,4};
 struct Box box;
 scanf("%d",&box.length);
 scanf("%d",&box.weight);
 scanf("%d",&box.height);
 Volume(box);
 //printf("this box's volume = %d",box.volume);
 return 0;
}

景区门票案例

#include <stdio.h>
#include <string.h>
struct Visitor{ //结构体
 char name [10];
 int age;
 int price;
};
//因为结构体默认是值传递,会拷贝一份完整数据,效率较低因此,
//为了提高效率,我们直接接收地址(指针)
void Price(struct Visitor * visitor){
 // 以下visitor-> = (*visitor)
 if( visitor->age > 18){
 (*visitor).price = 20;
 }
 else{
 (*visitor).price = 0;
 }
 printf("name:%s\n",(*visitor).name);
 printf("Price:%d\n",(*visitor).price);
}
int main(){
 struct Visitor visitor;
 while (1){
 printf("input visitor's name\n");
 //其中name不加&是因为name定义的是一个字符数组,地址传递。
 //其中age加&是因为age定义的是int,值传递。
 scanf("%s",visitor.name);
 if(strcmp("n",visitor.name)==0){
 break;
 };
 printf("input visitor's age\n");
 scanf("%d",&visitor.age);
 printf("this visitor price is\n");
 //取地址是因为Price函数参数是指针
 Price(&visitor);
 return 0;
 }
 printf("quit process");
}
 
output:
input visitor's name
jack
input visitor's age
20
this visitor price is
name:jack
Price:20
input visitor's name
n
quit process

共用体

传统方式
定义结构体,根据人员的职业,使用对应的成员变量。
struct Person {
char name[20];
int num;
char sex;
char profession;
float score; //学生使用score
char course[20];//老师使用course
};
传统方式的问题分析:会造成空间的浪费,比如学生只使用score,但是也占用了course成员的20个字节.
解决方案:
1. 做struct Stu和struct Teacher但如果职业很多,就会对应多个结构体类型,不利于管理
2. 使用共用体

共用体

union 共用体名 {
 成员列表
};

定义共同体类型和共同体变量的三种方式(类似于结构体)

1. 先定义共用体,再定义共同体变量
union union1{ //共同体
 int n;
 char ch;
 double f;
};
int main(){
 union union1 a,b,c;
}
2.定义共用体的同时,定义共同体变量
union union1{ //共同体
 int n;
 char ch;
 double f;
}a,b,c;
3.只使用一次共同体 
union { //共同体
 int n;
 char ch;
 double f;
}a,b,c;

快速入门

#include <stdio.h>
union information{ //共同体:三个成员
 int age; //4个字节
 char name; //1个字节
 short salary; //2个字节 7个字节,但是输出字节大小为4,这说明三个成员不是占用不同的空间
 //实则是共享数据空间,以最大的数据类型为准,如果删除int age。那么占用空间为2个字节
};
int main(){
 union information info;//定义了一个共同体变量 info
 printf("%d,%d\n", sizeof(info), sizeof(union information)); //输出info和information占用空间
 info.age = 0x40; //16进制 0x40=64
 printf("%d, %c,%d\n", info.age, info.name, info.salary);//输出结果为64, @,64。由于共享空间,可能会导致其他成员的值改变
 //但是在结构体中,如果只赋值一个会报错。
 info.name= '9';
 printf("%d, %c,%d\n", info.age, info.name, info.salary);
 info.salary = 0x2059;
 printf("%d, %c,%d\n", info.age, info.name, info.salary);
 info.age = 0x3E25AD54;
 printf("%d, %c,%d\n", info.age, info.name, info.salary);
 return 0;
}
output:
4,4
64, @,64
57, 9,57
8281, Y,8281
1042656596, T,-21164
内存:
int占四个字节,一个字节占8bit即8位
info(四个字节:因为int是四个字节占用最大)--------> __0000 0000__ __0000 0000__ __0000 0000__ __0100 0000__
int age; //4个字节 即占用4个格子(从右往左)
char name; //1个字节 即占用1个格子
short salary; //2个字节 即占用2个格子
当执行info.age = 0x40; 0x40(16进制)即0100 0000(2进制).(其中0x代表找个数是16进制)
输出info.age = 0100 0000转10进制就变成了64.
输出info.name = 0100 0000转ASCII码就变成了@.
输出info.short = 0100 0000转10进制就变成了64.
info(四个字节:因为int是四个字节占用最大)--------> __0000 0000__ __0000 0000__ __0000 0000__ __0011 1001__
当执行info.name= '9'; 字符9对应的十进制为57 即0011 1001
输出info.age = 0011 1001转10进制就变成了57.
输出info.name = 0011 1001转ASCII码就变成了9.
输出info.short = 0011 1001转10进制就变成了57.
info(四个字节:因为int是四个字节占用最大)--------> __0000 0000__ __0000 0000__ __0010 0000__ __0101 1001__
当执行info.salary = 0x2059; 0x2059(16进制)即0010 0000 0101 1001 (2进制).(一位数=4bit即4位)
输出info.age = 0011 1001转10进制就变成了8281.
输出info.name = 0011 1001转ASCII码就变成了Y.
输出info.short = 0011 1001转10进制就变成了8281.
info(四个字节:因为int是四个字节占用最大)--------> __0011 1110__ __0010 0101__ __1010 1101__ __0101 0100__
当执行info.age = 0x3E25AD54;; 0x2059(16进制)即0011 1110 0010 0101 1010 1101 0101 0100(2进制).(一位数=4bit即4位)
输出info.age = 0011 1110 0010 0101 1010 1101 0101 0100转10进制就变成了1042656596.
输出info.name = 0011 1110 0010 0101 1010 1101 0101 0100转ASCII码就变成了T.
输出info.short = --short只占两个字节-- 1010 1101 0101 0100转10进制就变成了44372.
//实际上不是直接去掉前面两位,当两个字节占满后,读取前面的之后会溢出
//short的范围 为-32768~32767
//实际输出为-21164

#include <stdio.h>
#define Total 2 //人员总数
union Sc {
 float score;
 char course[20];
};
struct Person{
 char name[20]; //姓名
 int num; //编号
 char sex; //性别 f->女性,m->男性
 char profession;//职业 s->学生.t->老师
// union{
// float score;//得分
// char course[20]
// }sc;//sc是一个共同体变量
 union Sc sc;
};
int main(){
 int i;
 struct Person persons[Total];//定义了一个结构体数组
 //输入人员信息
 for(i=0;i<Total;i++){
 printf("input information:name,num,sex,profession(f->female,m->male.s->student.t->teacher):\n");
 //对于数字和字符要用&
 //输出时使用空格
 scanf("%s %d %c %c",persons[i].name,&(persons[i].num),&(persons[i].sex),&(persons[i].profession));
 if(persons[i].profession == 's'){ //如果是学生
 printf("input score\n");
 scanf("%f",&persons[i].sc.score);
 }
 else{
 printf("input course\n");//如果是老师
 scanf("%f",&persons[i].sc.course);
 }
 }
 fflush((stdin));
 //输出人员信息
 printf("name\tnum\tsex\tprofession\tscore/course\n");
 for (int i = 0; i < Total; i++) {
 if(persons[i].profession == 's'){ //如果是学生
 printf("%s\t%d\t%c\t%c\t\t%f\n",persons[i].name,persons[i].num,persons[i].sex,persons[i].profession,persons[i].sc.score);
 }
 else{//如果是老师
 printf("%s\t%d\t%c\t%c\t\t%f\n",persons[i].name,persons[i].num,persons[i].sex,persons[i].profession,persons[i].sc.course);
 }
 }
 return 0;
}
input information:name,num,sex,profession(f->female,m->male.s->student.t->teacher):
jack 10 f s
input score
90
input information:name,num,sex,profession(f->female,m->male.s->student.t->teacher):
lucy 20 f t
input course
chinese
name num sex profession score/course
jack 10 f s 90.000000
lucy 20 f t 0.000000