程序诗篇里的灵动笔触：指针绘就数据的梦幻蓝图＜3＞

news2025/2/2 11:52:51

在这里插入图片描述

大家好啊，我是小象٩(๑òωó๑)۶
我的博客：Xiao Xiangζั͡ޓއއ

很高兴见到大家，希望能够和大家一起交流学习，共同进步。
在这里插入图片描述
今天我们来对上一节做一些小补充，了解学习一下assert断言，指针的使用和传址调用等…

目录

  • 一、assert 断言
  • 二、指针的使用和传址调用
    • 2.1 strlen的模拟实现
    • 2.2 传值调用和传址调用

一、assert 断言

assert 断言是一种在程序中用于检查某个条件是否为真的语句。它基于这样的假设：在程序的某个特定点上，某个条件应该始终成立。如果这个条件确实为真，程序将继续正常执行；但如果条件为假，断言就会失败，通常会导致程序抛出一个AssertionError 异常，从而中断程序的执行。这有助于快速定位程序中的错误，尤其是在开发和测试阶段。
assert.h 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

作用：
调试辅助：帮助开发者快速定位程序中的逻辑错误。例如，在一个计算平均值的函数中，可以使用断言来确保传入的列表不为空，因为计算空列表的平均值是没有意义的，这能让开发者在函数被错误调用时迅速发现问题。
代码契约：在编写函数或方法时，断言可以用于定义函数的前置条件和后置条件，形成一种代码契约。比如，一个除法函数，使用断言可以确保除数不为零这个前置条件，明确函数的使用规则，也让其他阅读和使用代码的人清楚函数的约束条件。
测试验证：在测试用例中，断言是验证测试结果是否符合预期的重要手段。比如在单元测试中，使用断言来检查函数的返回值是否等于预期值，或者检查某个对象的属性是否处于特定状态，从而判断测试是否通过。

assert(p != NULL);

上面代码在程序运行到这一行语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。
assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产生任何作用，程序继续运行。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误流 stderr 中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。

assert() 的使用对程序员是非常友好的，使用assert()
有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭 assert()的机制。如果已经确认程序没有问题，不需要再做断言，就在 #include <assert.h> 语句的前面，定义⼀个宏 NDEBUG 。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的 assert() 语句。如果程序又出现问题，可以移除这条 #define NDEBUG 指令（或者把它注释掉），再次编译，这样就重新启用了 assert() 语句。
assert() 的缺点是，因为引入了额外的检查，增加了程序的运行时间。
一般我们可以在 Debug 中使用，在 Release 版本中选择禁用 assert 就行，在 VS 这样的集成开发环境中，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在 Release 版本不影响用户使用时程序的效率。

二、指针的使用和传址调用

2.1 strlen的模拟实现

库函数strlen的功能是求字符串长度，统计的是字符串中 \0 之前的字符的个数。
函数原型如下：

size_t strlen ( const char * str );

参数str接收一个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回长度。
如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停止。
举个例子:

int my_strlen(const char* str)
{
	int count = 0;
	assert(str);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

2.2 传值调用和传址调用

学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？
例如：写一个函数，交换两个整型变量的值
我们可能写出这样的代码：

#include <stdio.h>
void Swap1(int x, int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	Swap1(a, b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

我们发现其实没产生交换的效果，这是为什么呢？
在这个代码里，Swap1 函数采用的是传值调用。传值调用的特点是，函数接收的是实参的副本，而不是实参本身。具体来说：
在 main 函数中调用 Swap1(a, b) 时，a 和 b 的值会被复制一份，分别传递给 Swap1 函数的形参 x 和 y。
在 Swap1 函数内部，虽然 x 和 y 的值进行了交换，但这只是对副本的操作，并不会影响到 main 函数中原始的 a 和 b 的值。

结论：实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。
所以Swap1是失败的了。

那怎么办呢？
我们现在要解决的就是当调用Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使用指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数里边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。
像这样：

#include <stdio.h>
void Swap2(int* px, int* py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	Swap2(&a, &b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

我们可以看到实现成Swap2的方式，顺利完成了任务，这里调用Swap2函数的时候是将变量的地址传递给了函数，这种函数调用方式叫：传址调用。
传址调用，可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采用传值调用。如果函数内部要修改主调函数中的变量的值，就需要传址调用。

好了，这节内容便结束了,附上这两节所写的代码：

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>

//int main()
//{
//	int a = 10;
//	//int* pa = &a;//int*
//	//char* pc = &a;
//	void* pv2 = &a;
//	//*pv2;
//	//pv2++;
//
//	char ch = 'w';
//	//char*pc = &ch;
//	//int* pi = &ch;
//	void* pv = &ch;//char*
//	//*pv;//err
//	return 0;
//}


//void test(void* pv)
//{
//	//pv在使用的时候，会强制类型转换，然后去使用
//	//
//}
//
//
//int main()
//{
//	int a = 10;
//	test(&a);
//	char c = 'w';
//	test(&c);
//	double d = 3.14;
//	test(&d);
//
//	return 0;
//}


//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);//10
//	int* p = &arr[0];
//
//	//for (i = 0; i < sz; i++)
//	//{
//	//	*(p + i) = 0;
//	//}
//
//	for (i = 0; i < sz; i++)
//	{
//		scanf("%d", p + i);
//	}
//
//
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(p + i));
//	}
//
//	return 0;
//}

//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);//10
//	int* p = &arr[sz-1];
//
//	for (i = 0; i < sz; i++)
//	{
//		*(p - i) = i+1;
//	}
//
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//
//	return 0;
//}
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);//10
//	int* p = &arr[sz - 1];
//
//	for (i = 0; i < sz; i++)
//	{
//		*p = i + 1;
//		p--;
//	}
//
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//
//	return 0;
//}


//int main()
//{
//	int arr[10] = { 0 };
//	int n = &arr[0] - &arr[9];
//	printf("%d\n", n);
//
//	return 0;
//}


//int main()
//{
//	int arr[10] = { 0 };
//	char ch[5] = {0};
//	printf("%d\n", & arr[9] - &ch[0]);//err
//
//	return 0;
//}


#include <string.h>
//strlen 是求字符串长度，统计的是字符串中\0之前的字符个数

//int main()
//{
//	char arr[] = "abcdef";
//	//a b c d e f \0
//	//数组名其实是数组首元素的地址
//	//arr == &arr[0]
//	size_t len = strlen(arr);//6
//	printf("%zd\n", len);
//
//	return 0;
//}

//size_t my_strlen(char* str)
//{
//	size_t count = 0;
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//
//size_t my_strlen(char* str)
//{
//	char* start = str;
//	while (*str != '\0')
//		str++;
//	return str - start;//指针-指针
//}
//
//
//int main()
//{
//	char arr[] = "abcdefghi";
//	//a b c d e f \0
//	//数组名其实是数组首元素的地址
//	//arr == &arr[0]-- char*
//	size_t len = my_strlen(arr);//6
//	printf("%zd\n", len);
//
//	return 0;
//}
//

//
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int* p = arr;
//	while (p < &arr[sz])
//	{
//		printf("%d ", *p);
//		p++;
//	}
//
//
//
//	//int i = 0;
//	//int* p = arr;//p = &arr[0];
//	//for (i = 0; i < sz; i++)
//	//{
//	//	printf("%d ", *(p + i));
//	//}
//
//
//	//for (i = 0; i < sz; i++)
//	//{
//	//	printf("%d ", arr[i]);
//	//}
//
//
//	return 0;
//}

//const 是常属性-不能改变的属性

//int main()
//{
//	const int a = 10;
//	//a变成了常变量，a的本质还是变量，但是因为被const修饰，所以不能改变
//	//a = 1;//err
//	int* p = &a;
//	*p = 1;
//
//	printf("%d\n", a);
//
//	return 0;
//}

//int main()
//{
//	const int n = 10;
//	int arr[n];
//
//	return 0;
//}


//int main()
//{
//	const int a = 10;
//	//a变成了常变量，a的本质还是变量，但是因为被const修饰，所以不能改变
//	//a = 1;//err
//	const int* p = &a;
//	*p = 1;
//
//	printf("%d\n", a);
//
//	return 0;
//}

//const 修饰指针变量
//可以放在*的左边，也可以放在*的右边,意义是不一样的
//const 放在*的左边表示指针指向的内容，不能通过指针来改变了，但是指针变量本身是可以改变的
//const 放在*的右边表示指针变量本身不能被修改了，但是指针指向的内容是可以通过指针变量来改变的

//int main()
//{
//	int a = 100;
//	int b = 1000;
//	int* const p = &a;
//	*p = 0;//ok
//	p = &b;//err
//
//	return 0;
//}

//int main()
//{
//	int a = 100;
//	int b = 1000;
//	const int * p = &a;
//	//*p = 0;//err
//	p = &b;
//
//	return 0;
//}


//int main()
//{
//	int a = 100;
//	int b = 1000;
//
//	const int* const p = &a;
//
//	return 0;
//}
//
//
//
//


//int main()
//{
//	int* p;//局部变量不初始化的时候，里边放的是随机值
//
//	*p = 20;//非法访问，p就是野指针
//
//	return 0;
//}

//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = arr;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0; i <= sz; i++)
//	{
//		*p = i;
//		p++;
//	}
//
//	return 0;
//}
//

//
//int* test()
//{
//	int n = 100;
//	return &n;
//}
//
//int main()
//{
//	int* p = test();
//	printf("%d\n", *p);
//
//	return 0;
//}

//
//int main()
//{
//	int* p = NULL;
//	if(p != NULL)
//		*p = 200;
//
//	return 0;
//}
//#define NDEBUG
#include <assert.h>

//int main()
//{
//	int arr[10] = { 1,2,3,4,5 };
//	int* p = arr;
//	assert(p != NULL);
//	int i = 0;
//	for (i = 0; i < 5; i++)
//	{
//		printf("%d ", *p);
//		p++;
//	}
//	//
//	return 0;
//}

//int main()
//{
//	int arr[10] = { 1,2,3,4,5 };
//	int* p = arr;
//	assert(p != NULL);
//	int i = 0;
//	for (i = 0; i < 5; i++)
//	{
//		printf("%d ", *p);
//		p++;
//	}
//	
//	return 0;
//}


//int main()
//{
//	int a = 5;
//	assert(a != 5);
//
//	return 0;
//}
//
//size_t my_strlen(const char* str)
//{
//	size_t count = 0;
//	assert(str != NULL);
//
//	while (*str)//'\0' -- 0
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//
//int main()
//{
//	char arr[] = "abcdef";
//	size_t len =  my_strlen(arr);
//	printf("%zd\n", len);
//
//	return 0;
//}

//void Swap1(int x, int y)
//{
//	int z = 0;
//	z = x;
//	x = y;
//	y = z;
//}
//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	//写一个函数，交换a和b的内容
//
//	printf("交换前:a = %d b = %d\n", a, b);
//	Swap1(a, b);
//	printf("交换后:a = %d b = %d\n", a, b);
//	
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int* p = &a;
//	*p = 20;
//	return 0;
//}


//void Swap2(int* pa, int* pb)
//{
//	int z = 0;
//	z = *pa;//z = a
//	*pa = *pb;//a = b
//	*pb = z;//b = z
//}
//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	//写一个函数，交换a和b的内容
//
//	printf("交换前:a = %d b = %d\n", a, b);
//	Swap2(&a, &b);
//	printf("交换后:a = %d b = %d\n", a, b);
//	
//	return 0;
//}

//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int a = 3;
//	int b = 5;
//	int r = Add(a, b);//传值调用
//	printf("%d\n", r);
//	return 0;
//}

      //    3      5
int Max(int x, int y)
{
	return (x > y ? x : y);
}

int main()
{
	int a = 3;
	int b = 5;

	int r = Max(a, b);//传值调用
	printf("%d\n", r);

	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2289764.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

神经网络的数据流动过程（张量的转换和输出）

神经网络的数据流动过程（张量的转换和输出）

文章目录 1、文本从输入到输出&#xff0c;经历了什么&#xff1f;2、数据流动过程是张量&#xff0c;如何知道张量表达的文本内容&#xff1f;3、词转为张量、张量转为词是唯一的吗&#xff1f;为什么&#xff1f;4、如何保证词张量的质量和合理性5、总结 &#x1f343;作者介…
阅读更多...
爬取鲜花网站数据

爬取鲜花网站数据

待爬取网页&#xff1a; 代码&#xff1a; import requestsfrom lxml import etree import pandas as pdfrom lxml import html import xlwturl "https://www.haohua.com/xianhua/"header {"accept":"image/avif,image/webp,image/apng,image/sv…
阅读更多...
vue框架技术相关概述以及前端框架整合

vue框架技术相关概述以及前端框架整合

vue框架技术概述及前端框架整合 1 node.js 介绍&#xff1a;什么是node.js Node.js就是运行在服务端的JavaScript。 Node.js是一个事件驱动I/O服务端JavaScript环境&#xff0c;基于Google的V8引擎。 作用 1 运行java需要安装JDK&#xff0c;而Node.js是JavaScript的运行环…
阅读更多...
数据结构 树2

数据结构 树2

文章目录 前言 一&#xff0c;二叉搜索树的高度 二&#xff0c;广度优先VS深度优先 三&#xff0c;广度优先的代码实现 四&#xff0c;深度优先代码实现 五&#xff0c;判断是否为二叉搜索树 六&#xff0c;删除一个节点 七&#xff0c;二叉收索树的中序后续节点 总结 …
阅读更多...
NeetCode刷题第19天(2025.1.31)

NeetCode刷题第19天(2025.1.31)

文章目录 099 Maximum Product Subarray 最大乘积子数组100 Word Break 断字101 Longest Increasing Subsequence 最长递增的子序列102 Maximum Product Subarray 最大乘积子数组103 Partition Equal Subset Sum 分区等于子集和104 Unique Paths 唯一路径105 Longest Common Su…
阅读更多...
Google Chrome-便携增强版[解压即用]

Google Chrome-便携增强版[解压即用]

Google Chrome-便携增强版 链接&#xff1a;https://pan.xunlei.com/s/VOI0OyrhUx3biEbFgJyLl-Z8A1?pwdf5qa# a 特点描述 √ 无升级、便携式、绿色免安装&#xff0c;即可以覆盖更新又能解压使用&#xff01; √ 此增强版&#xff0c;支持右键解压使用 √ 加入Chrome增强…
阅读更多...
[EAI-027] RDT-1B，目前最大的用于机器人双臂操作的机器人基础模型

[EAI-027] RDT-1B，目前最大的用于机器人双臂操作的机器人基础模型

Paper Card 论文标题&#xff1a;RDT-1B: a Diffusion Foundation Model for Bimanual Manipulation 论文作者&#xff1a;Songming Liu, Lingxuan Wu, Bangguo Li, Hengkai Tan, Huayu Chen, Zhengyi Wang, Ke Xu, Hang Su, Jun Zhu 论文链接&#xff1a;https://arxiv.org/ab…
阅读更多...
[EAI-028] Diffusion-VLA，能够进行多模态推理和机器人动作预测的VLA模型

[EAI-028] Diffusion-VLA，能够进行多模态推理和机器人动作预测的VLA模型

Paper Card 论文标题&#xff1a;Diffusion-VLA: Scaling Robot Foundation Models via Unified Diffusion and Autoregression 论文作者&#xff1a;Junjie Wen, Minjie Zhu, Yichen Zhu, Zhibin Tang, Jinming Li, Zhongyi Zhou, Chengmeng Li, Xiaoyu Liu, Yaxin Peng, Chao…
阅读更多...
DIFY源码解析

DIFY源码解析

偶然发现Github上某位大佬开源的DIFY源码注释和解析&#xff0c;目前还处于陆续不断更新地更新过程中&#xff0c;为大佬的专业和开源贡献精神点赞。先收藏链接&#xff0c;后续慢慢学习。 相关链接如下&#xff1a; DIFY源码解析
阅读更多...
hexo部署到github page时，hexo d后page里面绑定的个人域名消失的问题

hexo部署到github page时，hexo d后page里面绑定的个人域名消失的问题

Hexo 部署博客到 GitHub page 后&#xff0c;可以在 setting 中的 page 中绑定自己的域名&#xff0c;但是我发现更新博客后绑定的域名消失&#xff0c;恢复原始的 githubio 的域名。 后面搜索发现需要在 repo 里面添加 CNAME 文件&#xff0c;内容为 page 里面绑定的域名&…
阅读更多...
【Block总结】MAB，多尺度注意力块|即插即用

【Block总结】MAB，多尺度注意力块|即插即用

文章目录 一、论文信息二、创新点三、方法MAB模块解读1、MAB模块概述2、MAB模块组成3、MAB模块的优势 四、效果五、实验结果六、总结代码 一、论文信息 标题: Multi-scale Attention Network for Single Image Super-Resolution作者: Yan Wang, Yusen Li, Gang Wang, Xiaoguan…
阅读更多...
移动互联网用户行为习惯哪些变化，对小程序的发展有哪些积极影响

移动互联网用户行为习惯哪些变化，对小程序的发展有哪些积极影响

一、碎片化时间利用增加 随着生活节奏的加快&#xff0c;移动互联网用户的碎片化时间越来越多。在等公交、排队、乘坐地铁等间隙&#xff0c;用户更倾向于使用便捷、快速启动的应用来满足即时需求。小程序正好满足了这一需求&#xff0c;无需下载安装&#xff0c;随时可用&…
阅读更多...
使用 Tauri 2 + Next.js 开发跨平台桌面应用实践：Singbox GUI 实践

使用 Tauri 2 + Next.js 开发跨平台桌面应用实践：Singbox GUI 实践

Singbox GUI 实践 最近用 Tauri Next.js 做了个项目 - Singbox GUI&#xff0c;是个给 sing-box 用的图形界面工具。支持 Windows、Linux 和 macOS。作为第一次接触这两个框架的新手&#xff0c;感觉收获还蛮多的&#xff0c;今天来分享下开发过程中的一些经验~ 为啥要做这个…
阅读更多...
攻防世界_simple_php

攻防世界_simple_php

同类型题&#xff08;更难版->&#xff09;攻防世界_Web(easyphp)&#xff08;php代码审计/json格式/php弱类型匹配&#xff09; php代码审计 show_source(__FILE__)&#xff1a;show_source() 函数用于显示指定文件的源代码&#xff0c;并进行语法高亮显示。__FILE__ 是魔…
阅读更多...
C++哈希（链地址法）（二）详解

C++哈希（链地址法）（二）详解

文章目录 1.开放地址法1.1key不能取模的问题1.1.1将字符串转为整型1.1.2将日期类转为整型 2.哈希函数2.1乘法散列法&#xff08;了解&#xff09;2.2全域散列法&#xff08;了解&#xff09; 3.处理哈希冲突3.1线性探测&#xff08;挨着找&#xff09;3.2二次探测&#xff08;跳…
阅读更多...
Solon Cloud Gateway 开发：导引

Solon Cloud Gateway 开发：导引

Solon Cloud Gateway 是 Solon Cloud 体系提供的分布式网关实现&#xff08;轻量级实现&#xff09;。 分布式网关的特点&#xff08;相对于本地网关&#xff09;&#xff1a; 提供服务路由能力提供各种拦截支持 1、分布式网关推荐 建议使用专业的分布式网关产品&#xff0…
阅读更多...
dmfldr实战

dmfldr实战

dmfldr实战 本文使用达梦的快速装载工具&#xff0c;对测试表进行数据导入导出。 新建测试表 create table “BENCHMARK”.“TEST_FLDR” ( “uid” INTEGER identity(1, 1) not null , “name” VARCHAR(24), “begin_date” TIMESTAMP(0), “amount” DECIMAL(6, 2), prim…
阅读更多...
Spring AOP 入门教程：基础概念与实现

Spring AOP 入门教程：基础概念与实现

目录 第一章&#xff1a;AOP概念的引入 第二章&#xff1a;AOP相关的概念 1. AOP概述 2. AOP的优势 3. AOP的底层原理 第三章&#xff1a;Spring的AOP技术 - 配置文件方式 1. AOP相关的术语 2. AOP配置文件方式入门 3. 切入点的表达式 4. AOP的通知类型 第四章&#x…
阅读更多...
Upscayl-官方开源免费图像AI增强软件

Upscayl-官方开源免费图像AI增强软件

upscayl 链接&#xff1a;https://pan.xunlei.com/s/VOI0Szqe0fCwSSUSS8zRqKf7A1?pwdhefi#
阅读更多...
SpringBoot Web开发（SpringMVC)

SpringBoot Web开发（SpringMVC)

SpringBoot Web开发&#xff08;SpringMVC) MVC 核心组件和调用流程 Spring MVC与许多其他Web框架一样&#xff0c;是围绕前端控制器模式设计的&#xff0c;其中中央 Servlet DispatcherServlet 做整体请求处理调度&#xff01; . 除了DispatcherServletSpringMVC还会提供其他…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023