C语言学习入门第一节————初识C语言（下）

最新推荐文章于 2024-05-31 09:42:54 发布
最新推荐文章于 2024-05-31 09:42:54 发布
阅读量59 收藏 1
点赞数 5
分类专栏： C语言初阶学习 文章标签： c语言 学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79418684/article/details/132310930
版权

系列文章目录

C语言学习入门第一节初始C语言（上）
C语言学习入门第一节初始C语言（下）

初识C语言

什么是C语言
数据类型
变量、常量
字符串+转义字符+注释
选择语句
循环语句
函数
数组
操作符
常见关键字
define 定义常量和宏
指针
结构体

文章目录

一、函数

函数可以理解为一个模块的额代码，完成一个独立的功能，防止代码冗余。

函数的特点：简化代码，代码复用。

#include <stdio.h>
//定义一个名叫Add，带两个参数（x，y分别接收 a，b）的函数//这里的两个参数是 形式参数（形参）
int Add(int x, int y)
{
	int z = x + y;
	return z;//最后返回z，因为z是int类型，所以Add()函数的返回类型定义为int
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int sum = Add(a, b);   //这里调用上面的Add()函数,把输入的a和b代入函数的两个参数 ，两值相加后返回z，代入sum
						   //这里的两个参数是 实际参数（实参）

	printf("%d\n", sum);

	return 0;
}

在这里插入图片描述

二、数组

要存储1-10的数字，怎么存储？
C语言中给了数组的定义：一组相同类型元素的集合

1.数组定义

//数组定义
#include <stdio.h>
 
int main()
{
	/*int a = 5;
	int b = 2;
	int c = 1;*/
	//像这样一个一个存如果要存的数很多，很麻烦。
 
	//这时就可以用数组 - 可以保存一组相同类型的数
	int arr[19] = {1,2,3,4,5,6,7,8,9,10,11,55,154,6262};//整型数组
	char ch[86]={"sawasdcsad"};//字符数组
 
	return 0;
}

2.数组的下标（ * * * ）

C语言规定：数组的每个元素都有一个下标，下标是从0开始的。

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

//数组下标
#include <stdio.h>
 
int main()
{

	//数组 - 可以保存一组相同类型的数
	//{}里的每个值是数组的元素（下标从0开始）
	int arr[19] = { 1,2,3,4,5,6,7,8,9,10,11,55,154,6262 };//整型数组
	//	数组下标：   0 1 2 3 4 5 6 7 8 9  10 11  12  13  
	char ch[86] = { "sawasdcsad" };//字符数组
 
	printf("%d\n", arr[8]);//通过数组下标来访问数组中的某个元素//这里访问的是下标为8的元素，即9
	printf("%s\n", ch);//通过%s打印字符串来打印数组中的字符串。
	
 
	return 0;
}

在这里插入图片描述
循环打印数组：

//数组下标
#include <stdio.h>

int main()
{
	int arr[19] = { 1,2,3,4,5,6,7,8,9,10,11,55,154,6262 };//整型数组
	//	数组下标：   0 1 2 3 4 5 6 7 8 9  10 11  12  13  

	//利用下标循环打印数组：
	int i = 0;
	while (i < 14)
	{
		printf("%d\n", arr[i]);
		//先打印arr[0],之后i自增变成1，还是<13,再进循环，
		//打印arr[0]......循环输出到arr[13]
		i++; //i自增成14, (i = 14) !< 13----跳出循环
	}

	return 0;
}

在这里插入图片描述

三、操作符

1.算术操作符：

+：加法

- ：减法

* ：乘法

/ ：除法

    1.计算的结果是整除之后得到的商

    2.除法有两种：

    （1）.整数除法(两个整数相除)       

    （2）.浮点数除法(保证除数和被除数中至少有一个数是浮点数)

%：取模（取余）操作符，得到的是余数，且只适用于整数（符号左右两边都为整型）

/ ----除法：

#include <stdio.h>
 
int main()
{
	//整数除法(两个整数相除)
	int a = 8 / 4; //-----》2
	printf("%d\n", a);
	
	//浮点数除法(保证除数和被除数中至少有一个数是浮点数) 
	printf("%lf\n", 9.0 / 4);  //-----》2.250000
	printf("%lf\n", 9 / 4.0);   //-----》2.250000
	printf("%lf\n", 9.0 / 4.0);  //-----》2.250000
	//%lf：打印double类型
	return 0;
}

在这里插入图片描述

2.移位操作符（移动的是二进制位）

>>（右移）        <<（左移）

3.位操作符（操作的额也是二进制位）

&（按位与） ^（按位异或） | （按位或）

4.赋值操作符

= ：赋值

+= ：加等于

-= ：减等于

*= ：乘等于

/= ：除等于

&= ：按位与等

^= ：按位异或等

|= ：按位或等
>>= ：右移等

<<= ：左移等

#include <stdio.h>
int main()
{
	int a = 0;
	a = 10;//赋值

	a = a + 5;
	a += 5;//复合赋值//等价于 a = a + 5

	a = a - 2;
	a -= 2;//等价于 a = a - 2

	a = a * 3;
	a *= 3;//等价于 a = a * 3

	return 0;
}

5.单目操作符（ * * * ）

！ ：逻辑反操作(真变假，假变真)

- ：负值（负变正，正变负）

+ ：正值

& ：取地址（跟指针有关）

sizeof ：操作数的类型长度（以字节位单位），是一个操作符，不是函数

            1.sizeof(变量名)，这时括号可去掉（说明sizeof不是函数）

            2.sizeof(变量的字符类型)

~ ：对一个数的二进制二进制按位取反

- - ：前置、后置++

&++ ：前置、后置++

* ：简介访问操作符（解引用操作符，跟指针有关）

（类型）：强制类型转换

！ – 逻辑反操作：


#include <stdio.h>
 
//C语言中表示真假：
//0 - 假
//非0 - 真（只要不是0就是真）
 
int main()
{
	int a = -1;
	//a = 0;
	if (a)//a = -1，非0，为真，进入if 
	{
		printf("hehe\n");
	}
	if (!a)//a原来为真，经过逻辑反操作后，变为假，无法进入if
	{      //真变假：0 假变真：1
		printf("haha\n");
	}
	return 0;
}

在这里插入图片描述
在这里插入图片描述

sizeof （）：

#include <stdio.h>
 int main()
{
	int a = 100;
	//sizeof 是一个操作符，不是函数
	//sizeof计算的是变量占有内存的大小，单位是字节
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof a);//sizeof 后边的括号省略，就说明sizeof 不是函数

	printf("%d\n", sizeof(int));
	//printf("%d\n", sizeof int);//err- 这是一个错误的示范


	return 0;
}

在这里插入图片描述

++ 前置、后置++：

#include <stdio.h>
int main()
{
	int a = 2;

	int b = ++a; //前置++，先++，后使用
	//等价于 a = a + 1;   
	// b = a;

	int c = a++; //后置++，先使用，再++
	//等价于 c = a;
	//a = a+1;

	//a经过两次++操作变成4
	printf("%d %d %d\n", c, b, a);//3  3  4
	return 0;
}

在这里插入图片描述

- - .前置、后置- -：

//--
#include <stdio.h>
int main()
{
	int a = 4;
	int b = --a;//先--，后使用
	//a=a-1
	//b=a 
	int c = a--;//先使用，再--
	//c = a
	//a = a-1
	printf("a=%d b=%d c=%d \n", a, b, c);//2 3 3

	return 0;
}

在这里插入图片描述

（类型）：强制类型转换：

int main()
{
	int a = 3.14;
	//int a = (int)3.14;//（类型）：强制类型转换(不会四舍五入，直接去掉小数部分)
	//这里如果不使用强制类型转换能打印但可能会警告（编译器不同可能不会警告）： 
	printf("%d\n", a);
	return 0;
}

在这里插入图片描述

6.关系操作符

> ：大于

>= ：大于等于

< ：小于

<= ：小于等于

!= ：用于测试“不相等”

== ：用于测试“相等”

//关系操作符：
#include <stdio.h>
int main()
{
	int num1 = 0;
	int num2 = 0;
	while (scanf("%d %d", &num1, &num2) == 2) //scanf函数返回输入参数个数
	{
		if (num1 == num2) //==：等于
		{
			printf("%d 等于 %d\n", num1, num2);
		}
		else if(num1 != num2 )
		{
			printf("%d 不等于 %d，并且", num1, num2);
			if (num1 > num2)// >：大于
			{
				printf("%d 大于 %d\n", num1, num2);
			}
			else if (num1 < num2)// <: 小于
			{
				printf("%d 小于 %d\n", num1, num2);
			}
		}
	}
	return 0;
}

在这里插入图片描述

7.逻辑操作符

&& ：逻辑与（并且），两个操作数都为真，才为真，只要有一个为假，就是假

||：逻辑或（或者），两个操作数只要有一个为真，则为真，两个同时为假，才为假

//逻辑操作符：
#include <stdio.h>
 
int main()
{
//	//并且  &&  逻辑与， 两个操作数都为真，才为真，只要有一个为假，则为假
//	//或者  ||  逻辑或， 两个操作数只要有一个为真，则为真，两个同时为假，才为假
	int a = 0;//默认：0为假
	int b = 1;//	  非0为真
 
	if (a && b)//&&：逻辑与
	{
		printf("两个操作数同时为真");
	}
	else if (a || b)//||：逻辑或
	{
		printf("两个操作数其中一个为真");
	}
	return 0;
}

在这里插入图片描述

8.条件操作符（三目操作符）

exp1 ? exp2 : exp3
根据表达式1的结果来确定是表达式2执行还是表达式3执行(exp：表达式)

(exp1) (exp2) (exp3)

真–> 执行 - 不执行
表达式2(exp2)执行的话，整个表达式的结果就是表达式2的结果

(exp1) (exp2) (exp3)
假–> 不执行 - 执行
表达式3(exp3)执行的话，整个表达式的结果就是表达式3的结果

#include <stdio.h>

int main()
{
	int a = 0;
	int b = 0;
	//输入
	scanf("%d %d", &a, &b);
	int m = 0;
	//三目操作符：(逻辑类似下面的if...else...语句)
	/*if (a > b)
		m = a;
	else
		m = b;*/ //a = b的话，进入else赋值哪个都一样

	// 写法一：
	//(a > b) ? (m = a) : (m = b)
	//  exp1	  exp2		exp3

	//写法二：
	m = (a > b ? a : b);
	//表达式2(exp2)执行的话，整个表达式的结果就是表达式2的结果
	//表达式3(exp3)执行的话，整个表达式的结果就是表达式3的结果


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

在这里插入图片描述

9.逗号表达式：

 exp1, exp2, exp3, ...expN     拿逗号隔开的一串表达式(从左向右依次计算)  （exp：表达式）

//逗号表达式：
#include <stdio.h>

int main()
{
	int a = 4;
	int b = 8;
	int c = 6;

	//逗号表达式：exp1, exp2, exp3, ...
	//从左向右依次计算
	//逗号表达式的结果时最后一个表达式的结果
	int d = (a += 4, b = 5, c = a + b, c - 5);
	//	  a = a + 4 = 8   b = 5   c = 8 + 5 = 11  c - 5 = 8 
	//						  最后的结果=8

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

在这里插入图片描述

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

[] ------- 下标引用操作符（数组在引用时的一个习惯）

// [] -- 下标引用操作符：
#include <stdio.h>
 
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	//下标：	   0 1 2 3 4 5 6 7 8  9 
 
	printf("%d\n",arr[6]);//取数组中下标为6的值
	// []是一个操作符，有两个操作数：这里一个是arr,一个是6
	return 0;
}

在这里插入图片描述
（） – 函数调用:

//（）：函数调用操作符：
#include <stdio.h>

int Add(int x, int y)//这里的括号是语法限定
{
	return x + y;
}


int main()
{
	int z = Add(6, 9);//调用Add（）函数，这里的（）就是函数调用操作符
					 //这里有三个操作数： Add	6	9 
	printf("%\d\n", z);

	printf("hello");//调用printf（）函数，这里的（）就是函数调用操作符
				   //这里有两个操作数“	 printf	 "hello"
	return 0;
}

在这里插入图片描述

四、关键字

auto break case char const continue default do double lse enum externe float for goto if int long register return short signed izeof static struct switch typedef unions unsigned void volatile while

C语言提供了丰富的关键字，这些关键字都是语言本身预先设定好的，用户自己是不能创造关键字的。

1.关键字 typedef：

typedef 顾名思义是类型定义，这里应该理解为类型重命名

#include <stdio.h>
typedef unsigned int u_int;//     以后在创建无符号整形时就可以用 u_int + 变量名的方式
typedef unsigned long long ull;//     以后在创建无符号长整形时就可以用 ull + 变量名的方式

int main()
{
	unsigned int num = 0;
	u_int num2 = 0;
	ull num3 = 0;

	return 0;
}

2.修饰变量的关键字：

auto – 局部变量自动创建，自动销毁

extern – 声明外部符号

register – 寄存器

static – “静态”

auto:

//关键字：auto
#include <stdio.h>
 
int main()
{
	auto int num = 0; //局部变量本身都是有auto(自动创建，自动销毁)的，所有干脆都给省略掉了
	//局部的变量是进入作用域创建，出了作用域销毁
	//这里是 自动创建、自动销毁的 -- auto
	return 0;
}

static:

在C语言中： static是用来修饰变量和函数的

  1. 修饰局部变量-称为静态局部变量
  2. 修饰全局变量-称为静态全局变量
  3. 修饰函数-称为静态函数
  1. 修饰局部变量-称为静态局部变量

栈区、堆区、静态区：（ * * * ）

在这里插入图片描述

未使用static时:

#include <stdio.h>
 
void test()
{
	 int a = 5; //a是静态局部变量，每次调用函数，a都会重新创建一次
	a++;
	printf("%d ", a);
}
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();//函数调用结束，a自动销毁，然后在进入下一次循环时再次重新创建。
		i++;
	}

	return 0;
}

在这里插入图片描述
使用static后：变量a变成静态变量，存放在静态区:


#include <stdio.h>
//static 修饰局部变量的时候
//本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了
//static 修饰局部变量改变了变量的存储类型（位置），使得这个静态变量的生命周期变长了，直到程序结束才结束,实现累计打印的效果
//但是作用域不变
void test()
{
	static int a = 5;//加上static属性，变成静态变量，直到程序结束才销毁
	//出了作用域后，不再自动销毁，进入作用域也不再自动创建
	a++;
	printf("%d\n",a);
}
 
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}

在这里插入图片描述
注：被static修饰的变量(静态变量)和全局变量的区别：都存放在静态区中，两者生命周期相同，都是程序结束才销毁。但静态变量的作用域还是在局部，全局变量的作用域是任意地方。

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

未使用static时：

                                    //add.c文件:
//全局变量具有外部链接属性（可以被extern声明）
//使用在其他源文件内部依然可以使用（方法要正确）
int g_val = 2023;
 
                                   
//static 修饰全局变量
#include <stdio.h>
//声明外部符号
extern int g_val;
 
int main()
{
	printf("%d\n",g_val);
	return 0;
}

在这里插入图片描述

使用static后：


//全局变量具有外部链接属性（可以被extern声明）
//使用在其他源文件内部依然可以使用（方法要正确）
//add.c文件：
static int g_val = 2023;
//static修饰全局变量，改变了这个全局变量的链接属性，
//由外部链接属性变成了内部链接属性
//内部链接属性：只能在源文件内部使用
//这个静态变量只能在自己所在的源文件内部使用，不能在其他源文件外部使用了

//static 修饰全局变量
#include <stdio.h>
//声明外部符号
extern int g_val;

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

在这里插入图片描述

3.修饰函数 ------- 称为静态函数
未使用static时：

 //add.c文件中：
int Add(int x, int y)
{
	return (x + y);
}
 

//static 修饰函数
#include <stdio.h>
//声明外部符号
extern int Add(int x, int y);
//声明是为了告诉 函数名 参数名 返回值

int main()
{
   int a = 0;
   int b = 0;
   scanf("%d %d", &a, &b);
   int s = Add(a, b);
   printf("%d\n", s);
   return 0;
}

在这里插入图片描述
使用static后：


//add.c文件：
//static修饰函数和static修饰全局变量是一样的
//函数本身时具有外部链接属性的，但是被static修饰，
//就变成了内部链接属性
//使得这个函数只能在自己所在的源文件内部使用，
//不能再其他文件内部使用
static int Add(int x, int y)
{
	return (x + y);
}



                         
//static 修饰函数
#include <stdio.h>
//声明外部符号
extern int Add(int x, int y);
//声明是为了告诉 函数名 参数名 返回值
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int s = Add(a, b);
	printf("%d\n", s);
	return 0;
}

在这里插入图片描述

register – 寄存器：

在计算机领域，寄存器是CPU内部的元件，包括通用寄存器、专用寄存器和控制寄存器。寄存器拥有非常高的读写速度，所以在寄存器之间的数据传送非常快。

在这里插入图片描述

#include <stdio.h>
int main()
{
	//register 仅仅是建议的作用
	//建议放在寄存器中，但是不是真的放在寄存器中，取决于编译器
	register int num = 10;

	return 0;
}

3.#define 定义常量和宏：

define定义常量：

#include <stdio.h>
#define M 100 //后面不用加 ；（分号）
			  // 在预处理时进行替换

int main()
{
	int arr[M] = { 0 };//声明数组长度的值得时常量
	int m = M;//使用符号进行赋值

	printf("%d\n", sizeof(arr));//
	//数组长度为100，有100个元素，一个元素占4个字节
	//			100	* 4 = 400
	printf("%d\n", M);
	printf("%d\n", m);

	return 0;
}

在这里插入图片描述

define定义宏：

#include <stdio.h>
//使用#define定义一个宏：
#define ADD(x, y) ((x)+(y))
//ADD-->宏的名字	
//(x, y)-->宏的两个参数	
//((x)+(y))-->宏的实现体 
int Add(int x, int y)
//int-->函数的返回类型	Add-->函数名	（int x, int y）-->函数参数
{					
	return x + y;	
}					
 
 
int main()
{
	int a = 45;
	int b = 26;
 
	//调用宏，类似调用函数
	int c = ADD(a, b);
	//编译时进行替换：int c = ((a)+(b));
	//宏 和 函数：写的形式不一样，调用方式非常类似
	printf("%d\n", c);
 
	//调用add函数
	int d = Add(a, b);
	printf("%d\n", d);
 
	return 0;
}

在这里插入图片描述

五、指针

1.内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的 。
所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。 为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

所以为了有效地使用内存，就把内存划分成一个个小的内存单元，每个内存单元地大小是1个字节(Byte)，等于8个比特(bit)

在这里插入图片描述

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

*地址或者编号如何产生？（地址 = 编号 = 指针）

在这里插入图片描述
程序运行起来，要加载到内存中，也要申请内存空间使用
比如：


#include <stdio.h>;
 
int main()
{
	int a = 19;//a是int类型，所以向内存申请了四个字节的空间，用来存放这19个数值。  
	return 0;
}
 
//整型--4个字节--32个比特位 转换为 8个十六进制位
//					   4个二进制位 转换成 1个十六进制位 、
 
//用二进制表示15： 1111
//用十进制表示15： 15
//用十六进制表示15： F --> 0x 00 00 00 0f

在这里插入图片描述

%p – 专门用来打印地址的，以十六进制的形式表示地址

//%p -- 专门用来打印地址的，以十六进制的形式表示 
int main()
{
	int a = 19;//虽然a占有4个字节，但是当&a时，拿到的是4个字节中的第一个地址
	printf("%p\n", &a);
	return 0;
}

在这里插入图片描述

2.指针变量（ * * * ）

在C语言中，把地址（编号）也叫做指针，编号 = 地址 = 指针

//指针 - 地址 -编号
//指针变量 - 变量 - 存放地址的变量
//口头语中说的指针，基本上都是指针变量
#include <stdio.h>;
int main()
{
	int a = 15;

	//指针变量
	//&：取地址符
	//pa是用来存放a的地址的，是一个变量，叫 指针变量。
	//意思是存放指针的变量
	int* pa = &a; //要存放一个整数，a的类型是int，
				  //而要存放一个整型变量的地址时，就写成int*
	*pa = 900;			  // 在对应的类型后加上*
		printf("%d\n", a);			  //*pa  解引用操作符 *pa就是a
	return 0;
}

#include <stdio.h>;
int main()
{
	double d = 3.14;
	double* pd = &d;
	*pd = 0;
	printf("%lf\n", d);
	return 0;
}

3.指针变量的大小

指针变量是用来存放地址的，指针变量的大小取决于地址的大小。

在32位操作系统上，地址是32个二进制位，假设这个地址要存储的话，需要4个字节，所以在32位操作系统上，指针变量的大小是4个字节。

在64位操作系统上，地址是64个二进制位，假设这个地址要存储的话，需要8个字节，所以在64位操作系统上，指针变量的大小是8个字节。

所以指针地址要多大空间，指针变量就需要多大空间。

在32位操作系统上（X86）：

#include <stdio.h>;

int main()
{
	//32位操作系统：
	int a = 10;
	int* pa = &a;
	printf("%d\n", sizeof(pa));
	//求指针变量pa的大小，也可以理解成求pa类型的大小，即 int* 的大小
	printf("%d\n", sizeof(int*));
	return 0;
}

在这里插入图片描述

在64位操作系统上（X64）：

//指针变量的大小：
#include <stdio.h>;

int main()
{
	//32位操作系统：
	int a = 10;
	int* pa = &a;
	printf("%zd\n", sizeof(pa));//在64位操作系统下最好不用%d输出sizeof返回的值 ，要用%zd
	//求指针变量pa的大小，也可以理解成求pa类型的大小，即 int* 的大小
	printf("%zd\n", sizeof(int*));
	return 0;
}

在这里插入图片描述

六、结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。 比如描述学生，学生包含： 名字+年龄+性别+学号 这几项信息。
这里只能使用结构体来描述了。
例如：

char name[20]; //名字
int age; //年龄
 char sex[5];//性别 
char id[15]； //学号
};

1.使用 . 操作符（结构成员操作符）调用指针

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

struct Stu
{
	//学生的相关属性
	char name[20];//名字-字符串，一个汉字是2个字符
	int age;//年龄
	char sex[5];//“男”、“女”、“保密”
	![在这里插入图片描述](https://img-blog.csdnimg.cn/c9144847e7c74ed08f003030bf6ebe8b.png#pic_center)
//结构体里定义的内容称为结构体的成员
};

struct Book
{
	char name[50];//书名
	char author[10];//作者
	float price;//价格
	
};

int main()
{
	struct Stu s = { "张三", 14, "女" };
	struct Book b1 = { "《大话数据结构 》", "flops", 66.6f };
	printf("%s %s %f\n", b1.name, b1.author, b1.price);
	//使用 .操作符 来访问 成员对象
	//浮点数在内存中无法精确地保存，会丢失一些精度
	return 0;
}

在这里插入图片描述

2.使用->操作符（结构成员操作符)调用指针（ * * * ）


#include <stdio.h>
 
struct S
{
	char name[20];
	int age;
	float score;
};
//结构体大括号后加分号
 
//使用 结构体变量 来的打印
void print1(struct S t)//传入 struct S 类型的变量
{
    printf("用结构体变量来打印"); 
	printf("%s %d %f\n", t.name, t.age, t.score);
}
 
//使用 结构体变量的指针 来的打印
void print2(struct S* pt)//传入 struct S 类型的变量的地址
{	
	//1.第一种写法，有些啰嗦
	//.(点)操作符：	结构体变量.成员 
	printf(".(点)操作符：");
	printf("%s %d %f\n", (*pt).name, (*pt).age, (*pt).score);
	//加（）是因为.(点)的优先级比较高，要先使*pt找到对象
 
	//2.第二种写法：
	// ->操作符（结构成员操作符）：结构指针-->成员 
	printf("->操作符（结构成员操作符）：");
	printf("%s %d %f\n", pt->name, pt->age, pt->score);
	//使用了 -> 符号，通过pt找到地址所对应的变量
}
 
int main()
{
	struct S s = {"张三", 16, 85.5f};//这里变量 s 的字符类型是 struct S
	print1(s);//使用自定义的print1打印结构体变量
	print2(&s);//使用自定义的print2打印结构体变量
	return 0;
}

在这里插入图片描述

莲雾flops
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言基础内容（一）——第01章_C语言入门
sun7_9的博客
01-07 750
*C 语言最初是作为 Unix 系统的开发工具而发明的。**广泛用于各种操作系统和系统软件的开发。如UNIX、MS-DOS、Microsoft Windows及Linux等。1988年，美国国家标准协会（ANSI）正式将C语言标准化，标志着 C 语言开始稳定和规范化。Code::Block是一个免费的跨平台IDE，它支持C、C++和Fortan程序的开发。Code::Block的最大特点是它支持通过插件的方式对IDE自身功能进行扩展，这使得Code::Block具有很强的灵活性，方便用户使用。
c语言入门学习代码——黄果树
05-23
自己最初学习时留下的c语言代码，不限于书本，有些来源于网络，有些是自己原创。希望能对c语言初学者有所帮助！ 唠叨一句：一切抽象的概念都是为了帮助初学者理解，不满于理解概念表面的含义便可能看到本质！
C语言学习入门第一节——初识C语言（上）
2301_79418684的博客
08-30 64
什么是C语言数据类型变量、常量字符串+转义字符+注释选择语句循环语句函数数组操作符常见关键字define 定义常量和宏指针结构体。
C语言学习入门第二节————分支语句和循环语句
2301_79418684的博客
09-05 88
分支语句 if switch 循环语句 while for do while goto语句
【全网最强C语言学习】C语言入门篇（主线）——初识C语言①
罅隙的博客
10-16 8896
一、前言 作为一个小白说出标题这样的话看来是有些大言不惭，但博主有心将这个系列做好、做精。实话说博主学习C语言不过两个多月，也很能明白初学者的困惑，所以会尽肯能详细。同时作为一个系统的教程，这个系列会持续推新的，所以关注博主????，在学习C语言的路上结伴前行吧！ ????‍????作者概况:就读南京邮电大学努力学习的大一小伙 ????‍????联系方式：2879377052（QQ小号） [有问题欢迎留言讨论，作者尽力帮忙]✨ ????‍????资源推荐：C语言从入门到进阶
C语言从入门到精通——初阶1 初识C语言
m0_58125693的博客
03-12 2714
初识C语言 3 什么是C语言 C语言——计算机语言——底层开发——人和计算机交流的语言 4 第一个C语言程序 #include<stdio.h> //包含一个叫stdio.h的文件 //std-标准 standard input output int main()//主函数-程序的入口-不能没有main函数，有且仅有一个 //main前面的int表示main函数调用返回一个整型值 { printf("hello world\n");//函数-print fu...
C语言从入门到精通 ————1.初识C语言
热门推荐
Fly_鹏程万里
02-25 1万+
无意中发现了一个巨牛巨牛的人工智能教程，忍不住分享一下给大家。教程不仅是零基础，通俗易懂，小白也能学，而且非常风趣幽默，还时不时有内涵段子，像看小说一样，哈哈～我正在学习中，觉得太牛了，所以分享给大家。点这里可以跳转到教程！ 程序的定义 程序是一组计算机能识别并执行的指令，只要让计算机执行这个程序，计算机就会自动地、有条不紊地进行工作，计算机的一切操作都是由程序控制的，离开程序，计...
C语言入门（一）—— 初识C语言
weixin_45923239的博客
07-30 288
封面是《春日田野》，与内容无关
初识C语言——详细入门（系统性学习day4）
weixin_58070962的博客
09-19 3503
本篇文章详细地讲了C语言的详细入门基础知识，希望能够帮到大家！
c语言从入门到实战——初识指针
qq_74013365的博客
11-13 287
C语言指针是一种变量，它存储了另一个变量的内存地址。通过指针，我们可以直接访问内存中的数据，从而实现灵活的数据操作。
C语言条件下入门程序——阶乘表.
04-22
C语言基础代码，在此程序里，利用简单的代码，达到输入任意一个数字，得到一列从1~输入数字的阶乘表，不支持负数。
第1章-c语言学习PPT文档.pptx
11-18
第1章-c语言学习PPT文档.pptx
C语言学习笔记——小浪神
10-04
C语言学习笔记——小浪神
C语言入门——循环结构练习（内附答案）
10-26
大一的C语言实验题，两道关于循环的题，适合刚刚入门C语言的同学来巩固和学习循环结构while、for如何来写，是很好的练手题
数据结构——二叉树（C语言版）
2302_80657849的博客
05-30 597
二叉树是一种非线性的数据结构。二叉搜索树、堆、红黑树等高阶数据结构都是依托于二叉树的基础实现的，所以我们有必要好好研究一下“二叉树”这种数据结构。本文只介绍二叉树的基础及中等用法，笔者能力有限，欠妥当之处欢迎批评指正。
二叉排序树简单实现【C风格】
weixin_45690131的博客
05-30 181
利用二叉排序树对数据进行保存、搜索、删除
强化学习——学习笔记3
qq_52302919的博客
05-29 1309
先上图：在上述流程图中所说的Q表即为下表：假设我们在玩一个小游戏，该游戏有上下左右不同的动作，同时也会有不同的状态，比如游戏结束等。Q表也可以称为状态-价值函数QsaQ(s,a)Qsa：这个表格的每一行代表每个 state上述例子中的游戏结束等，每一列代表每个 action上述例子中的上下左右，表格的数值就是在各个 state 下采取各个 action 时能够获得的最大的未来期望奖励。
学习整理 docker
最新发布
wonder_dog的博客
05-31 108
nexus。
两个字节crc码 c语言,modbus-crc16——c语言
06-09
下面是使用 C 语言实现 Modbus CRC16 的代码： ...其中，`modbus_crc16` 函数接收一个字节数组 `buf` 和长度 `len`，计算出 CRC16 校验码并返回。主函数中，我们定义了一个字节数组 `buf`，并计算出它的 CRC16 校验码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值