C语言学习基础篇

一.进入C语言的世界—HELLO WORLD!的生成

#include<stdio.h>
int main()
{
	printf("HELLO WORLD!");
	return 0;
}

代码初解：#代表预处理，stdio.h->std代表standard标准库 i代表input输入 o代表output h代表header头文件  int->integer整型  printf实现功能在屏幕打印对应内容

main函数是程序的入口，编译器系统都是从main 开始进行编译执行。意味着写代码必须要写main函数。

一个项目中可以写多个.c的源文件但是main函数有且只能有一个

main函数的基本写法：

int main()

{

       …//写自己的代码

        return 0; 

}

二.多样的数据类型

char            //字符数据类型    
short           //短整型
int               //整型
long            //长整型
long long    //更长的整型
float            //单精度浮点数
double        //双精度浮点数

利用机算机帮助我们解决实际问题时需要表示价格，名字等。而整型会存在四种类型，小数两种，其实是为了更加丰富的表达生活中的各种值以及节约空间。

每种类型的大小使用sizeof进行输入输出

#include<stdio.h>
int main()
{
	printf("%d\n", sizeof(char));//输出char字符的长度，1
	printf("%d\n", sizeof(short));//输出short字符的长度，2
	printf("%d\n", sizeof(int));//输出int字符的长度，4
	printf("%d\n", sizeof(long));//输出long字符的长度，4
	printf("%d\n", sizeof(long long));//输出long long字符的长度，8
	printf("%d\n", sizeof(float));//输出float字符的长度，4
	printf("%d\n", sizeof(double));//输出double字符的长度，8
	return 0;
}

代码运行效果：

 注意：换行符必须要写在双引号里面，%d被字符数据的大小取代被打印出来。 

1字节=8bit，1个bit位放一个0/1 

例如：小数不要求太高精度时可以使用float节约空间。直接写3.14， 编译器默认它是double类型，可以后面加一个f，即3.14f表示它是float类型。

三.格式控制符的简单应用:

%d—整型

%s—字符串型

%c—字符型

%p—打印地址，一般是十六进制

例如：

#include<stdio.h>
int main()
{
		char ch = 'A';
		char arr[4] = "lee";
		int num = 20;
		printf("%c\n", ch);
		printf("%s\n", arr);//打印整个字符串
		printf("%d\n", num);
		printf("%c\n", arr[0]);//打印字符串中的第一个字符
	return 0;

}

或者

#include<stdio.h>
char ch = 'A';//定义一个字符A，注意在定义字符的时候用单引号进行囊括
char arr[4] = "lee";//定义一个字符串，[]里面的数字要大于字符串的长度
int num = 20;//定义一个整型的变量num
int main()
{
		printf("%c\n", ch);
		printf("%s\n", arr);//打印整个字符串
		printf("%d\n", num);
		printf("%c\n", arr[0]);//打印字符串中的第一个字符
	return 0;

}

代码运行效果：

注意：

1.代码中的arr—>array数组（整个字符串），如果是需要输出字符串中的单个字符，需要确定输出的单字符在字符串中的位置，由于数组是从0开始计数，所以arr[0]代表数组（字符串）中的第一个数（字符），其余的以此类推。

2.如果是要打印的是单个字符，在定义char的时候使用的是单个引号；如果char定义的是字符串，那么使用的是双引号的定义。

四.变量和常量

1.定义变量的方法

类型 变量名 = 值

例如：

int age = 50；//定义年龄为50

float num = 23.6f；//定义一个浮点型的数据23.6

char ch = ’A‘；//定义一个单个的字符A

char arr[5] = "apple";  //定义一个字符串apple

2.变量的命名

命名要求：

1.只能由字母（包括大写和小写）、数字和下划线（ _ ）组成。

2.不能以数字开头。

3.长度不能超过63个字符。

4.变量名中区分大小写的。

5.变量名不能使用关键字。比如：char float。

3.变量的分类

1.局部变量：位于大括号里的

2.全局变量：在整个项目里的

例如：

#include<stdio.h>

int global = 2019;//全局变量

int main ()

{

        int local = 2018;//局部变量

        return 0;

}

注意：局部变量可以与全局变量同名。当局部变量和全局变量同名的时候，局部变量会被优先使用。就实现了变量覆盖。

例如：

#include <stdio.h>

int global = 2019;

int main()
{
        int global = 2020;
        printf("global = %d\n", global);
        return 0;
}

4.变量的作用域和生命周期

作用域

1. 局部变量的作用域是变量所在的局部范围

例如：

错误代码：

#include<stdio.h>
int main()
{
	{
		int b = 0;
	}
	printf("%d\n", b);
		float f = 2.3f;
	printf("%f\n", f);
	return 0;
}

由于需要打印出来的字符b没有在上面的大括号里面，所以程序无法识别b的含义，导致程序出错。

正确代码：

#include<stdio.h>
int main()
{
	{
		int b = 0;

		printf("%d\n", b);//b这个符号在大括号内才被识别出来，可以进行输出
	}
		float f = 2.3f;//float型的数字，在赋值的时要进行标识
	printf("%f\n", f);
	return 0;
}

字符b被囊括在有标明类型的大括号里面，使得b字符被识别出来，程序成功运行。

2.全局变量的作用域就是作用域整个工程，不同的源文件皆可以使用

例如：

a变量可以在右边的文件一用也可以在左边的文件二用，语法格式要求文件二在最前面加 extern int a，那么就可以使用这个变量了。

生命周期

变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段。

1.局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

2.全局变量的生命周期是：整个程序的生命周期。

5.常量

C语言中常量的分类：

1.字面常量：就是平时在代码里直接写出的‘a’，23等字符、数字。

例如：1.23    3.1415926 

2.const修饰的常变量：const是不变的的意思，在语法层面对变量进行修饰告诉编译器这个变量的值不能改变。

const int num=10；

num=20；//会报错，因为const修饰 num的值不能改变了

//注：但是它本质还是一个变量，如果有语法规定只能用常量的地方不能放 num，编译器默认它不符合语法。

const int num=10；

int arr[num];//报错，因为语法规定，数组定义[ ]内一定要用常量。

3.#define定义的标识符常量

#define P1 3.1415926//贯穿全体程序的变量、

4.枚举常量：

enum Sex
{
    Male,   
    Female, 
    Secret  
};

//

printf("%d\n", MALE); //结果为0

因为系统默认会给它们依次赋值0,1,2,3……，括号中的MALE,FEMALE,SECRET就是枚举常量 是常量就不能改。

#include<stdio.h>
#define P1 3.1415926//define定义的标识符常量
enum Sex//枚举常量，系统会给他们自动进行编号，从0，1，2~依次进行输出
{
	Male,   
	Female, 
	Secret  
};
int main( )
{
	const int num = 10;//const修饰的常变量，不能发生改变
	int shuzi = 20;//字面的常量
	printf("打印的常变量num=%d\n", num);
	printf("打印的P1=%f\n", P1);
	printf("打印的数字=%d\n", shuzi);
	printf("%d\n", Male);//输出0
	printf("%d\n", Female);//输出1
	printf("%d\n", Secret);//输出2
	return 0;
}

输出结果：

五.字符串、转义字符和注释

1.字符串的定义

由双引号引起来的一串字符称之为字符串字面值，简称字符串。

注：字符串的结束标志是一个\0的转义字符，在计算字符串长度的时候\0是结束标志，不计入字符串内容，如果直接创建一个字符串，系统自动在最后生成一个\0，用于标识字符串达到了末尾。

#include<stdio.h>
int main()
{
	char arr1[] = "bit";
	char arr2[] = { 'b','i','t' };
	char arr3[] = { 'b','i','t' ,'\0' };
	printf("%s\n", arr1);
	printf("%s\n", arr2);
	printf("%s\n", arr3);
}

运行结果：

原因分析：

arr1在创建时为字符串，系统自动为他添加\0，数组长度为4，%s打印字符串的原理是遇到\0就停下，所以值打印出了bit

arr2创建的不是字符串，系统没有添加\0，数组长度为3，%s打印字符串时功能原理是会遇到\0自动停下。bit后面不确定是什么内容，所以会打印出乱码直到遇到\0才会结束。

arr3创建时虽然不是字符串，系统没有自动添加'\0'，但末位加了'\0'。%s打印字符串时功能原理是会遇到'\0'自动停下，所以最后打印出了bit。

2.字符串的打印结果及其分析

代码1：打印abc\0def字符

#include<stdio.h>
#include<string.h> 
int main()
{
	printf("abc\0def");

	return 0;
}

运行结果：

原因：

printf 函数用于输出字符串,然而，字符串中的 \0 是一个空字符，它在 C 语言中用来表示字符串的结束。因此，当 printf 函数遇到 \0 时，它会认为字符串已经结束，并且不会打印 \0 后面的任何字符,"def" 部分不会被打印出来，因为它紧随 \0 之后，而 \0 已经告诉 printf 函数字符串结束了。

如果想打印出“def”部分需要将\0替换为其他的字符或者使用两个不同的字符串：

#include<stdio.h>
#include<string.h> 

int main()
{
    printf("abc%s", "def");

    return 0;
}

在这个修改后的代码中，printf 函数使用 %s 格式化字符串来打印两个字符串的连接。这样，输出将会是：

注：%s 是一个格式占位符，它告诉 printf 函数接下来要打印的是一个字符串。"def" 是传递给 printf 函数的参数，它将替换掉 %s。因此，printf 函数将打印出 "abc" 和 "def" 连接后的字符串 "abcdef"

代码2：打印字符串的长度

//字符串长度的输入输出
#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "bit";
	char arr2[] = { 'b','i','t' };
	char arr3[] = { 'b','i','t' ,'\0' };
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	printf("%d\n", strlen(arr3));
	return 0;
}

注：strlen 一个专门求字符串长度的库函数，使用时得包含头文件<string.h>。原理是遇到'\0'才
停止统计。同理，strlen(arr1)为3，strlen(arr2)为随机值不能确定什么时候遇到'\0'，strlen(arr3)
为3.

运行结果：

3.转义字符定义

为了展现出换行和空四格Tab键等含义，C语言里用转义字符来代表类似的含义。

例：

#include<stdio.h>
int main()
{
	printf("c:\code \t est.c");
	return 0;
}

注：这段代码的作用是在控制台上打印出字符串 "c:\code \t est.c"。这里的字符串包含了一个反斜杠 \ 和一个 t 字符，它们组合在一起形成了 \t 转义序列，表示一个制表符。

运行结果：

c:\code     est.c

转义字符的类型：

\a 警告字符，蜂鸣
\b 退格符
\f 进纸符
\n 换行
\r 回车
\t 水平制表符
\v 垂直制表符
\ddd ddd表示1~3个八进制的数字。 如： \130     对应字符X
\xdd dd表示2个十六进制数字。 如： \x30            对应字符0

#include<stdio.h>
int main()
{
	printf("c:\code \t est.c\n");
	printf("\130\n");
	printf("\x30");
	return 0;
}

运行结果：

注：X  因为130八进制转为十进制为88，根据 ASCII码表得知对应的为X

       0   因为30十六进制转为十进制为48，根据 ASCII码表得知对应的为0

\r:回车符，会覆盖掉前面的内容

#include<stdio.h>

int main()
{	//\r:回车符，会覆盖掉前面的内容
	printf("abc\rdef\rghi");//输出结果为ghi
	return 0;
}

4.其他特殊转义字符

还有一部分转义字符是为了避让误会让编译器正确打印相关内容在前面加\构成新释义

#include<stdio.h>
int main()
{
	printf("abc\\tf");//为了正确打印出\t，避免编译器认成制表符在前面加一个\

	return 0;
	
}

\? :     过去的编译器原来经常会有三字母词，例如？？）打印出来是 ]，？？（打印出来是[。

          为了 防止编译器认为？？是参与三字母的字母就在？前面加\。

#include<stdio.h>

int main()
{
	printf("%s\n","(are you ok??)");
	//(are you ok])某些编译器会打印出这个
	//printf("%s\n","(are you ok\?\?)")
	//如果不想把??)识别成],则输入上述结果，在?之前加入斜杠形成转义字符
	return 0;
}

\'    \“  同理，避免编译器认为是代码里的单引号或者双引号

#include <stdio.h>
int main()
{
    //问题1：在屏幕上打印一个单引号'，怎么做？
    //问题2：在屏幕上打印一个字符串，字符串的内容是一个双引号“，怎么做？
    printf("%c\n", '\'');
    printf("%s\n", "\"");
    return 0;
}

注：%c匹配的是单引号，%s匹配的是双引号

\\：用于表示一个反斜杠。防止他被解释为一个转义序列符

#include<stdio.h>

int main()
{	//\\:用于表示一个反斜杠。防止他被解释为一个转义序列符
	printf("abc\\0def");
	return 0;
}

思考计算：

#include <stdio.h>
#include <string.h>

int main()
{
    printf("%d\n", strlen("c:\test\628\test.c"));
    return 0;
}

5.注释

1. 代码中有不需要的代码可以直接删除，也可以注释掉。

2. 代码中有些代码比较难懂，可以加一下注释文字。

注释的两种风格：

1.C语言风格的注释 /*xxxxxx*/

不能嵌套注释，系统不会匹配对个/**/,只会找到最近的*/,并注释它之前的所有代码。

/*
调用add方法
*/

2.C++风格的注释//xxxxxxx

可以注释一行也可以注释多行

//调用Add函数，完成加法

六.选择语句

选择语句有两种实现，一种是if else，一种是switch

1.if-else语句

#include<stdio.h>

int main()
{	
	int input = 0;
	printf("加入比特\n");
	printf("要好好学习吗(1/0)?\n");
	scanf_s("%d", &input);
	if (input == 1)
	{
		printf("好offer\n");
	}
	else
	{
		printf("卖红薯\n");
	}
	return 0;
}
//注：1.在运行之前要进行input的初始化赋值
      2.scanf_s效果比scanf不容易出错
      3.scanf的格式是scanf("格式控制符", &变量名)

2.switch语句

#include<stdio.h>

int main()
{
	int day = 0;
	scanf_s("%d", &day);
	int n = 1;
	switch (day)
	{ 
	case 1:
		printf("星期1\n");
	break;
	case 2:
		printf("星期2\n");
	break;
	case3:
		printf("星期3\n");
	break;
	case 4:
		printf("星期4\n");
	break;
	case 5:
		printf("星期5\n");
	break;
	case 6:
		printf("星期6\n");
	break;
	case 7:
		printf("星期7\n");
	break;
	default:
		printf("输入错误");
	break;
	}
	return 0;
}

七.循环语句

1.while循环

#include<stdio.h>

int main()
{
	int line = 0;
	while(line<20000)
	{	

		printf("写代码:%d\n",line);
		line++;
	}

	if (line <= 20000)
	{
		printf("好offer\n");

	}
	else
	{
		printf("继续加油");

	}


	return 0;
}
//语法格式
//while(要循环满足的条件)
//     {
//                //循环要做的事
//      }

2.for循环

#include<stdio.h>

int main()
{	
	int i=0;
    for(i=0;i<10;i++)
    {
        printf("%d",i);
    }

    return 0;
}

3.do.....while....循环 

#include<stdio.h>

int main()
{	
	int i=0;
    do{
        printf("%d",i);
        i++;
      }
     while(i<10)
	 return 0;
}

八.函数

1.函数定义

函数是执行特定任务的一段代码块。函数定义告诉编译器函数的名称、返回类型、参数列表以及函数体。

2.函数结构

返回类型 函数名称(参数1类型 参数1名称, 参数2类型 参数2名称, ...)
{
    // 函数体
    // 这里是执行特定任务的代码
}

下面是一个简单的函数定义示例，该函数计算两个整数的和并返回结果：

#include<stdio.h>
int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}
int main()
{
	int n1 = 0;
	int n2 = 0;
	
	scanf_s("%d %d",&n1, &n2);
	int sum = Add(n1, n2);
	printf("%d\n", sum);
	return 0;
}

注：程序包含一个名为 Add 的函数，它接受两个整数参数 x 和 y，计算它们的和，并将结果返回。main 函数中，程序使用 scanf_s 函数从用户那里读取两个整数，调用 Add 函数计算它们的和，然后使用 printf 函数输出结果。

Add函数的简化写法：

int Add(int x,int y)
{
    return (x+y);
}

九.数组

要存储1-10数字，要怎么存储?

1.数组的定义

一组相同类型的元素的集合

int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };//定义一个整型数组，最多放十个元素

2.数组的下标

数组的每一个元素都有一个下标，下标是从0开始的。

数组可以通过下标来进行访问。

比如：

int arr[10] = { 0 };

//数组的10个元素，下标的范围是0-9

int arr[10]	0	0	0	0	0	0	0	0	0	0
下标	0	1	2	3	4	5	6	7	8	9

3.数组的使用

#include<stdio.h>

int main()
{
	int arr[10] = { 10,11,12,13,14,15,16,17,18,19 };//数组
	int i = 0;
	//printf("%d\n", arr[8]);
	//0-9
	/*while (i < 10)      //while的使用
	{   
		
		printf("%d ", arr[i]);
		i++;
	}*/
	/*for (i = 0;i < 10;i++)//for的使用
	{
		printf("%d ", arr[i]);
	}*/
	do               //do...while的使用
	{
		printf("%d ", arr[i]);
		i++;
	} while (i < 10);
	return 0;
}

十.操作符

1.算数操作符

+    -    *     /     %

//算数操作符的应用
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	int a = 7 / 2;
	//除号的两端都是整数，执行的是整数除法
	//如果两端有一个是浮点数，就执行浮点数的除法
	int b = 7 % 2;//取余数
	float c = 7.0 / 2.0;
	printf("%d\n", a);
	printf("%d\n", b);
	printf("%.1f\n", c);//小数点后一位写成.1f
	return 0;
}

2.移位操作符（涉及二进制）

>> 右移   << 左移

3.位操作符

& 按位与

^ 按位异或

| 按位或

~按位取反

4.赋值操作符

=        +=         -=         *=         /=         &=         ^=         |=         >>=         <<=复合赋值符

5.单目操作符

! 逻辑反操作
- 负值                //+ - 与数学中的正号 负号一样
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
-- 前置、后置--
++ 前置、后置++
*      间接访问操作符(解引用操作符)
(类型)       强制类型转换

sizeof的应用

sizeof计算对应变量类型的内存大小 单位 字节

sizeof 不是函数而是操作符所以有：

  sizeof a      sizeof(a)   两种写法 后面放变量()可以省略

  sizeof(int)                              后面放类型()不能省略

(类型)       强制类型转换

6.关系操作符

>

>=

< <=

!= 用于测试“不相等”

== 用于测试“相等”，与赋值号不同“=” 注意区分7.

7.逻辑操作符

&&          逻辑与 —— 两个为真才为真

||             逻辑或 —— 两个为假才为假8.

8.条件操作符

exp1 ? exp2 : exp3  三目操作符

9.逗号表达式

exp1, exp2, exp3, …expN

注：逗号表达式输出的是最后一个表达式的数值

10.下标引用、函数调用和结构成员

[]    ()   

.   ->   //ps：最后两章会具体讲

十一.常用关键字

char short int long float double struct enum union                       类型
const unsigned signed extern static typedef void sizeof auto       与类型有关,修饰和操作类型
if else while for goto switch case continue break default do        与选择循环等结构有 关
register return volatile                                                                   其它

红体是还没讲到的：

struct,enum和 union：三个自定义的类型 结构体，枚举，联合体，会在后面具体介绍。
unsigned和 signed  : 用于修饰变量 前者表示无符号后者表示有符号,涉及二进制的表示,后面精讲。

 1.关键词typedef(对类型重命名)

typedef unsigned int uint;//把 unsigned int 这个类型命名为 uint

typedef struct Node 
{
    int date;
    struct Node* next;

}Node;//把这个结构体类型命名成 Node；
int main()
{
    unsigned int num = 0;
    uint num2 = 1;
    struct Node n;
    Node n2;
    return 0;
}

2.关键词static(用来修饰变量和函数的)

2.1. 修饰局部变量-称为静态局部变量

#include <stdio.h>
void test()
{
    int i = 0;
    i++;
    printf("%d ", i);
}
int main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        test();
    }
    return 0;
}
//222222222
//i局部变量，进入函数会创建i赋值1，出了函数被销毁

#include <stdio.h>
void test()
{
    //static修饰局部变量
    static int i = 0;
    i++; printf("%d ", i);
}
int main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        test();
    }
    return 0;
}
//2 3 4 5 6 7 8 9 10 11

结论：
static修饰局部变量的时候，局部变量除了作用域，不销毁的。本质上static修饰局部变量的时候改变的变量的存储位置的。影响了变量的生命周期，生命周期变长，和程序的生命周期一样。

2.2. 修饰全局变量-称为静态全局变量

全局变量具有外部链接属性的，可以被其他源文件访问，各个源文件可以链接到一起完成程序。一个全局变量被static修饰，使得这个全局变量失去了外部链接属性变成内部链接属性。只能在本源文件内使用，不能在其他源文件内使用。

2.3. 修饰函数-称为静态函数

一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。

一个函数本来是具有外部链接属性的，但是被static修饰的时候，外部链接属性就变成了内部链接属性，其他源文件(.c)就无法使用了。

十二.#define定义常量和宏

//define定义标识符常量
#define NUM 100


//define定义宏
//宏是有参数的
#define ADD(x,y) ((x)+(y))

int Add(int x, int y)
{
	return x + y;

}
int main()
{
    printf("%d\n", NUM);
	int n = NUM;
	printf("%d\n", NUM);
	int arr[NUM] = { 0 };
	int a1 = 10;
	int b1 = 20;
	int a2 = 30;
	int b2 = 40;
	int c = ADD(a1, b1);
	int d = Add(a2, b2);

	printf("%d\n", c);
	printf("%d\n", d);
	return 0;
}

宏不用定义类型，实际上是把对应部分的值给替换成定义的后面部分表达式

代码里面的ADD(2,3)被替换成((2)+(3))再进行操作

十三.指针

1.内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的 。

所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。(1内存单元=1字节byte=8bit位)

为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

1KB =1024byte
1MB=1024KB
1GB=1024MB

例如：32位电脑

地址线：1/0

00000000000000000000000000000000

00000000000000000000000000000001

..........

1111111111111111111111111111111111111   

每个地址都有2种可能，总共有2*2*2*2*......*2(32个2)=2^32

故以上总共有2^32可能的地址序列

一个地址管理一个内存单元，一个内存单元大小又是一个字节，则以上地址序列可以管理2^32个字节，那么这么多字节又是多大的空间呢？

2^32byte

=4294967296byte

=4194304KB

=4096MB

=4GB

如果是64位机器——>8G/16G/32G都可能

内存单元

编号—>地址—>地址也被称为指针

存放指针或地址的变量就是指针变量

int    a    =  10;

int *  p    =  &a;

int是说明p指向的对象是int类型的

*说明p是指针变量

int main( )
{
    int a = 10;//向内存申请4个字节，存储10
    //&a;//取地址操作符
    //printf("%p\n", &a);
    int* p = &a;
    //p就是指针变量
    //char ch = 'w';
    //char* p = &ch;
    *p = 20;//c解引用操作符，意思就是通过p中存放的地址，找到p所指的对象，*p就是p指向的对象
    //把20赋给*p，也就是或把20赋给p所指向的对象(a),也就是a变成20
    printf("%d\n", a);
    return 0;
}

2.指针变量的大小

#include<stdio.h>

//不管是什么类型的指针，都是在创建指针变量
//指针变量都是用来创建地址的
//指针变量的大小取决于一个地址存放的时候西药多大的空间
//32位机器上的地址：32bit位—4byte，所以指针变量的大小是4个字节
//64位机器上的地址：64bit位—8byte，所以指针变量的大小是8个字节

int main()
{
    printf("%zu\n", sizeof(char*));//8
    printf("%zu\n", sizeof(short*));
    printf("%zu\n", sizeof(int*));
    printf("%zu\n", sizeof(float*));
    printf("%zu\n", sizeof(double*));

    return 0;
}

十四.结构体

结构体的函数结构：

Struct  类型
{
    成员1；
    成员2；
    成员3；
    .........
};

初始化结构体结构：

Struct  类型   结构体对象={%size1 %size2 %size3......，结构体对象.成员名1 结构体对象.成员名2 结构体对象.成员名3............. };

void 自定义函数名( struct 类型* p结构体对象)//使用这个的时候，主函数里面要有打印的函数

                                                                               自定义函数名(&结构体对象)；

{

        printf("%size1 %size2 %size3......"，(*p结构体对象).成员名1 (*p结构体对象).成员名2 (*p结构体对象).成员名3............. )

    //->
    //结构体的指针变量->成员名

        printf("%size1 %size2 %size3......"，p结构体对象->成员名1 p结构体对象->成员名2     p结构体对象->成员名3............. )                

        

}

主程序代码：

// 学生
struct Stu
{
    //成员变量
    char name[20];
    int age;
    char sex[10];
    char tele[12];
};

void print(struct Stu* ps)
{
    printf("%s %d %s %s\n", (*ps).name, (*ps).age, (*ps).sex, (*ps).tele);
    //->
    //结构体的指针变量->成员名
    printf("%s %d %s %s\n", ps->name, ps->age, ps->sex, ps->tele);
}
int main()
{
    struct Stu s = { "zhangsan",20,"nan","17563978041" }；
    //结构体对象.成员名
    //printf("%s %d %s %s\n", s.name,s.age,s.sex,s.tele)；
    print(&s);
    return 0;
}