🧊 BigWind's Blog

3月6日小杂感

BigWind — Tue, 03 Jun 2025 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/3%E6%9C%886%E6%97%A5%E5%B0%8F%E6%9D%82%E6%84%9F/

import Info from "../../../components/mdx/Info.astro";

近来所思，杂碎的想法，姑且是篇散文。好久没有去更新自己的博客，好久没有去写下文字，代码固然简洁高效，却难以寄托我的情感，实习的日子过了又去，工作的变动一天接一天，那些复杂难喻的感受，在日复一日的Work中积累消磨，始终没有被表达。

我想人都是寂寞的，寂寞的雪也未曾在绵阳落下，倒是春雨淋漓了起来。

在这些或者那些的要求下，娱乐也变得单调省时了，偶尔几把王者，偶尔去晒晒难得一见的太阳。我在两地的高铁奔波，却极少放眼流动的景色。

在办公室伏案的日子里，我又错过了多少夕阳呢？

日出也是少见的，当我出门时，阳光还在寻找回归线...

当然努力也算有所见效的，至少...

希望往后的春光依旧明媚，等我忙完这阵子，到处去转转，想必是极好的。

而你呢？寂寞的游客，又是在哪的链接，寻得了这互联网的犄角旮旯，来见我。

祝你也有和煦的阳光洒落肩头，消融你的寂寞。

就这样...

Adding Comment Systems to Frosti

BigWind — Tue, 15 Apr 2025 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/adding-comment-systems/

Introduction

One of the essential features of any blog is the ability for readers to engage with your content through comments. While Frosti provides an excellent foundation for your Astro-based blog, adding a comment system requires a few additional steps. This guide will walk you through integrating the Waline comment system into your Frosti blog.

Static sites like those built with Astro don't have built-in comment systems since they lack server-side processing. However, we can use third-party comment services that handle the backend for us, while we integrate their frontend components into our site.

Creating Comment Components in Astro

Before diving into a specific comment system, let's understand how to create and use components in Astro. We'll create a reusable component that can be easily added to any page.

Component Structure

We'll create our comment component in the src/components/comments directory. First, let's ensure this directory exists:

mkdir -p src/components/comments

Integrating Waline

Waline is a simple, safe, and feature-rich comment system with backend and frontend separation. It is highly customizable and easy to set up.

Step 1: Set Up Waline Backend

Before adding Waline to your site, you need to set up the backend:

Create a LeanCloud application to store your comments.
Deploy the Waline server to Vercel or another hosting platform.

Follow the official Waline guide to set up your backend service. After deploying, you'll get a server URL that you will need for the frontend component.

Step 2: Create the Waline Component

Let's create a reusable Waline component:

touch src/components/comments/Waline.astro

Add the following code to this component:

---
interface Props {
  serverURL: string;
  lang?: string;
  dark?: string;
  emoji?: string[];
  meta?: string[];
  requiredMeta?: string[];
  reaction?: boolean;
  pageview?: boolean;
}

const {
  serverURL,
  lang = "en",
  dark = "html[data-theme-type='dark']",
  emoji = ["https://unpkg.com/@waline/emojis@1.1.0/weibo", "https://unpkg.com/@waline/emojis@1.1.0/bilibili"],
  meta = ["nick", "mail", "link"],
  requiredMeta = [],
  reaction = false,
  pageview = false,
} = Astro.props;
---

<div id="waline-container"></div>

<link rel="stylesheet" href="https://unpkg.com/@waline/client@v3/dist/waline.css" />

<script
  type="module"
  define:vars={{
    serverURL,
    lang,
    dark,
    emoji,
    meta,
    requiredMeta,
    reaction,
    pageview,
  }}
>
  import { init } from "https://unpkg.com/@waline/client@v3/dist/waline.js";

  let walineInstance;

  async function mountWaline() {
    if (walineInstance) {
      await walineInstance.destroy();
    }
    walineInstance = init({
      el: "#waline-container",
      serverURL,
      path: location.pathname,
      lang,
      dark,
      emoji,
      meta,
      requiredMeta,
      reaction,
      pageview,
    });
  }

  document.addEventListener("astro:after-swap", () => {
    mountWaline();
  });

  document.addEventListener("DOMContentLoaded", () => {
    mountWaline();
  });
</script>

<style>
  #waline-container {
    margin-top: 2rem;
    margin-bottom: 2rem;
  }
</style>

Step 3: Using the Waline Component

You can now use the Waline component in your Astro pages or layouts. Here's how to add it to your blog post template:

---
// In your blog post layout file
import Waline from "../../components/comments/Waline.astro";
// Other imports and frontmatter...
---

<!-- Your blog post content -->
<article>
  <slot />
</article>

<!-- Add the comment section -->
<section class="comments">
  <h2>Comments</h2>
  <Waline serverURL="https://your-waline-server.vercel.app" />
</section>

Replace "https://your-waline-server.vercel.app" with your actual Waline server URL.

Troubleshooting

Common Issues

Comments not displaying: Make sure your serverURL is correctly set and accessible.
CSS issues: Ensure that the Waline stylesheet is properly loaded.
Deployment issues: If your server is on Vercel, check the environment variables and deployment logs.

随笔虚拟生命

BigWind — Tue, 26 Nov 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/%E9%9A%8F%E7%AC%94-%E8%99%9A%E6%8B%9F%E7%94%9F%E5%91%BD/

import Info from "../../../components/mdx/Info.astro";

脑海中的残缺故事,梦后的只言片语

结尾

如今想来也是可笑，我是个悲观主义的代表，总是寂寥的看待万事万物，他是乐观主义的荣光，永远张扬着活力和春意。

到如今，我苟活着，倒有几分惬意和自由，他燃尽了光和热，决心和世界告别了。

可惜世界似乎并不记得他。

又或许他不想要被记得，无论是整个世界，还是我。不然怎么解释呢：对他的记忆模糊了，连同那些伤感、遗憾甚至快乐，都被抹去了？

我想我也是个虚拟生命，为着一串不知目的的核心代码活着。

自由在两种文化环境下的核心

BigWind — Mon, 11 Nov 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/%E8%87%AA%E7%94%B1%E5%9C%A8%E4%B8%A4%E7%A7%8D%E6%96%87%E5%8C%96%E7%8E%AF%E5%A2%83%E4%B8%8B%E7%9A%84%E6%A0%B8%E5%BF%83/

在西方

自由在英语的表达是Free，他，源自古英语 freo，意为“免除束缚；自主行动”，亦有“高贵；欢乐”之意，源于原始日耳曼语 * friaz * “被爱的；不受束缚”的词。

在近代Free还有免费的意思。

在东方的起源和变迁

而在中文中，自由最早的出处应该是史记的言贫富自由，无所予。

《孔雀东南飞》里面的母亲说岂敢自由专，来指责儿子的婚姻自作主张。在东西方的语境里，自由都是从阶级斗争中产生的Free可以指从奴隶制中的解放或者专制的解放。而在东方里自由这个词更强调在新民主运动以后，和德先生赛先生一起加入了中国的主要价值观。在此之前自由的提出，总是边角料的旁枝末节的。有人会把庄子当做自由的先贤，但庄子始终不在主流语境下保持着足够有震撼力的地位。

只有在东方的提出伴随着清朝时期殖民主义和帝国主义的双重压迫，是在压迫的过程中，广大民众呐喊出的心声。自由在东方总是要天街踏尽公卿骨的。总是带着王侯将相宁有种乎的。他是古老的，同时又是被忽视的，他是广为人知的，又同时是渺小无人在意的。

直到反帝国和反殖民主义的思潮如火如荼，自由的呐喊，才真正的宣告了东方哲学上的诞生。

因此自由在东方的价值观里代表着人民当家作主的核心要素和根本动力，代表着广大人民群众的主人翁精神，在东方的语境里自由不仅反掉了帝国主义殖民主义，各种杂七杂八的压迫的阶级性的主义，同时也加入了自己要当家作主的朴素要求。

自由在古文里是由自的倒装，我们很多人说自由自由，但是并不知道自由的字意是什么，由自己决定，这是东方古老的哲学。由人民当家作主，这是东方新的哲学，也是共产的哲学，主人翁的精神标识。

自由中间夹杂这半年以来的屈辱史带来的反思和无数前人先烈的探索和牺牲，因此在东方，自由即是一种追求，也是一种沉重的付出或者说代价。自由是有代价的，是有牺牲的。他令人们向往追求，又令人血泪尽付，肝脑涂地。

自由在西方的阶级性变化

但是在西方的语境，自由是免于束缚，更多的是奴隶制的束缚。自由中的阶级思想变得软弱了，甚至被遗忘了。在资本阶级的轰炸下，自由甚至是免费的。

因此近代西方的自由，更多的强调是免于付出代价。这种代价是制度的或者是资本的。自由在西方是脱缰野马，没有任何制度上的，道德上的基本的束缚。Free跟强调个体的独立，这种独立甚至是破坏性的。因为你很Free，所以你可以做出破坏阶级团结，破坏社区和谐，或者破坏当地人民利益的事情，而在这个方面，西方显示出了制度上的缺漏。

因此Free不仅美好，同时也可憎。西方的民众，坚信自由的代价是零的，因为他们没有偿还过这个代价，这个代价被拖欠了，阶级斗争和历史清算，没有结束，甚至没有开始。宣扬或者说叫嚣着自由的林肯，死前甚至仍有种植园和奴隶佣人。而西方奴隶制度的真正废除，法律上的废除，甚至在新世纪之后，而且废除的不动声色、怕人声张。换句话说，在西方，聪明的资本主义仍然在拖欠自由的结算，为此愿意付出高额的贷款利率，制度成本，并决意由他们的人民承担且继续长期的承担。

在西方自由是文明的灯塔是绝对的正确，但很少有人说自由是有代价的，他们总是把代价转移给他人。当漂亮国派兵阿富汗时，他们在能源上自由了，把当前制度上的代价转寄给阿富汗的广大人民，阿富汗人民由此进入了政权的真空期，混乱的萌芽期，于是他们叫嚣着，虽然你们失去了一切，但是你们自由了。他们把军事自由的代价交给了相信热爱国家并为此服上兵役的人民群众，他们把士兵道义上的困境，药物毒品的依赖，和美国人民极高的军事债务打包贷款了能源自由，即使这是一笔高利贷。他们毫不在乎，因为还款的不是他们，资产主义阶级把所有代价通过华丽的金融包装，赋予他的天选人民，再把巨额的钞票和利润揣进自己腰兜。美国人民由此破产，他们透支道义金融甚至是制度上的未来，资产主义唯一给他们带来的是拖延结算的美梦。

无论当今的西方是谁上台谁下台，最核心的政治纲领就是拖延自由的破产清算，不惜以制度破产，国家破产降低欠款。那么资本主义的自由能持续多久呢？换句话说，资本主义。想要拖到什么时候对自由进行破产清算呢？当然是拖到跑出国界时。我们常说资本无国界，但很遗憾，这是理想状态。资本想要实现高利率，就必须绑架国家。中国的古话就是窃国者侯。当资本和国家深度绑定的时候，脱钩无疑是需要时间的。

结语

资本想要的是脱钩，但广大的国家的人民群众想要的是清算。

旧时代的账不能总是拖着，让新时代的人民来偿还。把旧时代的资本主义扫进历史尘埃。至少能还清一部分自由的债务。

那个时候的Free，免费的账单终于有了顶额的清算。

What is Const in CPP

BigWind — Wed, 23 Oct 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/cpp/what-is-const-in-cpp/

import Collapse from "../../../components/mdx/Collapse.astro"; import Diff from "../../../components/mdx/Diff.astro"; import Error from "../../../components/mdx/Error.astro"; import Info from "../../../components/mdx/Info.astro"; import Kbd from "../../../components/mdx/Kbd.astro"; import Success from "../../../components/mdx/Success.astro"; import Warning from "../../../components/mdx/Warning.astro"; import TimeLine from "../../../components/mdx/TimeLine.astro"; import LinkCard from "../../../components/mdx/LinkCard.astro";

作用

修饰引用，指向常量的引用（reference to const），用于形参类型，即避免了拷贝，又避免了函数对值的修改；
修饰成员函数，说明该成员函数内不能修改成员变量。

const 的指针与引用

指针
- 指向常量的指针（pointer to const）
- 自身是常量的指针（常量指针，const pointer）
引用
1. 指向常量的引用（reference to const）
2. 没有 const reference，因为引用只是对象的别名，引用不是对象，不能用 const 修饰

const 的判断技巧

const总是先对左边生效再对右边生效

eg：int const a和 const int a 等价，在int const a 中const对左边int先生效。

*的效果取决于在const左边还是右边，*在左边为const指针，*在右边const指针的数据内存值。

eg: int const *p和 int * const p ，前者 * 在右为常量指针，后者为指针常量。

复杂度分析复习笔记

BigWind — Fri, 20 Sep 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/algorithm/complexity-analysis-review-notes/

复杂度分析犹如浩瀚的算法宇宙中的时空向导。它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。

算法效率评估

在算法设计中，我们先后追求以下两个层面的目标。

找到问题解法：算法需要在规定的输入范围内可靠地求得问题的正确解。
寻求最优解法：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。

也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。

时间效率：算法运行时间的长短。
空间效率：算法占用内存空间的大小。

简而言之，我们的目标是设计“既快又省”的数据结构与算法。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。

效率评估方法主要分为两种：实际测试、理论估算。

实际测试

缺点:

难以排除测试环境的干扰因素
展开完整测试非常消耗资源

理论估算

由于实际测试具有较大的局限性，因此我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为渐近复杂度分析（asymptotic complexity analysis），简称复杂度分析。

复杂度分析描述了随着输入数据大小的增加，算法执行所需时间和空间的增长趋势。

迭代与递归

迭代

迭代（iteration）是一种重复执行某个任务的控制结构。在迭代中，程序会在满足一定的条件下重复执行某段代码，直到这个条件不再满足。

常见代码迭代形式:

迭代形式	适用范围
for循环	适合在预先知道迭代次数时使用
while 循环	while与 for 循环类似，循环比 for 循环的自由度更高
嵌套循环	时间复杂度可能会随嵌套升幂

递归

递归（recursion）是一种算法策略，通过函数调用自身来解决问题。它主要包含两个阶段。

递：程序不断深入地调用自身，通常传入更小或更简化的参数，直到达到“终止条件”。
归：触发“终止条件”后，程序从最深层的递归函数开始逐层返回，汇聚每一层的结果。

而从实现的角度看，递归代码主要包含三个要素。

终止条件：用于决定什么时候由“递”转“归”。
递归调用：对应“递”，函数调用自身，通常输入更小或更简化的参数。
返回结果：对应“归”，将当前递归层级的结果返回至上一层。

对比

虽然从计算角度看，迭代与递归可以得到相同的结果，但它们代表了两种完全不同的思考和解决问题的范式。

迭代：“自下而上”地解决问题。从最基础的步骤开始，然后不断重复或累加这些步骤，直到任务完成。
递归：“自上而下”地解决问题。将原问题分解为更小的子问题，这些子问题和原问题具有相同的形式。接下来将子问题继续分解为更小的子问题，直到基本情况时停止（基本情况的解是已知的）。

以求和为例，f(n)=\sum n

迭代：在循环中模拟求和过程，从1遍历到n，每轮执行求和操作,1+2 -> 1+2+3 ->... ->1+2+...+n

递归：将问题分解为子问题,既f(n)=n+f(n-1),f(n-1)=n-1+f(n-2)..直至基本情况f(1)=1，再依次计算f(1)、f(2)...最终得到f(n)

	迭代	递归
实现方式	循环结构	函数调用自身
时间效率	效率通常较高，无函数调用开销	每次函数调用都会产生开销
内存使用	通常使用固定大小的内存空间	累积函数调用可能使用大量的栈帧空间
适用问题	适用于简单循环任务，代码直观、可读性好	适用于子问题分解，如树、图、分治、回溯等，代码结构简洁、清晰

时间复杂度

时间复杂度分析统计的不是算法运行时间，而是算法运行时间随着数据量变大时的增长趋势。

常见类型

设输入数据大小为n，常见的时间复杂度类型如图所示（按照从低到高的顺序排列）

算法的时间效率往往不是固定的，而是与输入数据的分布有关。

空间复杂度

算法在运行过程中使用的内存空间主要包括以下几种。

输入空间：用于存储算法的输入数据。
暂存空间：用于存储算法在运行过程中的变量、对象、函数上下文等数据。
输出空间：用于存储算法的输出数据。

一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。

暂存空间可以进一步划分为三个部分。

暂存数据：用于保存算法运行过程中的各种常量、变量、对象等。
栈帧空间：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
指令空间：用于保存编译后的程序指令，在实际统计中通常忽略不计。

设输入数据大小为n ，常见的空间复杂度类型（从低到高排列）:

降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然。

Q & A

Q：尾递归的空间复杂度是O(1)吗？

理论上，尾递归函数的空间复杂度可以优化至 O(1)。不过绝大多数编程语言（例如 Java、Python、C++、Go、C# 等）不支持自动优化尾递归，因此通常认为空间复杂度是O(n) 。

Q：函数和方法这两个术语的区别是什么？

函数（function）可以被独立执行，所有参数都以显式传递。方法（method）与一个对象关联，被隐式传递给调用它的对象，能够对类的实例中包含的数据进行操作。

下面以几种常见的编程语言为例来说明。

C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构体（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他编程语言中的方法。
Java 和 C# 是面向对象的编程语言，代码块（方法）通常作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
C++ 和 Python 既支持过程式编程（函数），也支持面向对象编程（方法）。

Q：图解“常见的空间复杂度类型”反映的是否是占用空间的绝对大小？

不是，该图展示的是空间复杂度，其反映的是增长趋势，而不是占用空间的绝对大小。

参考

Hello 算法-复杂度分析

开启Windows自带剪切板

BigWind — Wed, 11 Sep 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/enable_windows_built-in_clipboard/

在使用电脑💻的时候，大家会用上各种快捷操作😃，如果要说一个在世界范围内都能称之为“经典”的电脑入门操作，莫过于复制和粘贴这两个几乎人人必学的功能。

为什么要使用剪切板

复制和粘贴虽然经典，但是不少朋友也仅仅是复制粘贴，像是 Windows 系统自带的调出历史剪贴板内容的功能，可能一直都没有开启过。

开启剪贴板，在大批量或者高频复制粘贴有着独特优势，同时剪贴板可以较长时间暂存图片和格式信息。

例如有一百条学号号或者是好几段文献资料这类数据需要复制粘贴，如果只使用Ctrl+C/V就会有及其高频的切换页面/软件的行为。

一般来说Windows自带的剪切版就够用了，如果有更专业的需求，可以考虑剪切板增强工具，例如 EcoPaste

开启剪贴板

遗憾的是，在Windows电脑上，这个功能是默认关闭的

开启方法：Win+ V键

开启效果如下图：

键位介绍

请勿在剪贴板存储敏感数据，因为可能被其他风险软件/WEB获取

键	操作说明
`删除`键	删除剪贴板中某条选中的数据。
`固定`键	将某条选中数据固定，关机不会清空，适合高频不敏感数据。
`全部清除`键	清除剪贴板中的所有数据，除了使用`固定`键固定了的数据。

结语

现在你成功学会了使用剪贴版，快去试试吧！会使用剪贴板，会在繁杂的文档工作中助你一臂之力💝

如何测试自建邮箱的得分

BigWind — Thu, 05 Sep 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/how-to-test-the-score-of-a-self-built-mailbox/

很多朋友邮件发到 QQ 邮箱都进垃圾箱，或者干脆收不到，导致想要在朋友面前大显身手，结果颜面扫地😆，如何让你的邮件准确到达收件箱呢？

测试步骤

向测试邮箱发信

打开网站后会给你一个测试邮箱，点击复制后，在你的邮箱里发一份邮件，建议内容随便复制一段话(20个字左右即可) ❗不要留空,会减低评分

点击查看你的邮件得分

等待结果

如果是10分，恭喜你不用再折腾，如果不是，去下面没打勾的测试点击下拉查看详情并修改你的自建邮箱配置

一般来说自建邮箱开启DKIM认证非常重要，它使邮件可信且识别为重要

结语

对自建邮箱测试是非常重要的👍

我曾犯过偷懒💤的错，结果就是虽然邮箱的搭建是成功的，但被识别为垃圾邮件移送垃圾堆或钓鱼邮件被拒绝送达

这导致了我以为已回复的邮件，对方根本没找到或收到🙌,使得我的简历并没有送达或被回复📞

经常出现自建邮箱不好用，嫌折腾麻烦，看我这篇教程托管邮箱到lark 🚩使用Lark企业邮箱服务启用自定义域名邮箱

不过现在我轻松获得10分！你也来试试吧！

见近日青海路虎女逆行打人事件有感

BigWind — Mon, 02 Sep 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/feeling-about-the-recent-incident-of-a-land-rover-driving-in-the-opposite-direction-and-hitting-people-in-qinghai/

import Info from "../../../components/mdx/Info.astro";

事件起由

原报道：被逆行路虎女司机打伤男司机是退伍军人，事后女司机未向其道歉-新浪新闻

“逆行插队打人事件”发生于8月28日13时许。据青岛崂山区警方此前通报，38岁的女司机王某驾路虎车行至崂山区青山村观景台附近时逆向行驶，因对向正常行驶的26岁男司机林某某(退役军人)未对其让行，王某下车对林某某进行辱骂、殴打。

疑点

现场有黑衣男子身份不明，后续公告称女已被拘留，但有网友称“在家拘留”，并拍摄到图片。

罗翔老师推崇的幸福者退让原则

在近期另一个地方的惨剧，两名男子起了冲突，其一名男子怒火攻心，持刀杀害了另一名男子。评论区纷纷普及所谓的幸福者退让原则

什么是幸福者退让原则

主张在狭路相逢的冲突情境下，那些拥有更多资源、更稳定生活状态的个体应主动退让，避免与处于弱势地位的人针锋相对。这里的“命贵”，并非单纯指经济财富或社会地位，而是指个体所拥有的幸福感、安全感以及对未来生活的积极预期。

谁幸福？

幸福是一个相对值，而阶级不是。

你很难去比较谁更幸福，所谓的“那些拥有更多资源、更稳定生活状态的个体”在许多冲突并不成立,冲突的双方往往都是普通的劳苦大众，争夺的是个体微薄的利益或尊严，于是打上了所谓的补丁“这里的“命贵”，并非单纯指经济财富或社会地位，而是指个体所拥有的幸福感、安全感以及对未来生活的积极预期”。

而事实上，马克思说过，拥有更多的资源、财富，本质上就拥有了更多的对人的社会支配权。一个被支配的、压迫的、为生计疲于奔命的的人，你怎么说所谓的幸福？

所以幸福是一个相对值、比较值，它天然的具有"阶级性"。

站在道德的高点去讲幸福、不过是小资主义的修正幻想，指望着退让和妥协能赢得社会的和谐和解决阶级的矛盾。

所谓的“退让”，不过是没有社会地位、财富、资源来解决这场冲突，而以自己的利益受损来换取“稳定的未来”。两位商贩会为了一个更有顾客的档口打的头破血流，他们谁更幸福呢？

“三万姐”和人起了冲突，宁愿赔三万也不道歉，受了三万的人放弃了之前据理力争的“就要一个道歉”，他们谁更幸福呢？实质上，受了三万的人有现实的窘迫和实际的需求，只能以三万元来放下冲突和矛盾，矛盾只是被放下了，不是解决了。

资本主义把人变成鬼，这不是空话。

在实际生活中，往往是“不幸福”的人退让

两位人起了冲突，和稀泥的说法总是说“他怎么就打你，不打别人”，来迫使“不幸福”的退让。

“不幸福”的人才珍惜所谓的“幸福”，更糟糕的生存环境、更少的资源、更艰难的生活，更需要稳定，更遭不住所谓的变故。

故曰“麻绳专挑细处断，厄运专找苦命人”

每个人都会遇到“厄运”和“不幸福”，遇到这样的冲突和那样的矛盾。只是那些没有资源、财富的“苦命人”，任何一场小浪和风波都是致命的难关。

有人为孩子的学费卖命和尊严，乞求帮助，有人在医院病重不起，烧干了积蓄也只是杯水车薪，有人减肥用几十万一针的糖尿病特效药，有人一顿饭钱就是万千工人的年薪总和。

悲哀的、渺小的你，怎么能不退让？

让出资源、让出社会地位、接受剥削、接受不幸福，以汇聚成他们的幸福

“幸福”永远都是斗争出来的

以妥协求生存则亡，以斗争求生存则存

无论是国家的地位，还是个人的权益，都是斗争出来的，国家妥协了，美国的试探和祸心不会消失、个人妥协了、权益也不会凭空补足或生成。

改革到了“闯险滩，涉难关”的硬仗

如何促进公平正义，如何促进人民的幸福感、获得感、如何维护和代表最广大的人民的根本利益。如何在改革中发扬斗争精神、如何为人民打造“斗争精神”的生存土壤，是改革是否实现社会主义和提升民生福祉的本质要求。

如何坚定和推进“按劳分配为主体，多种分配方式并存”，减少社会的贫富差距，决定了广大人民是否拥护和改革的成功关键。

如何建设“法制社会”，决定了“有法必依、违法必究”的力度，更决定了广大人民的“法制精神”，只有更公平正义的维护人民切身利益的社会环境，人民才能用法律的武器去斗争，创造更公平正义的社会。

广大人民对公平正义的呼声越来越强烈，改革必须总是他们的心声和夙愿。

结语

没有法律的武器，就会有各种不公的矛盾。没有法律的武器，总会有别的武器。

使用Lark企业邮箱服务启用自定义域名邮箱

BigWind — Fri, 30 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/lark-email-uses-a-custom-domain-name/

什么是自定义域名邮箱？

像qq有@qq.com，微软有@outlook.com，如果你购买了一个心仪的域名eg:yourdomain.com，你也可以拥有一个自己的邮箱@yourdomain.com

拥有了自定义域名，是否想拥有自己的邮箱呢？

为什么要有一个自定义域名邮箱

✅ 你能拥有专属的邮箱域名
✅ 作为开发者更有逼格，值得用户信赖
✅ 可以减少不必要的打扰

如果你仅想接收邮件参考此教程即可-<a href={"/blog/web/lark-email-uses-a-custom-domain-name"}>仅接收邮件的搭建办法

为什么要用Lark企业邮箱

Lark是飞书海外版，提供企业邮箱，有更宽松的机制，且可以实现用Cloudfare托管难以解决的麻烦事--发邮件。

使用gmali代发仍会暴露我们的真实邮箱地址，这真的的很搞笑😂，你实际上在裸奔，且容易被识别为风险邮件而被拒绝或丢弃到垃圾箱，因此使用Lark来隐藏更好。

更重要的是，Lark提供企业级邮箱的稳定，无需维护的同时，国内直连可用 ！！！😍

完全不用担心收不到，Gmail收个邮箱还要用魔法，但谁一天24小时不间断挂着魔法呢？

SMTP 免费发送邮件功能限制：发信频率：200 封/100 秒，单日发信上限（一个发件人单日发信上限）450 封。这些限制对于大多数小型社区或个人项目来说已经绰绰有余。

使用步骤

点击Lark官网注册账号

Lark限制了国内注册，请自行使用魔法和选择模式全局代理，使用本机IP地址查询

填写个人信息，建议虚拟身份,避免暴露隐私图略

点击管理后台

选择产品设置-邮箱

选择开始设置

配置域名邮箱后缀

将配置生成的DNS参数解析到你的DNS域名服务商，我是CF

我这里已实现邮箱服务，所以显示的是搬家，但是新增和他差别不大，都是把参数解析到dns

选择立即验证通过后点击下一步

| 新增的图怕你看不懂还是加上了

选择立即配置

选择自己的账号配置后点击保存

设置公共邮箱

配置如图：

邮箱别名是指这个公共邮箱可以有多个地址,可以用不同的地址相同的密码和配置共享邮箱服务，很适合用来接收一次性验证码，后面可以把这个别名弃用防骚扰

保存后再次点击编辑即可看到 IMAP/SMTP 服务参数

可以看到邮箱的限制：

发信频率（调用 SMTP 服务的整体频率）200 封/ 100 秒

单日发信上限（一个发件人单日发信上限）450 封

邮箱总容量是200G

开启 DMARC

❗启用 DKIM 可以有效防范他人仿冒你的域名发信，同时尽量避免系统将你的外发邮件标记为垃圾邮件。

步骤是进入 Lark 管理后台，点击产品设置 > 邮箱 > 安全与反垃圾 > DKIM 身份验证

选择需要启用 DKIM 的域名，点击启用

使用默认2048 密钥长度

弹出需要域名解析需要的内容

到域名服务商设置域名解析增加TXT记录，添加完之后，点击立即验证

解析参考：

选择记录类型：TXT

主机记录框填写：弹出的信息

记录值填写：弹出的信息

其他默认就可。

验证成功后的效果

如何在第三方邮箱平台使用

如果你想要在手机或者电脑上使用第三方邮箱客户端来看邮件，请继续看

管理员账号开启第三方登录(默认)

点击看官方教程链接来检查是否开启权限

下载Lark客户端

看到这，有小伙伴要问了，为什么要下载呢？ [Lark | 立即下载Lark — 国际版](https://www.larksuite.com/zh_cn/download?from=navbar)

比较恶心的事发生了,账号的该设置选项仅在客户端有，你只能下载设置完成后在卸载

安装打开登录后

点击邮箱

点击设置

选择你需要的平台设备系统

注意不同系统的登录密码不共用

生成的结果如图：

打开第三方邮箱平台客户端

我这里是Win10下的outlook客户端

输入你的域名邮箱点击继续

选择IMAP

将Lark平台生成的配置填上去

SMTP密码可以留空,和IMAP一个密码,建议开启SSL防劫持

大功告成

你可以用其他邮箱测试我这里用qq邮箱发测试邮件，outlook客户端成功接收

结语

是不是很有成就感呢？现在你有一个独特的域名邮箱了，当然，它可以变成很多个，毕竟域名独属于你🌟

从今天开始，你是一个有企业邮箱的开发者了，看起来就很厉害(~~不是，实际上也很厉害~~)😡

点击这篇教程教你测试邮箱以确保万无一失 🚩如何测试自建邮箱的得分

有什么问题或看法，欢迎评论区留言！

使用Cloudfare启用自定义域名邮箱收邮件

BigWind — Fri, 30 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/use-cloudflare-to-enable-custom-domain-email-receiving/

什么是自定义域名邮箱？

像qq有@qq.com，微软有@outlook.com，如果你购买了一个心仪的域名eg:yourdomain.com，你也可以拥有一个自己的邮箱@yourdomain.com

拥有了自定义域名，是否想拥有自己的邮箱呢？

为什么要有一个自定义域名邮箱

✅ 你能拥有专属的邮箱域名

✅ 作为开发者更有逼格，值得用户信赖

✅ 可以减少不必要的打扰，你可以方便地添加一个特定的邮箱用于一次性注册白嫖，eg:想要在A网站获得服务，但不想接收广告，可以虚拟一个aserver@yourdomain.com来接收邮件

使用cloudfare快速白嫖邮箱服务

❗ 请提前将域名绑定解析到CF,该教程略过,其他人教程Cloudflare域名解析

CF虽快，但是只能接收邮件，发邮件设置较为麻烦，建议仅用来接收再搭建，发可以考虑使用Gmail代发或者Worker(复杂)

打开面板

按图片找到路由规则页面

点击创建

按提示添加保存即可

这时可以在面板上看到已创建并启用

测试一下

随便找个平台用你的域名邮箱接收验证码，查看你的接收邮箱123@qq.com是否收到

也可以在日志看到CF帮我实现了转发

这只实现了用123@qq.com接收test@bingwind.cn的邮箱，如果你选择回复，仍然会使用123@qq.com发送邮件而不是你的域名邮箱

如何实现所有自定义域名邮箱转发

如果你的域名只打算给自己用，且想用不同的邮箱账号来接收验证码或防打扰

使用Catch-all 地址

添加成功后你的所有域名邮箱都会发给你的接收邮箱

举例：你的域名为text.cn,test@xyz.cn、qq@xyz.cn等邮箱地址邮件都会发送到123@qq.com

恭喜你已完成所有工作，记得测试邮箱是否正常使用再关闭哦!

如果你想要发邮件

参考：

Cloudflare + Gmail + Resend 十分钟轻松拥有免费的企业邮箱

如何使用 Cloudflare 配置域名邮箱收发邮件 – 数字移民

这种使用Gmail代发邮件仍会暴露你的真实gamail邮箱地址，它会显示来自test@bigwind.cn由bigwind@gmail.com代发

如果你不想暴露真实邮箱，建议自建邮箱服务器或者使用大厂企业邮箱服务

参考我的另一篇博文 使用Lark企业邮箱服务启用自定义域名邮箱

waline评论插件表情链接cdn分享

BigWind — Fri, 30 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/waline%E8%AF%84%E8%AE%BA%E7%B3%BB%E7%BB%9F%E8%A1%A8%E6%83%85%E5%88%86%E4%BA%AB/

import Error from "../../../components/mdx/Error.astro"; import Info from "../../../components/mdx/Info.astro";

使用的框架在今天发现评论表情无法加载，于是自己搭建了cdn链接修复并分享

Title: 🛠️ Bug Report: [waline评论系统点击表情已不可用]

Description:

waline评论系统点击表情已不可用，报错如图，原因应该是原来框架的图床的桶设为私有或删除。

Proposed Fix or Solution:

修复建议：

我将其表情迁移到我的两个图床上(由于图床限制，第一个图床不能使用png动图)，很高兴你能使用，他们都是支持全球CDN访问的使用方法:替换原来框架的waline组件表情网络地址
组件路径：src/components/CommentWaline.astro

这是gif格式，这个图床的链接将是长久的

      "https://i.p-i.vip/37/20240828-66cf168c67b90.gif",
      "https://i.p-i.vip/37/20240828-66cf11c98f75c.gif",
      "https://i.p-i.vip/37/20240828-66cf16919077c.gif",
      "https://i.p-i.vip/37/20240828-66cf167ed75d1.gif",
      "https://i.p-i.vip/37/20240828-66cf168176744.gif",
      "https://i.p-i.vip/37/20240828-66cf16978ff66.gif",
      "https://i.p-i.vip/37/20240828-66cf13460d38a.gif",
      "https://i.p-i.vip/37/20240828-66cf1687607bb.gif",

png格式图床，这个图床是我自建的，所以有可能会被限速，但表情的下载速度问题应该不大

      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/good.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/bad.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/happy.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/color.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/confuse.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/heart.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/rocket.png",
      "https://pub-e9759568a2dc405c9565f765445e931e.r2.dev/eyes.png",

Contact Information:

Name: [BigWind]
Email: [bigwind@bigwind.cn]

看EveSunMaple博客《'局外人'读后感》有感

BigWind — Fri, 23 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/%E7%9C%8Bevesunmaple%E5%8D%9A%E5%AE%A2%E5%B1%80%E5%A4%96%E4%BA%BA%E8%AF%BB%E5%90%8E%E6%84%9F%E6%9C%89%E6%84%9F/

原文链接

局外人

原文

之前有人推荐我去看一本加缪的小说《局外人》，刚好手头无书好看，便从图书馆中借了一本来，同时还附了一本《鼠疫》。

看完后，我突然明白他为何推荐这本书给我了。在之前，我曾写了一篇五千字的长文，记录了一下自己的心迹。简单来说，就是对这世界的环境失望了：限制互联网上太多负能量的内容，他们发出来大多只是为了找寻一份安慰或鼓励——这本身挺好。可问题是，我们对于他们来说，不过是一个局外人罢了。一点点微不足道的安慰并不能改变他们所生活的环境，更不可能让他们忘记自己所经历过的事。我们这种局外人又做不了什么，反而会被这种情绪反噬，在我看来这是得不偿失的¹。

所以那时我说，一昧从外界找帮助是不会有用的，而是靠自己的！

但看完《局外人》后，我又不得不面对一种情况……

故事的主人公确是犯了罪，这没错。可问题在于他自己成为了自己事情的“局外人”：律师是法律安排找的；辩词不是自己口中说的；意识是被强加的。整个过程中，他仿佛成了一个符号，可以被自由地挪动在各大报纸上。前因后果是不重要的、本人的想法是可以不听的。反倒是之前去参加母亲葬礼的事被一次次炒作，将他与另一个罪犯相提并论，最终在人民面前“人头落地”。

记者只是为了更高的稿费；律师只是为了一次完美的辩护²；看似善良的神父也仅是执着于自己的信仰。无人关心这个事情的主角，主角成了局外人。

如此被裹挟的结果，主角好像也无力回天。也许他唯一能做的，不过是在上空，默默地看着自己被审判，然后死在广场上。

漠然地做了这么久的局外人³，没想到最后成了自己的局外人。

第一篇随笔，没什么思考，字也很差；最多的用处可能是证明我看了书。

原文（图片）

关于本文

推荐此书的人是：Nick Chen

BigWind读后评

有些时候我们太过于论心不论迹，总是对别人的真心和目的好奇、惶恐、悲伤，自然而然有种“局外人”之感，因为别人的真心和目的不总是关心与"我"的，故曰“他人既地狱”，先贤则劝“论迹不论心，论心无完人”。

即使是我们自个，与他人交往也经常会有别样的目的或心思，我们总是关注别人，也希望别人只关注自己，尼采想做所有人的太阳，便发了疯，喊着上帝已死，想来看着他心，不免悲哀，觉似在地狱18层。

但生活总要前进，与其穷究他人的根本，指望着他心通，不如修行自己。明己心如明月，便难以惹尘埃。了解个人的心思，坚定个人的志向，再借助他人的有意或无意的援助支持，才能化为鲲鹏。

想走进别人的生活，“局外人”是难免的，可经营自己的一生，不能总是困顿成自己的"局外人"。

共勉之。。。

🐤 建站神器：使用Cloudflare实现全站CDN

BigWind — Fri, 23 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/%E4%BD%BF%E7%94%A8cloudflare%E5%AE%9E%E7%8E%B0%E5%85%A8%E7%AB%99cdn/

很多站长会购买虚拟主机或VPS来部署，甚至直接部署在自己的NAS上。我们知道，这种部署环境普遍存在性能或带宽不足的问题，一旦机器宕机或网络出现问题，轻则用户访问缓慢，重则直接打不开网站。解决方案，那就是Cloudflare的Page Rules和Cache Rules功能

关于Cloudflare的Page Rules和Cache Rules功能，很多人分不清二者有什么区别和联系。简单说，Page Rules除了可以配置缓存规则外，还可以设置很多其他的规则；而Cache Rules仅用于设置缓存相关的规则，并且其缓存规则的优先级要高于Page Rules。

前提准备

• 你的网站域名需要在Cloudflare上解析，并且开启代理这是必要条件(传送门)
• 关闭Wordpress上的各种缓存插件，并清空缓存，这是建议

设置Page Rules

Cloudflare免费计划，每个域名可以免费添加3条页面规则，对于Wordpress来说正好够用，如果你是其他建站程序切勿直接照抄，要根据你的程序链接规则去设置。

第一步、从Cloudflare主页选择你的域名，进入到域名功能界面

第二步，展开左侧菜单，点击`规则`——`页面规则`，进入页面规则设置页面

第三步、点击`创建页面规则`按钮，一共添加3条规则，如下

1、设置管理后台规则(如果有后台的话)

规则名称	值
URL	https://www.bigwind.cn/admin* ，注意：这个网址要改成你自己的
浏览器完整性检查	开启
安全级别	高
缓存级别	绕过
IP地理位置表头	开启
电子邮件混淆技术	开启

如下图：
重点是，缓存级别一定要设置绕过，缓存级别一定要设置绕过，缓存级别一定要设置绕过，否则就麻烦大了！

2、设置首页、分类、页面及文章页规则

规则名称	值
URL	https://bigwind.cn/* ，注意：这个网址要改成你自己的
浏览器完整性检查	开启
安全级别	高
缓存级别	缓存所有内容
边缘缓存TTL	2小时。就是每隔2小时CDN会回源到源站获取更新，免费计划最短只能设置2小时，一般足够了。
浏览器缓存TTL	就是访客浏览器缓存页面的时间，默认是30分钟，最短可以设置2分钟。
IP地理位置表头	开启
电子邮件混淆技术	开启

如下图：

3、设置其他动态页面规则

例如评论、搜索等等。

规则名称	值
URL	https://waline-blog.bigwind.cn/* ，注意：这个网址要改成你自己的
浏览器完整性检查	开启
SSL	严格
安全级别	高
缓存级别	绕过
IP地理位置表头	开启
电子邮件混淆技术	开启

如下图：

重点也是缓存级别一定要设置绕过，不过设置错了不像管理后台规则那么严重。

以上我们就设置好了基本的网站页面规则，这时候可以保证网站的首页、分类、文章等页面都可以走CDN。这地方有个小技巧，设置完成以后自己到网站上把页面都点一遍，以触发页面缓存到CDN，等到真正的访客浏览网站时，就能秒开了！

设置Cache Rules

由于Cloudflare免费计划最多只能设置3条页面规则，我们设置了1个静态页面和2个动态页面规则之后，就用完了。但是，网站除了以上页面外，还有很多静态资源,比如图片、JS、CSS、字体等等，如果这些每次都从源站加载，还是会占用大量带宽，这时候Cache Rules（缓存规则）就排上用场了。

Cloudflare免费计划每个域名可以创建10条缓存规则，绰绰有余！下面我们就将静态资源加入到缓存中。

第一步、从Cloudflare主页选择你的域名，进入到域名功能界面

第二步、展开左侧菜单，点击`缓存`——`Cache Rules`，进入缓存规则设置页面

第三步、点击`创建规则`按钮，添加1条规则，如下

方法一：可以在界面中添加多个`Or`字段，表示符合其中任何一种就行。

方法二、因为静态资源的类型比较多，也可以直接点击`编辑表达式`，把下面的内容直接粘贴进去即可

(http.request.uri contains ".css") or (http.request.uri contains ".js") or (http.request.uri contains ".woff") or (http.request.uri contains ".jpg") or (http.request.uri contains ".png") or (http.request.uri contains ".svg") or (http.request.uri contains ".gif") or (http.request.uri contains ".bmp") or (http.request.uri contains ".ico") or (http.request.uri contains ".jpeg")

博客首页和文章页缓存

第四步、其他设置

继续往下拉，对其他设置项进行设置。

lsky 图床 - 图片缓存

以上我们就设置好了静态资源的缓存规则，这时候并不是马上就能生效了，而是会随着你的网站被访问逐渐被缓存到CDN。与页面规则通用的小技巧，设置完成以后自己到网站上把页面都点一遍，以触发页面缓存到CDN，等到真正的访客浏览网站时，静态资源就能秒加载了！

其他设置

除了页面规则和缓存规则设置，我们还可以充分利（白）用（嫖）Cloudflare的其他功能，以下几个功能建议开启：

1、Crawler Hints

当使用 Cloudflare 的站点更改内容时，Crawler Hints 会为搜索引擎和其他爬网程序提供高质量的数据。这样，爬网程序可以精确地抓取，避免浪费，同时可以普遍减少源服务器及其他 Internet 基础结构的资源消耗。
操作路径：缓存——配置——Crawler Hints

2、Always Online™

源服务器不可用时让访问者仍可访问您的网站。Cloudflare 可通过 Internet Archive 的 Wayback Machine 提供有限的网页副本。
操作路径：缓存——配置——Always Online™

3、Tiered Cache Topology

通过选择缓存拓扑，您可以控制源服务器与 Cloudflare 数据中心的连接方式，以确保缓存命中率更高、源服务器连接数更少，并且 Internet 延迟更短。
操作路径：缓存——Tiered Cache——Tiered Cache Topology™，选择Smart Tiered Caching Topology

清理缓存

最后，如果你修改了网站的主题或安装了新的插件或修改了代码等等，强烈建议你马上清理Cloudflare的CDN缓存，否则网站可能不能正常显示，或者各种错误。

操作路径：缓存——配置，最顶上就有清除缓存的操作按钮，支持自定义路径清除和清除所有内容，可按自己实际情况使用。

参考

🐤 建站神器：使用Cloudflare实现Wordpress全站CDN

在Cloudflare设置缓存规则全站加速WordPress博客

C++基础入门(02)_引用

BigWind — Wed, 21 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/cpp/c%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A802/

01.引用的使用场景（重点）

1.引用作为函数参数

//1.引用作为函数参数
void func(int &a, int &b)
{
    int sum = a + b;
    cout << "sum=" << sum << endl;
}

void test01()
{
    int a = 10;
    int b = 20;
    func(a, b);
}

2.引用作为函数的返回值

//2.引用作为函数的返回值
int& func2()
{
    int b = 10;//注意1：不要返回局部变量的引用
    int &p = b;
    return p;
}
int &func3()
{
    static int b = 10;
    return b;
}
void test02()
{
    int &q = func2();
    q = 100;
    cout << q << endl;

    func2() = 200;
    cout << q << endl;
////---------上面的代码是错误，只是编译器没有检测出来
    cout << "func2="<<func2() << endl;

    func3() = 100;//注意2：如果要函数当左值，那么该函数必须返回引用
    cout << "func3()=" << func3() << endl;
}

02.常量引用（了解）

int &ref=10;//err
const int &ref2=10;//ok
原理是:int tmp=10;const int &ref=tmp;

03.内联函数（了解）

1.宏函数的缺陷

#define ADD(x,y) x+y
//在普通函数前面加上inline是向编译器申请成为内联函数
//注意：加inline可能成为内联函数，可能不成为内联函数
inline int Add(int x, int y)
{
    return x + y;
}

void test()
{
    //10+20*2
    int ref = ADD(10, 20) * 2;
    cout << "ref=" << ref << endl;

    int ref2 = Add(10, 20) * 2;
    cout << "ref2=" << ref2 << endl;
}

#define COMAPD(x,y) ((x)<(y)?(x):(y))
inline int func(int x, int y)
{
    return x < y ? x : y;
}
void test02()
{
    int a = 1;
    int b = 3;
    //                        ((++a)<(b)?(++a):(b))      
    //cout << "COMAPD(x,y)=" << COMAPD(++a, b) << endl;//3
    cout << "func=" << func(++a, b) << endl;//2
}

2.什么情况不会成为内联函数

1.存在过多的条件判断语句

2.函数体过大

3.对函数进行取址操作

4.存在任何形式的循环语句

3.内联函数的好处

1.有宏函数的效率，没有宏函数的缺点

2.类的成员函数默认加上inline

4.在普通函数前面加上inline是申请成为内联函数

04.函数的默认参数（重点）

1.函数的默认参数就是给函数的形参赋值

int myFunc(int a, int b = 0)//int b=0;这就是函数的默认参数，不一定是0
{
    return a + b;
}
void test01()
{
    //函数的默认参数的作用
    //当函数内常要用到形参的某个值，但偶尔要使用其他值
    //增加函数的灵活性
    cout << myFunc(10, 20) << endl;
    cout << myFunc(10)<< endl;
}

2.函数的默认参数的注意事项

//注意1：函数的默认参数后面的参数必须都是默认参数
int myFunc2(int a, int b = 0, int c=2,int d=3)
{
    return a + b + c + d;
}
//注意2：函数的声明和实现不能同时有函数的默认参数
void myFunc3(int a, int b);
void myFunc3(int a, int b = 0)
{

}

05.函数的占位参数（了解）

//函数的占位参数,占位参数在后面运算符重载时区分前加加或后加加
void func(int a,int=10)//占位参数也有默认值
{

}

void test02()
{
    func(10);
}

函数的默认参数和占位参数的混搭

//占位参数和默认参数混搭
void func2(int=10, int a=20)
{

}
void test03()
{
    func2();
    func2(10);
    func2(10,30);
}

06.函数重载（重点）

1.函数重载是：允许函数名相同，这种现象叫函数重载

2.函数重载的作用：是为了方便使用函数名

3.函数重载的条件：同一个作用域，参数的个数不同，参数的顺序不同，参数的类型不同

//参数的个数不同
void func()
{
    cout << "func()" << endl;
}

void func(int a)
{
    cout << "func(int a)" << endl;
}

//参数的类型不同
void func(char c)
{
    cout << "func(char c)" << endl;
}
//参数的顺序不同
void func(int a, double b)
{
    cout << "func(int a, double b)" << endl;
}
void func(double b, int a)
{
    cout << "func(double b, int a)" << endl;
}

4.调用重载函数的注意：

严格的类型匹配，如果类型不匹配，那么尝试转换，转换成功就掉用，失败就报错

void test01()
{
    int a = 10;
    double b = 3.14;

    func();
    //func(b);// err double转换不了成为int或char
    func(a, b);
    func(b, a);
    char c = 'c';
    func(c);//char转换int成功，调用int参数的函数
}

5.函数重载和函数的默认参数一起使用，需要注意二义性问题

//函数重载和函的默认参数一起使用
void myfunc(int a, int b = 0)
{
    cout << "myfunc(int a, int b = 0)" << endl;
}

void myfunc(int a)
{
    cout << "myfunc(int a)" << endl;
}

void test02()
{
    //myfunc(10); err,二义性问题，不知道调用哪个函数
}

6.函数的返回值不作为函数重载的条件

编译器是通过你调用函数时，传入的参数来判断调用重载的哪个函数，我们调研函数时不需要写返回值，所以返回值不能成为函数重载的条件

07.函数重载的原理（重点）

1.函数重载的原理是在汇编时，给各个函数取别名，C语言不能重载的原因是没有取别名

2.生成汇编文件:gcc -S test.c -o test.s g++ -S test.cpp -o test2.s

3.查看内容:type 文件名

08.C++调用C语言的函数（重点）

1.C++的函数在汇编时，会给函数取别名，C语言的不会，这时，如果C++来调用C语言的函数，C++会去找取了别名的函数，但是C语言没有取别名，这时会出错

test.h文件中

//这是告诉C++编译器，找下面的函数，要以C语言的方式去寻找
#ifdef __cplusplus
extern "C"
{
#endif
    void func();//C语言的函数声明


#ifdef __cplusplus
}
#endif

09.类和对象的概念（重点）

1.类是自定义数据类型，是C语言的结构体进化而成的

2.对象是类实例化出的，用数据类型定义一个变量

class Maker//这个是类
{
public:
    int a;//成员属性（成员变量）
    void func()//成员方法（成员函数）
    {
        cout << "func" << endl;
    }
};

int main()
{
    Maker m;//m就是对象

    system("pause");
    return EXIT_SUCCESS;
}

10.类的封装（重点）

1.封装是把属性（变量）和方法（函数）封装到类内，然后给这些数据赋予权限

2.为什么要有封装

1.防止乱调用函数和变量，出现错误

2.维护代码更方便

3.权限

//封装：1,把属性和方法放到类中,2.给这些数据赋予权限
class Maker
{
public://公有权限
    void set(string Name,int Id)
    {
        id = Id;
        name = Name;
    }
    void printMaker()
    {
        cout << "id=" << id << " name=" << name << endl;
    }
private://私有
    int id;
    string name;

protected://保护
    int a;
};
//继承
class Son :public Maker
{
    void func()
    {
        a = 20;//子类的类内可以方法父类的保护权限的成员

    }
};
//类外不能访问私有权限的成员
//类外可以访问公有权限的成员
//类外不能访问保护权限的成员
//子类的类内可以方法父类的保护权限的成员
//类内是没有权限之分

void test()
{
    Maker m;
    m.set("小花",1);
    m.printMaker();


}

4.尽量把属性设置为私有权限

1.可以控制属性的读写权限

2.可赋予客户端访问数据的一致性

3.可以保护属性的合法性

11.类和结构体的区别（了解）

结构体的默认权限是公有的，类的默认权限是私有的

JAVA 前端丢失大Long精度问题

BigWind — Mon, 19 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/java/java-%E5%89%8D%E7%AB%AF%E4%B8%A2%E5%A4%B1%E5%A4%A7long%E7%B2%BE%E5%BA%A6%E9%97%AE%E9%A2%98/

使用JAVA开发Springboot项目,在后端使用LONG类型存储，前端获取数据会丢失精度

最近在使用RuoYi前后端分离版本发现问题，数据库的主键设计为雪花ID随机生成后，LONG类型的主键数据数据发送给前端精度丢失了

例如后端主键数据:7231278613075632128
       前端展示:7231278613075600000

可以看到前端数据的后几位变成了0，精度丢失

那么如何修复呢?

核心思想：将大LONG类型JSON数据序列化为String字符串再传给前端，由前端处理

局部解决

使用JSON序列化注解指定到具体字段

@Data
public class SysResource implements Serializable {
    /**
     * 主键id
     */
    @JsonSerialize(using = LongToStringConverter.class)
    private Long id;
}

@Component
public class LongToStringConverter extends JsonSerializer<Long> {

    @Override
    public void serialize(Long aLong, JsonGenerator jsonGenerator,
                          SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeString(aLong.toString());
    }
}

优点与问题

优点：只改变某个字段，影响可控且直观容易测试

缺点：项目存在大量大LONG类型字段传给前端添加繁琐且易遗漏

整体统一解决

//统一将 Long 类型序列化为 String
@Configuration
public class JacksonConfiguration {

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder -> {
            // 把 Long 类型序列化为 String
            builder.serializerByType(Long.class, ToStringSerializer.instance);
        };
    }
}

优点与问题

优点：整体统一改变序列化方式，可自定义，可通过排除代码来排除部分LONG序列化的字段

缺点：项目框架可能有兼容问题，前端已完成部分需要改动，例如ruoyi框架的pageNumber是LONG类型，前端控制台会报错需要在前端做类型转换或者在序列化容器代码里排除

总结

统一改变序列化方式解决前端丢失大Long精度问题更有自定义能力，可将部分字段排除，且符合SpringBoot的设计思想，但要注意项目本身的框架结构和已完成部分代码的影响，避免出现类型冲突

参考

雷丰阳-项目开发中的小技巧

若依(ruoyi)前后端分离代码生成如何实现自动导出字典字段值

BigWind — Mon, 19 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/java/%E8%8B%A5%E4%BE%9Druoyi%E5%89%8D%E5%90%8E%E7%AB%AF%E5%88%86%E7%A6%BB-%E4%BB%A3%E7%A0%81%E7%94%9F%E6%88%90%E5%A6%82%E4%BD%95%E5%AE%9E%E7%8E%B0%E8%87%AA%E5%8A%A8%E5%AF%BC%E5%87%BA%E5%AD%97%E5%85%B8%E5%AD%97%E6%AE%B5%E5%80%BC/

前提

了解框架的注解@Excel ，其中存在一个字段dictType

参数	类型	默认值	描述
dictType	String	空	如果是字典类型，请设置字典的type值 (如: sys_user_sex)

笨蛋法-手动给每个实体类导出字段添加

在对应实体类的字段@Excel添加(dictType="你的字典名")

eg:

class PatientDemo extends BaseEntity{
    //@Excel(name = "手术切除程度") 原来的样子 
    @Excel(name = "手术切除程度",dictType = "doc_resection_extent")  
    private String surgicalResection;
}

自动法-利用代码生成器

手动一是要自己去找到字典名复制修改，二是容易遗漏，因此更推荐自动法

确保你的项目里已有代码生成模块 generator

找到路径 src/main/resources/vm/java/domain.java.vm，找到如下代码

    @Excel(name = "${comment}

替换为

    //如果该实体类字段有字典则导出字典对应解释值，否则导出原数据
    #if( ""!=$column.getDictType())
    @Excel(name = "${comment}",dictType = "$column.getDictType()")
    #else
    @Excel(name = "${comment}")
    #end

重新启动项目，现在重新copy你的代码生成的实体类到项目里即可

云顶之弈/金铲铲 S12推荐阵容--堡垒学者阿狸

BigWind — Sun, 18 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/%E4%BA%91%E9%A1%B6%E4%B9%8B%E5%BC%88s12%E6%8E%A8%E8%8D%90%E9%98%B5%E5%AE%B9--%E5%A0%A1%E5%9E%92%E5%AD%A6%E8%80%85%E9%98%BF%E7%8B%B8/

这是低费赌狗阵容金铲铲强度略低t2左右，原因：阿里在铲的技能后摇长打假赛

什么时候推荐玩

以下条件满足任意其一

2-1时手中对应阵容牌多佐伊波比莉莉娅阿狸萨勒芬妮
可能独家
2-1赌狗海克斯备战席黄金门票小妮寇*2 天生2星(这个实测不咋地) 等
连败硬玩

装备推荐

主C阿狸目前根据b站up花花九分享的数据

推荐双头盔+大帽

其他英雄推荐出装优先出波比的波比是主坦(来的少给莉莉娅换主坦)

其次给瑞兹找装备一定要给灼烧装，鬼书和红Buff都行，其次是电刀，瑞兹的技能群体伤害+灼烧+电刀能较快给对面挂debuff和给脆皮补刀

佐伊在当前版本并不配吃装备，因为阿狸和佐伊都是单点爆发伤害，在作用上是重复的，而阿狸经常会出现打不死人丝血gg，所以需要瑞兹来带灼烧和减抗来大范围收割，其次佐伊的伤害依赖装备，而本阵容的装备数量在前中期并不够用，因此只有在中后期其他位置的装备满了或者实在适配佐伊，佐伊再吃是合理的决策

强化符文选择

没有也可以选择光明装备和神器，灵活变化

站位推荐和英雄选择

站位原理：单顶坦克，让对面集中，使阿狸等技能一串多，阿狸技能两段，第一段配合佐伊/瑞兹电刀/主坦离子的减抗接近真伤和第二段自带真伤快速清理前排。而瑞兹范围伤害收割对方

高手：阿狸对准主坦，瑞兹对准对面主C 自行调整

第一种-傻瓜站位莉莉娅先三推荐

第二种-傻瓜站位波比先三推荐

运营思路

2-1 不拉等级，前期留这几张牌，走连败最好，进野怪50块钱就是顺风，开香槟吧

2-7 打野怪前看一遍对手，确认有无同行，独家稳啦，一个能玩，两个看技术，三个跑路换其他赌狗阵容或卡30速拉等级到7转高费运营
打完野怪确认要玩，一波大递牌到30块

细节: 萨勒芬妮不卡其他牌可以留，三了可以用到瑞兹2再换，瑞兹装备全给萨勒芬妮过渡，给佐伊没拆拆就完啦；人马可以留一张避免格子不够用，2的快无视上一句。

后面每回合都可以卡30元递，感觉来牌浪了可以多刷2下，但是切勿上头经济崩盘，1费3星两个等级升6，阿狸三了上等级，人马看缘分，2星后可以不留攒钱。

细节：上面步骤英雄三星后升等级可以不考虑利息，连胜打压制给压力比经济重要

5级来人马且多，萨勒芬妮少或者没装备，可以下萨勒芬妮，先开2命运，也可以6级再开，命运选择器给阿狸(效果是3的英雄越多法强越高)
期间可以多买点实惠法杖，尤其是给所有1费英雄和给复制器的，或者加金币和装备的
后期8级来泽拉斯，命运选择器给泽拉斯(效果是买的法杖越多增伤越高)

其他

前期有命运转/灵活摇摆建议玩高命运，选择器给携带命运转的英雄(效果是纹章/铲子越多伤害越高)

参考

b站手刃猫咪堡垒学者阿狸！版本更新后大数据登顶阵容玩法介绍

b站花花九【443阿狸】一个视频让你提高上限玩阿狸不在老八

C++基础入门(01)_初识

BigWind — Sat, 17 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/cpp/c%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/

1 C++初识

1.1 第一个C++程序

编写一个C++程序总共分为4个步骤

创建项目
创建文件
编写代码
运行程序

1.1.1 创建项目

Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开

1.1.2 创建文件

右键源文件，选择添加->新建项

给C++文件起个名称，然后点击添加即可。

1.1.3 编写代码

#include<iostream>
using namespace std;

int main() {

	cout << "Hello world" << endl;

	system("pause");

	return 0;
}

1.1.4 运行程序

1.2 注释

作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码

两种格式

单行注释：// 描述信息
- 通常放在一行代码的上方，或者一条语句的末尾，==对该行代码说明==
多行注释： /* 描述信息 */
- 通常放在一段代码的上方，==对该段代码做整体说明==

提示：编译器在编译代码时，会忽略注释的内容

1.3 变量

作用：给一段指定的内存空间起名，方便操作这段内存

语法：数据类型变量名 = 初始值;

示例：

#include<iostream>
using namespace std;

int main() {

	//变量的定义
	//语法：数据类型  变量名 = 初始值

	int a = 10;

	cout << "a = " << a << endl;
	
	system("pause");

	return 0;
}

注意：C++在创建变量时，必须给变量一个初始值，否则会报错

1.4 常量

作用：用于记录程序中不可更改的数据

C++定义常量两种方式

#define 宏常量： #define 常量名常量值
- ==通常在文件上方定义==，表示一个常量
const修饰的变量 const 数据类型常量名 = 常量值
- ==通常在变量定义前加关键字const==，修饰该变量为常量，不可修改

示例：

//1、宏常量
#define day 7

int main() {

	cout << "一周里总共有 " << day << " 天" << endl;
	//day = 8;  //报错，宏常量不可以修改

	//2、const修饰变量
	const int month = 12;
	cout << "一年里总共有 " << month << " 个月份" << endl;
	//month = 24; //报错，常量是不可以修改的
	
	
	system("pause");

	return 0;
}

1.5 关键字

**作用：**关键字是C++中预先保留的单词（标识符）

在定义变量或者常量时候，不要用关键字

C++关键字如下：

asm	do	if	return	typedef
auto	double	inline	short	typeid
bool	dynamic_cast	int	signed	typename
break	else	long	sizeof	union
case	enum	mutable	static	unsigned
catch	explicit	namespace	static_cast	using
char	export	new	struct	virtual
class	extern	operator	switch	void
const	false	private	template	volatile
const_cast	float	protected	this	wchar_t
continue	for	public	throw	while
default	friend	register	true
delete	goto	reinterpret_cast	try

提示：在给变量或者常量起名称时候，不要用C++得关键字，否则会产生歧义。

1.6 标识符命名规则

作用：C++规定给标识符（变量、常量）命名时，有一套自己的规则

标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符中字母区分大小写

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读

2 数据类型

C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存

2.1 整型

作用：整型变量表示的是==整数类型==的数据

C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同：

数据类型	占用空间	取值范围
short(短整型)	2字节	(-2^15 ~ 2^15-1)
int(整型)	4字节	(-2^31 ~ 2^31-1)
long(长整形)	Windows为4字节，Linux为4字节(32位)，8字节(64位)	(-2^31 ~ 2^31-1)
long long(长长整形)	8字节	(-2^63 ~ 2^63-1)

2.2 sizeof关键字

**作用：**利用sizeof关键字可以==统计数据类型所占内存大小==

语法： sizeof( 数据类型 / 变量)

示例：

int main() {

	cout << "short 类型所占内存空间为： " << sizeof(short) << endl;

	cout << "int 类型所占内存空间为： " << sizeof(int) << endl;

	cout << "long 类型所占内存空间为： " << sizeof(long) << endl;

	cout << "long long 类型所占内存空间为： " << sizeof(long long) << endl;

	system("pause");

	return 0;
}

整型结论：==short < int <= long <= long long==

2.3 实型（浮点型）

作用：用于==表示小数==

浮点型变量分为两种：

单精度float
双精度double

两者的区别在于表示的有效数字范围不同。

数据类型	占用空间	有效数字范围
float	4字节	7位有效数字
double	8字节	15～16位有效数字

示例：

int main() {

	float f1 = 3.14f;
	double d1 = 3.14;

	cout << f1 << endl;
	cout << d1<< endl;

	cout << "float  sizeof = " << sizeof(f1) << endl;
	cout << "double sizeof = " << sizeof(d1) << endl;

	//科学计数法
	float f2 = 3e2; // 3 * 10 ^ 2 
	cout << "f2 = " << f2 << endl;

	float f3 = 3e-2;  // 3 * 0.1 ^ 2
	cout << "f3 = " << f3 << endl;

	system("pause");

	return 0;
}

2.4 字符型

**作用：**字符型变量用于显示单个字符

语法：char ch = 'a';

注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号

注意2：单引号内只能有一个字符，不可以是字符串

C和C++中字符型变量只占用==1个字节==。
字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

示例：

int main() {
	
	char ch = 'a';
	cout << ch << endl;
	cout << sizeof(char) << endl;

	//ch = "abcde"; //错误，不可以用双引号
	//ch = 'abcde'; //错误，单引号内只能引用一个字符

	cout << (int)ch << endl;  //查看字符a对应的ASCII码
	ch = 97; //可以直接用ASCII给字符型变量赋值
	cout << ch << endl;

	system("pause");

	return 0;
}

ASCII码表格：

ASCII值	控制字符	ASCII值	字符	ASCII值	字符	ASCII值	字符
0	NUT	32	(space)	64	@	96	、
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	\|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	`
31	US	63	?	95	_	127	DEL

ASCII 码大致由以下两部分组成：

ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

2.5 转义字符

**作用：**用于表示一些==不能显示出来的ASCII字符==

现阶段我们常用的转义字符有： \n \\ \t

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符""	092
'	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
?	代表一个问号	063
\0	数字0	000
\ddd	8进制转义字符，d范围0~7	3位8进制
\xhh	16进制转义字符，h范围0~~9，a~~f，A~F	3位16进制

示例：

int main() {
	
	
	cout << "\\" << endl;
	cout << "\tHello" << endl;
	cout << "\n" << endl;

	system("pause");

	return 0;
}

2.6 字符串型

作用：用于表示一串字符

两种风格

C风格字符串： char 变量名[] = "字符串值"

示例：

int main() {

    char str1[] = "hello world";
    cout << str1 << endl;
    
    system("pause");

    return 0;
}

注意：C风格的字符串要用双引号括起来

C++风格字符串： string 变量名 = "字符串值"

示例：

int main() {

    string str = "hello world";
    cout << str << endl;
    
    system("pause");

    return 0;
}

注意：C++风格字符串，需要加入头文件==#include<string>==

2.7 布尔类型 bool

**作用：**布尔数据类型代表真或假的值

bool类型只有两个值：

true --- 真（本质是1）
false --- 假（本质是0）

bool类型占==1个字节==大小

示例：

int main() {

	bool flag = true;
	cout << flag << endl; // 1

	flag = false;
	cout << flag << endl; // 0

	cout << "size of bool = " << sizeof(bool) << endl; //1
	
	system("pause");

	return 0;
}

2.8 数据的输入

作用：用于从键盘获取数据

**关键字：**cin

语法： cin >> 变量

示例：

int main(){

	//整型输入
	int a = 0;
	cout << "请输入整型变量：" << endl;
	cin >> a;
	cout << a << endl;

	//浮点型输入
	double d = 0;
	cout << "请输入浮点型变量：" << endl;
	cin >> d;
	cout << d << endl;

	//字符型输入
	char ch = 0;
	cout << "请输入字符型变量：" << endl;
	cin >> ch;
	cout << ch << endl;

	//字符串型输入
	string str;
	cout << "请输入字符串型变量：" << endl;
	cin >> str;
	cout << str << endl;

	//布尔类型输入
	bool flag = true;
	cout << "请输入布尔型变量：" << endl;
	cin >> flag;
	cout << flag << endl;
	system("pause");
	return EXIT_SUCCESS;
}

3 运算符

**作用：**用于执行代码的运算

本章我们主要讲解以下几类运算符：

运算符类型	作用
算术运算符	用于处理四则运算
赋值运算符	用于将表达式的值赋给变量
比较运算符	用于表达式的比较，并返回一个真值或假值
逻辑运算符	用于根据表达式的值返回真值或假值

3.1 算术运算符

作用：用于处理四则运算

算术运算符包括以下符号：

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10 + 5	15
-	减	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 5	2
%	取模(取余)	10 % 3	1
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
--	前置递减	a=2; b=--a;	a=1; b=1;
--	后置递减	a=2; b=a--;	a=1; b=2;

示例1：

//加减乘除
int main() {

	int a1 = 10;
	int b1 = 3;

	cout << a1 + b1 << endl;
	cout << a1 - b1 << endl;
	cout << a1 * b1 << endl;
	cout << a1 / b1 << endl;  //两个整数相除结果依然是整数

	int a2 = 10;
	int b2 = 20;
	cout << a2 / b2 << endl; 

	int a3 = 10;
	int b3 = 0;
	//cout << a3 / b3 << endl; //报错，除数不可以为0


	//两个小数可以相除
	double d1 = 0.5;
	double d2 = 0.25;
	cout << d1 / d2 << endl;

	system("pause");

	return 0;
}

总结：在除法运算中，除数不能为0

示例2：

//取模
int main() {

	int a1 = 10;
	int b1 = 3;

	cout << 10 % 3 << endl;

	int a2 = 10;
	int b2 = 20;

	cout << a2 % b2 << endl;

	int a3 = 10;
	int b3 = 0;

	//cout << a3 % b3 << endl; //取模运算时，除数也不能为0

	//两个小数不可以取模
	double d1 = 3.14;
	double d2 = 1.1;

	//cout << d1 % d2 << endl;

	system("pause");

	return 0;
}

总结：只有整型变量可以进行取模运算

示例3：

//递增
int main() {

	//后置递增
	int a = 10;
	a++; //等价于a = a + 1
	cout << a << endl; // 11

	//前置递增
	int b = 10;
	++b;
	cout << b << endl; // 11

	//区别
	//前置递增先对变量进行++，再计算表达式
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << b2 << endl;

	//后置递增先计算表达式，后对变量进行++
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << b3 << endl;

	system("pause");

	return 0;
}

总结：前置递增先对变量进行++，再计算表达式，后置递增相反

3.2 赋值运算符

**作用：**用于将表达式的值赋给变量

赋值运算符包括以下几个符号：

运算符	术语	示例	结果
=	赋值	a=2; b=3;	a=2; b=3;
+=	加等于	a=0; a+=2;	a=2;
-=	减等于	a=5; a-=3;	a=2;
*=	乘等于	a=2; a*=2;	a=4;
/=	除等于	a=4; a/=2;	a=2;
%=	模等于	a=3; a%2;	a=1;

示例：

int main() {

	//赋值运算符

	// =
	int a = 10;
	a = 100;
	cout << "a = " << a << endl;

	// +=
	a = 10;
	a += 2; // a = a + 2;
	cout << "a = " << a << endl;

	// -=
	a = 10;
	a -= 2; // a = a - 2
	cout << "a = " << a << endl;

	// *=
	a = 10;
	a *= 2; // a = a * 2
	cout << "a = " << a << endl;

	// /=
	a = 10;
	a /= 2;  // a = a / 2;
	cout << "a = " << a << endl;

	// %=
	a = 10;
	a %= 2;  // a = a % 2;
	cout << "a = " << a << endl;

	system("pause");

	return 0;
}

3.3 比较运算符

**作用：**用于表达式的比较，并返回一个真值或假值

比较运算符有以下符号：

运算符	术语	示例	结果
==	相等于	4 == 3	0
!=	不等于	4 != 3	1
<	小于	4 < 3	0
>	大于	4 > 3	1
<=	小于等于	4 <= 3	0
>=	大于等于	4 >= 1	1

示例：

int main() {

	int a = 10;
	int b = 20;

	cout << (a == b) << endl; // 0 

	cout << (a != b) << endl; // 1

	cout << (a > b) << endl; // 0

	cout << (a < b) << endl; // 1

	cout << (a >= b) << endl; // 0

	cout << (a <= b) << endl; // 1
	
	system("pause");

	return 0;
}

注意：C和C++ 语言的比较运算中， ==“真”用数字“1”来表示， “假”用数字“0”来表示。==

3.4 逻辑运算符

**作用：**用于根据表达式的值返回真值或假值

逻辑运算符有以下符号：

运算符	术语	示例	结果
!	非	!a	如果a为假，则!a为真；如果a为真，则!a为假。
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
\|\|	或	a \|\| b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

**示例1：**逻辑非

//逻辑运算符  --- 非
int main() {

	int a = 10;

	cout << !a << endl; // 0

	cout << !!a << endl; // 1

	system("pause");

	return 0;
}

总结：真变假，假变真

**示例2：**逻辑与

//逻辑运算符  --- 与
int main() {

	int a = 10;
	int b = 10;

	cout << (a && b) << endl;// 1

	a = 10;
	b = 0;

	cout << (a && b) << endl;// 0 

	a = 0;
	b = 0;

	cout << (a && b) << endl;// 0

	system("pause");

	return 0;
}

总结：逻辑==与==运算符总结： ==同真为真，其余为假==

**示例3：**逻辑或

//逻辑运算符  --- 或
int main() {

	int a = 10;
	int b = 10;

	cout << (a || b) << endl;// 1

	a = 10;
	b = 0;

	cout << (a || b) << endl;// 1 

	a = 0;
	b = 0;

	cout << (a || b) << endl;// 0

	system("pause");

	return 0;
}

逻辑==或==运算符总结： ==同假为假，其余为真==

4 程序流程结构

C/C++支持最基本的三种程序运行结构：==顺序结构、选择结构、循环结构==

顺序结构：程序按顺序执行，不发生跳转
选择结构：依据条件是否满足，有选择的执行相应功能
循环结构：依据条件是否满足，循环多次执行某段代码

4.1 选择结构

4.1.1 if语句

**作用：**执行满足条件的语句

if语句的三种形式

单行格式if语句
多行格式if语句
多条件的if语句

单行格式if语句：if(条件){ 条件满足执行的语句 }

示例：

int main() {

    //选择结构-单行if语句
    //输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印

    int score = 0;
    cout << "请输入一个分数：" << endl;
    cin >> score;

    cout << "您输入的分数为： " << score << endl;

    //if语句
    //注意事项，在if判断语句后面，不要加分号
    if (score > 600)
    {
        cout << "我考上了一本大学！！！" << endl;
    }

    system("pause");

    return 0;
}

注意：if条件表达式后不要加分号

多行格式if语句：if(条件){ 条件满足执行的语句 }else{ 条件不满足执行的语句 };

示例：

int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	if (score > 600)
	{
		cout << "我考上了一本大学" << endl;
	}
	else
	{
		cout << "我未考上一本大学" << endl;
	}

	system("pause");

	return 0;
}

多条件的if语句：if(条件1){ 条件1满足执行的语句 }else if(条件2){条件2满足执行的语句}... else{ 都不满足执行的语句}

示例：

	int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	if (score > 600)
	{
		cout << "我考上了一本大学" << endl;
	}
	else if (score > 500)
	{
		cout << "我考上了二本大学" << endl;
	}
	else if (score > 400)
	{
		cout << "我考上了三本大学" << endl;
	}
	else
	{
		cout << "我未考上本科" << endl;
	}

	system("pause");

	return 0;
}

嵌套if语句：在if语句中，可以嵌套使用if语句，达到更精确的条件判断

案例需求：

提示用户输入一个高考考试分数，根据分数做如下判断
分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。

示例：

int main() {

	int score = 0;

	cout << "请输入考试分数：" << endl;

	cin >> score;

	if (score > 600)
	{
		cout << "我考上了一本大学" << endl;
		if (score > 700)
		{
			cout << "我考上了北大" << endl;
		}
		else if (score > 650)
		{
			cout << "我考上了清华" << endl;
		}
		else
		{
			cout << "我考上了人大" << endl;
		}
		
	}
	else if (score > 500)
	{
		cout << "我考上了二本大学" << endl;
	}
	else if (score > 400)
	{
		cout << "我考上了三本大学" << endl;
	}
	else
	{
		cout << "我未考上本科" << endl;
	}

	system("pause");

	return 0;
}

练习案例： 三只小猪称体重

有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重？

4.1.2 三目运算符

作用： 通过三目运算符实现简单的判断

语法：表达式1 ? 表达式2 ：表达式3

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

示例：

int main() {

	int a = 10;
	int b = 20;
	int c = 0;

	c = a > b ? a : b;
	cout << "c = " << c << endl;

	//C++中三目运算符返回的是变量,可以继续赋值

	(a > b ? a : b) = 100;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	system("pause");

	return 0;
}

总结：和if语句比较，三目运算符优点是短小整洁，缺点是如果用嵌套，结构不清晰

4.1.3 switch语句

**作用：**执行多条件分支语句

语法：

switch(表达式)

{

	case 结果1：执行语句;break;

	case 结果2：执行语句;break;

	...

	default:执行语句;break;

}

示例：

int main() {

	//请给电影评分 
	//10 ~ 9   经典   
	// 8 ~ 7   非常好
	// 6 ~ 5   一般
	// 5分以下 烂片

	int score = 0;
	cout << "请给电影打分" << endl;
	cin >> score;

	switch (score)
	{
	case 10:
	case 9:
		cout << "经典" << endl;
		break;
	case 8:
		cout << "非常好" << endl;
		break;
	case 7:
	case 6:
		cout << "一般" << endl;
		break;
	default:
		cout << "烂片" << endl;
		break;
	}

	system("pause");

	return 0;
}

注意1：switch语句中表达式类型只能是整型或者字符型

注意2：case里如果没有break，那么程序会一直向下执行

总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

4.2 循环结构

4.2.1 while循环语句

**作用：**满足循环条件，执行循环语句

语法： while(循环条件){ 循环语句 }

解释：==只要循环条件的结果为真，就执行循环语句==

示例：

int main() {

	int num = 0;
	while (num < 10)
	{
		cout << "num = " << num << endl;
		num++;
	}
	
	system("pause");

	return 0;
}

注意：在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环

while循环练习案例：==猜数字==

**案例描述：**系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。

4.2.2 do...while循环语句

作用： 满足循环条件，执行循环语句

语法： do{ 循环语句 } while(循环条件);

**注意：**与while的区别在于==do...while会先执行一次循环语句==，再判断循环条件

示例：

int main() {

	int num = 0;

	do
	{
		cout << num << endl;
		num++;

	} while (num < 10);
	
	
	system("pause");

	return 0;
}

总结：与while循环区别在于，do...while先执行一次循环语句，再判断循环条件

练习案例：水仙花数

**案例描述：**水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身

例如：1^3 + 5^3+ 3^3 = 153

请利用do...while语句，求出所有3位数中的水仙花数

4.2.3 for循环语句

作用： 满足循环条件，执行循环语句

语法： for(起始表达式;条件表达式;末尾循环体) { 循环语句; }

示例：

int main() {

	for (int i = 0; i < 10; i++)
	{
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

详解：

注意：for循环中的表达式，要用分号进行分隔

总结：while , do...while, for都是开发中常用的循环语句，for循环结构比较清晰，比较常用

练习案例：敲桌子

案例描述：从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。

4.2.4 嵌套循环

作用： 在循环体中再嵌套一层循环，解决一些实际问题

例如我们想在屏幕中打印如下图片，就需要利用嵌套循环

示例：

int main() {

	//外层循环执行1次，内层循环执行1轮
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			cout << "*" << " ";
		}
		cout << endl;
	}

	system("pause");

	return 0;
}

**练习案例：**乘法口诀表

案例描述：利用嵌套循环，实现九九乘法表

4.3 跳转语句

4.3.1 break语句

作用: 用于跳出==选择结构==或者==循环结构==

break使用的时机：

出现在switch条件语句中，作用是终止case并跳出switch
出现在循环语句中，作用是跳出当前的循环语句
出现在嵌套循环中，跳出最近的内层循环语句

示例1：

int main() {
	//1、在switch 语句中使用break
	cout << "请选择您挑战副本的难度：" << endl;
	cout << "1、普通" << endl;
	cout << "2、中等" << endl;
	cout << "3、困难" << endl;

	int num = 0;

	cin >> num;

	switch (num)
	{
	case 1:
		cout << "您选择的是普通难度" << endl;
		break;
	case 2:
		cout << "您选择的是中等难度" << endl;
		break;
	case 3:
		cout << "您选择的是困难难度" << endl;
		break;
	}

	system("pause");

	return 0;
}

示例2：

int main() {
	//2、在循环语句中用break
	for (int i = 0; i < 10; i++)
	{
		if (i == 5)
		{
			break; //跳出循环语句
		}
		cout << i << endl;
	}

	system("pause");

	return 0;
}

示例3：

int main() {
	//在嵌套循环语句中使用break，退出内层循环
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (j == 5)
			{
				break;
			}
			cout << "*" << " ";
		}
		cout << endl;
	}
	
	system("pause");

	return 0;
}

4.3.2 continue语句

**作用：**在==循环语句==中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

示例：

int main() {

	for (int i = 0; i < 100; i++)
	{
		if (i % 2 == 0)
		{
			continue;
		}
		cout << i << endl;
	}
	
	system("pause");

	return 0;
}

注意：continue并没有使整个循环终止，而break会跳出循环

4.3.3 goto语句

**作用：**可以无条件跳转语句

语法： goto 标记;

**解释：**如果标记的名称存在，执行到goto语句时，会跳转到标记的位置

示例：

int main() {

	cout << "1" << endl;

	goto FLAG;

	cout << "2" << endl;
	cout << "3" << endl;
	cout << "4" << endl;

	FLAG:

	cout << "5" << endl;
	
	system("pause");

	return 0;
}

注意：在程序中不建议使用goto语句，以免造成程序流程混乱

5 数组

5.1 概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

**特点1：**数组中的每个==数据元素都是相同的数据类型==

**特点2：**数组是由==连续的内存==位置组成的

5.2 一维数组

5.2.1 一维数组定义方式

一维数组定义的三种方式：

数据类型数组名[ 数组长度 ];
数据类型数组名[ 数组长度 ] = { 值1，值2 ...};
数据类型数组名[ ] = { 值1，值2 ...};

示例

int main() {

	//定义方式1
	//数据类型 数组名[元素个数];
	int score[10];

	//利用下标赋值
	score[0] = 100;
	score[1] = 99;
	score[2] = 85;

	//利用下标输出
	cout << score[0] << endl;
	cout << score[1] << endl;
	cout << score[2] << endl;


	//第二种定义方式
	//数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
	//如果{}内不足10个数据，剩余数据用0补全
	int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
	
	//逐个输出
	//cout << score2[0] << endl;
	//cout << score2[1] << endl;

	//一个一个输出太麻烦，因此可以利用循环进行输出
	for (int i = 0; i < 10; i++)
	{
		cout << score2[i] << endl;
	}

	//定义方式3
	//数据类型 数组名[] =  {值1，值2 ，值3 ...};
	int score3[] = { 100,90,80,70,60,50,40,30,20,10 };

	for (int i = 0; i < 10; i++)
	{
		cout << score3[i] << endl;
	}

	system("pause");

	return 0;
}

总结1：数组名的命名规范与变量名命名规范一致，不要和变量重名

总结2：数组中下标是从0开始索引

5.2.2 一维数组数组名

一维数组名称的用途：

可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址

示例：

int main() {

	//数组名用途
	//1、可以获取整个数组占用内存空间大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;

	//2、可以通过数组名获取到数组首地址
	cout << "数组首地址为： " << (int)arr << endl;
	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;

	//arr = 100; 错误，数组名是常量，因此不可以赋值


	system("pause");

	return 0;
}

注意：数组名是常量，不可以赋值

总结1：直接打印数组名，可以查看数组所占内存的首地址

总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

练习案例1：五只小猪称体重

案例描述：

在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250};

找出并打印最重的小猪体重。

**练习案例2：**数组元素逆置

**案例描述：**请声明一个5个元素的数组，并且将元素逆置.

(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

5.2.3 冒泡排序

作用： 最常用的排序算法，对数组内元素进行排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
重复以上的步骤，每次比较次数-1，直到不需要比较

示例： 将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序

int main() {

	int arr[9] = { 4,2,8,0,5,7,1,3,9 };

	for (int i = 0; i < 9 - 1; i++)
	{
		for (int j = 0; j < 9 - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << endl;
	}
    
	system("pause");

	return 0;
}

5.3 二维数组

二维数组就是在一维数组上，多加一个维度。

5.3.1 二维数组定义方式

二维数组定义的四种方式：

数据类型数组名[ 行数 ][ 列数 ];
数据类型数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
数据类型数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
数据类型数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};

建议：以上4种定义方式，利用==第二种更加直观，提高代码的可读性==

示例：

int main() {

	//方式1  
	//数组类型 数组名 [行数][列数]
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

	//方式2 
	//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
	int arr2[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	//方式3
	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr3[2][3] = { 1,2,3,4,5,6 }; 

	//方式4 
	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr4[][3] = { 1,2,3,4,5,6 };
	
	system("pause");

	return 0;
}

总结：在定义二维数组时，如果初始化了数据，可以省略行数

5.3.2 二维数组数组名

查看二维数组所占内存空间
获取二维数组首地址

示例：

int main() {

	//二维数组数组名
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	cout << "二维数组大小： " << sizeof(arr) << endl;
	cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
	cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;

	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

	//地址
	cout << "二维数组首地址：" << arr << endl;
	cout << "二维数组第一行地址：" << arr[0] << endl;
	cout << "二维数组第二行地址：" << arr[1] << endl;

	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;

	system("pause");

	return 0;
}

总结1：二维数组名就是这个数组的首地址

总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

5.3.3 二维数组应用案例

考试成绩统计：

案例描述：有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩

	语文	数学	英语
张三	100	100	100
李四	90	50	100
王五	60	70	80

参考答案：

int main() {

	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80},
	};

	string names[3] = { "张三","李四","王五" };

	for (int i = 0; i < 3; i++)
	{
		int sum = 0;
		for (int j = 0; j < 3; j++)
		{
			sum += scores[i][j];
		}
		cout << names[i] << "同学总成绩为： " << sum << endl;
	}

	system("pause");

	return 0;
}

6 函数

6.1 概述

**作用：**将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

6.2 函数的定义

函数的定义一般主要有5个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

返回值类型 函数名 （参数列表）
{

       函数体语句

       return表达式

}

返回值类型：一个函数可以返回一个值。在函数定义中
函数名：给函数起个名称
参数列表：使用该函数时，传入的数据
函数体语句：花括号内的代码，函数内需要执行的语句
return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

**示例：**定义一个加法函数，实现两个数相加

//函数定义
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

6.3 函数的调用

**功能：**使用定义好的函数

语法： 函数名（参数）

示例：

//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
	int sum = num1 + num2;
	return sum;
}

int main() {

	int a = 10;
	int b = 10;
	//调用add函数
	int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
	cout << "sum = " << sum << endl;

	a = 100;
	b = 100;

	sum = add(a, b);
	cout << "sum = " << sum << endl;

	system("pause");

	return 0;
}

总结：函数定义里小括号内称为形参，函数调用时传入的参数称为实参

6.4 值传递

所谓值传递，就是函数调用时实参将数值传入给形参
值传递时，==如果形参发生，并不会影响实参==

示例：

void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	//return ; 当函数声明时候，不需要返回值，可以不写return
}

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "mian中的 a = " << a << endl;
	cout << "mian中的 b = " << b << endl;

	system("pause");

	return 0;
}

总结：值传递时，形参是修饰不了实参的

6.5 函数的常见样式

常见的函数样式有4种

无参无返
有参无返
无参有返
有参有返

示例：

//函数常见样式
//1、 无参无返
void test01()
{
	//void a = 10; //无类型不可以创建变量,原因无法分配内存
	cout << "this is test01" << endl;
	//test01(); 函数调用
}

//2、 有参无返
void test02(int a)
{
	cout << "this is test02" << endl;
	cout << "a = " << a << endl;
}

//3、无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 10;
}

//4、有参有返
int test04(int a, int b)
{
	cout << "this is test04 " << endl;
	int sum = a + b;
	return sum;
}

6.6 函数的声明

作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数的声明可以多次，但是函数的定义只能有一次

示例：

//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

int main() {

	int a = 100;
	int b = 200;

	cout << max(a, b) << endl;

	system("pause");

	return 0;
}

6.7 函数的分文件编写

**作用：**让代码结构更加清晰

函数分文件编写一般有4个步骤

创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义

示例：

//swap.h文件
#include<iostream>
using namespace std;

//实现两个数字交换的函数声明
void swap(int a, int b);

//swap.cpp文件
#include "swap.h"

void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

//main函数文件
#include "swap.h"
int main() {

	int a = 100;
	int b = 200;
	swap(a, b);

	system("pause");

	return 0;
}

7 指针

7.1 指针的基本概念

指针的作用： 可以通过指针间接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址

7.2 指针变量的定义和使用

指针变量定义语法： 数据类型 * 变量名；

示例：

int main() {

	//1、指针的定义
	int a = 10; //定义整型变量a
	
	//指针定义语法： 数据类型 * 变量名 ;
	int * p;

	//指针变量赋值
	p = &a; //指针指向变量a的地址
	cout << &a << endl; //打印数据a的地址
	cout << p << endl;  //打印指针变量p

	//2、指针的使用
	//通过*操作指针变量指向的内存
	cout << "*p = " << *p << endl;

	system("pause");

	return 0;
}

指针变量和普通变量的区别

普通变量存放的是数据,指针变量存放的是地址
指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结1：我们可以通过 & 符号获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

7.3 指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

示例：

int main() {

	int a = 10;

	int * p;
	p = &a; //指针指向数据a的地址

	cout << *p << endl; //* 解引用
	cout << sizeof(p) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl;

	system("pause");

	return 0;
}

总结：所有指针类型在32位操作系统下是4个字节

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间

**用途：**初始化指针变量

**注意：**空指针指向的内存是不可以访问的

示例1：空指针

int main() {

	//指针变量p指向内存地址编号为0的空间
	int * p = NULL;

	//访问空指针报错 
	//内存编号0 ~255为系统占用内存，不允许用户访问
	cout << *p << endl;

	system("pause");

	return 0;
}

野指针：指针变量指向非法的内存空间

示例2：野指针

int main() {

	//指针变量p指向内存地址编号为0x1100的空间
	int * p = (int *)0x1100;

	//访问野指针报错 
	cout << *p << endl;

	system("pause");

	return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

7.5 const修饰指针

const修饰指针有三种情况

const修饰指针 --- 常量指针
const修饰常量 --- 指针常量
const即修饰指针，又修饰常量

示例：

int main() {

	int a = 10;
	int b = 10;

	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错
	

	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");

	return 0;
}

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

7.6 指针和数组

**作用：**利用指针访问数组中元素

示例：

int main() {

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

	int * p = arr;  //指向数组的指针

	cout << "第一个元素： " << arr[0] << endl;
	cout << "指针访问第一个元素： " << *p << endl;

	for (int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}

	system("pause");

	return 0;
}

7.7 指针和函数

**作用：**利用指针作函数参数，可以修改实参的值

示例：

//值传递
void swap1(int a ,int b)
{
	int temp = a;
	a = b; 
	b = temp;
}
//地址传递
void swap2(int * p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {

	int a = 10;
	int b = 20;
	swap1(a, b); // 值传递不会改变实参

	swap2(&a, &b); //地址传递会改变实参

	cout << "a = " << a << endl;

	cout << "b = " << b << endl;

	system("pause");

	return 0;
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

7.8 指针、数组、函数

**案例描述：**封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

示例：

//冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组函数
void printArray(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

int main() {

	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int len = sizeof(arr) / sizeof(int);

	bubbleSort(arr, len);

	printArray(arr, len);

	system("pause");

	return 0;
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

8 结构体

8.1 结构体基本概念

结构体属于用户==自定义的数据类型==，允许用户存储不同的数据类型

8.2 结构体定义和使用

语法：struct 结构体名 { 结构体成员列表 }；

通过结构体创建变量的方式有三种：

struct 结构体名变量名
struct 结构体名变量名 = { 成员1值，成员2值...}
定义结构体时顺便创建变量

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}stu3; //结构体变量创建方式3 


int main() {

	//结构体变量创建方式1
	struct student stu1; //struct 关键字可以省略

	stu1.name = "张三";
	stu1.age = 18;
	stu1.score = 100;
	
	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

	//结构体变量创建方式2
	struct student stu2 = { "李四",19,60 };

	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;


	stu3.name = "王五";
	stu3.age = 18;
	stu3.score = 80;
	

	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;

	system("pause");

	return 0;
}

总结1：定义结构体时的关键字是struct，不可省略

总结2：创建结构体变量时，关键字struct可以省略

总结3：结构体变量利用操作符 ''.'' 访问成员

8.3 结构体数组

**作用：**将自定义的结构体放入到数组中方便维护

语法： struct 结构体名数组名[元素个数] = { {} , {} , ... {} }

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}

int main() {
	
	//结构体数组
	struct student arr[3]=
	{
		{"张三",18,80 },
		{"李四",19,60 },
		{"王五",20,70 }
	};

	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
	}

	system("pause");

	return 0;
}

8.4 结构体指针

**作用：**通过指针访问结构体中的成员

利用操作符 -> 可以通过结构体指针访问结构体属性

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};


int main() {
	
	struct student stu = { "张三",18,100, };
	
	struct student * p = &stu;
	
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	
	system("pause");

	return 0;
}

总结：结构体指针可以通过 -> 操作符来访问结构体中的成员

8.5 结构体嵌套结构体

作用： 结构体中的成员可以是另一个结构体

**例如：**每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//教师结构体定义
struct teacher
{
    //成员列表
	int id; //职工编号
	string name;  //教师姓名
	int age;   //教师年龄
	struct student stu; //子结构体 学生
};


int main() {

	struct teacher t1;
	t1.id = 10000;
	t1.name = "老王";
	t1.age = 40;

	t1.stu.name = "张三";
	t1.stu.age = 18;
	t1.stu.score = 100;

	cout << "教师 职工编号： " << t1.id << " 姓名： " << t1.name << " 年龄： " << t1.age << endl;
	
	cout << "辅导学员 姓名： " << t1.stu.name << " 年龄：" << t1.stu.age << " 考试分数： " << t1.stu.score << endl;

	system("pause");

	return 0;
}

**总结：**在结构体中可以定义另一个结构体作为成员，用来解决实际问题

8.6 结构体做函数参数

**作用：**将结构体作为参数向函数中传递

传递方式有两种：

值传递
地址传递

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//值传递
void printStudent(student stu )
{
	stu.age = 28;
	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}

//地址传递
void printStudent2(student *stu)
{
	stu->age = 28;
	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}

int main() {

	student stu = { "张三",18,100};
	//值传递
	printStudent(stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;

	cout << endl;

	//地址传递
	printStudent2(&stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;

	system("pause");

	return 0;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

8.7 结构体中 const使用场景

**作用：**用const来防止误操作

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//const使用场景
void printStudent(const student *stu) //加const防止函数体中的误操作
{
	//stu->age = 100; //操作失败，因为加了const修饰
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;

}

int main() {

	student stu = { "张三",18,100 };

	printStudent(&stu);

	system("pause");

	return 0;
}

8.8 结构体案例

8.8.1 案例1

案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生数据。

示例：

struct Student
{
	string name;
	int score;
};
struct Teacher
{
	string name;
	Student sArray[5];
};

void allocateSpace(Teacher tArray[] , int len)
{
	string tName = "教师";
	string sName = "学生";
	string nameSeed = "ABCDE";
	for (int i = 0; i < len; i++)
	{
		tArray[i].name = tName + nameSeed[i];
		
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].name = sName + nameSeed[j];
			tArray[i].sArray[j].score = rand() % 61 + 40;
		}
	}
}

void printTeachers(Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << tArray[i].name << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}

int main() {

	srand((unsigned int)time(NULL)); //随机数种子 头文件 #include <ctime>

	Teacher tArray[3]; //老师数组

	int len = sizeof(tArray) / sizeof(Teacher);

	allocateSpace(tArray, len); //创建数据

	printTeachers(tArray, len); //打印数据
	
	system("pause");

	return 0;
}

8.8.2 案例2

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄信息如下：

		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},

示例：

//英雄结构体
struct hero
{
	string name;
	int age;
	string sex;
};
//冒泡排序
void bubbleSort(hero arr[] , int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j].age > arr[j + 1].age)
			{
				hero temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
//打印数组
void printHeros(hero arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名： " << arr[i].name << " 性别： " << arr[i].sex << " 年龄： " << arr[i].age << endl;
	}
}

int main() {

	struct hero arr[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};

	int len = sizeof(arr) / sizeof(hero); //获取数组元素个数

	bubbleSort(arr, len); //排序

	printHeros(arr, len); //打印

	system("pause");

	return 0;
}

Icacls 教程

BigWind — Tue, 13 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/icacls-%E6%95%99%E7%A8%8B/

Excerpt

如果您通过 Windows 文件资源管理器之类的工具检查和更改文件权限，则必须单击周围并打开/更改每个文件和文件夹的权限。如果您需要修改一两个权限，此方法就很好。但也许您想要确定和更改文件夹中一百个或更多文件的权限。让 icacls 命令作为解决方案。

如果您通过 Windows 文件资源管理器之类的工具检查和更改文件权限，则必须单击周围并打开/更改每个文件和文件夹的权限。如果您需要修改一两个权限，此方法就很好。但也许您想要确定和更改文件夹中一百个或更多文件的权限。让 icacls 命令作为解决方案。

在本教程中，您将了解有关 icacls 命令如何允许您读取、保存、恢复文件和文件夹权限的所有内容。

让我们开始吧！

先决条件

本教程包含分步说明。要继续操作，请确保您已具备以下条件：

具有管理员权限的 Windows 服务器或客户端 PC。
如果您想了解如何更改远程计算机上的权限，请打开打开 Windows 文件和打印共享端口的远程 Windows 计算机。
Microsoft 的 Process Explorer v16.42（可选）显示哪个程序打开了特定文件或目录。

了解 `icacls` 命令是什么及其工作原理

有时，用户无法访问或修改文件或文件夹，原因之一是缺乏对该对象的用户权限。 icacls 命令是一个命令行实用程序，用于查看或修改 Windows 文件系统上的文件或文件夹权限。

但在使用 icacls 命令更改文件和文件夹权限之前，您必须首先了解访问控制列表 (ACL)。在此上下文中，ACL 包含用户或组对 NTFS 文件系统内的对象的权限列表。

ACL 中的每个条目称为访问控制条目 (ACE)。 ACE 包含权限以及有关子对象如何继承这些权限的详细信息。 NTFS 权限可保护系统免受未经授权的访问。

icacls 命令可以在高级安全设置页面中的文件或文件夹属性中设置许多精细的权限。这些权限包括允许或拒绝特定权限，以及基本的读/写权限。

要查看文件或文件夹的高级权限：

1. 打开文件资源管理器，右键单击文件或文件夹，然后从上下文菜单中选择属性。

2. 点击安全选项卡 —> 高级访问文件或文件夹的高级安全设置。

在高级视图中，您将看到一个权限选项卡以及构成该文件系统对象的 ACL 的每个 ACE。

3. 双击列表中的任意ACE，弹出权限输入对话框。

4. 现在，单击显示高级权限链接，深入了解该对象上设置的所有单独权限。

在下面，您可以看到授予或拒绝文件或文件夹的用户 ID 的所有高级权限。

运行基本 `icacls` 命令语法

现在您已经了解了查看和更改文件/文件夹权限所涉及的所有单击操作，现在让我们学习如何使用 icacls 命令来使用命令行。

icacls 命令接受许多开关和参数来成功更改文件和文件夹权限，但让我们从运行基本的 icacls 命令语法开始。

打开命令提示符并按原样输入 icacls 命令以查看其默认输出。您可以在下面看到icacls命令的所有开关的帮助信息，并且默认显示参数。

也许您想查看文件或文件夹的现有权限。如果是这样，基本的 icacls 命令语法命令就足够了。为了演示，创建一个文件夹，然后运行 icacls 来查看其权限，如下所示。

# Make a new folder named Folder1 md Folder1 # Checking permissions of the folder named Folder1 icacls Folder1

icacls 返回分配给对象的 ACL；在本例中，Folder 文件夹包含其中的所有 ACE。在下面，您可以看到 BUILTIN\Administrators 和 NT AUTHORITY\SYSTEM 用户 ID 拥有对象继承的完整 (F) 权限 (OI) 和容器继承**(CI)**。

另一方面，BUILTIN\Users 用户 ID 表示 PC 上的本地用户组具有对象继承**(OI)** 和容器继承**(CI)<** 启用，以及读取和执行访问权限。 （接收）

最后，两个 NT AUTHORITY\Authenticated Users 用户 ID 表明经过身份验证的用户组具有修改级别 (M) 访问权限，并且启用了对象继承 (OI) 和容器继承 (CI)。

保存和恢复文件和文件夹的 ACL

更改文件和文件夹权限是一项敏感任务；一个错误的举动可能会扰乱用户访问或组访问。好消息是 icacls 命令允许您保存 ACL 文件。 ACL 文件包含文件和文件夹的 ACL。

为了演示如何保存和恢复 ACL，我们首先创建一个名为 C:\Temp\Folder1 的文件夹，并通过运行以下命令保存该文件夹的所有权限。

1. 运行下面的 icacls 命令以递归方式 (/T) 备份文件和文件夹的 ACL (c:\Temp\Folder1) 并将它们保存 (/save) 到文件 (C:\Folder1ACL) 中。

# Make a new folder named Folder1 md c:\Temp\Folder1 # Save folder1's permissions to a file named Folder1ACL icacls c:\Temp\Folder1 /save c:\Folder1ACL /T

在下面，您可以看到您已经创建了一个新文件夹，并成功将该文件夹的 ACL 保存在 ACL 文件中。通过运行 dir 命令确认 ACL 文件 (Folder1ACL) 存在。

2. 现在，像之前一样访问_Folder1_的高级安全设置。下面，通过单击添加按钮将新用户添加到文件夹权限。

3. 单击下面的选择主体选项，选择要添加到_Folder1_权限的用户或组。在弹出窗口中输入要添加的用户或组 ID，然后单击检查名称。找到用户或组 ID 后，单击确定。

4. 通过选中完全控制选项，授予新用户对_Folder1_的完全权限，然后单击确定。

在下面，您可以看到 User02 已添加到 Folder1 的权限中并被授予完全权限。

5. 现在您已经更改了文件夹的权限，请使用之前保存的 ACL 文件恢复原始权限。

在下面的命令中，您将恢复 (/restore) Folder1 ACL，这些 ACL 保存在位于目录 (Folder1ACL) 的文件 (Folder1ACL) 中c:\）。

icacls c:\Temp\ /restore c:\Folder1ACL

6. 最后，通过访问_Folder1_的高级安全设置来确认是否恢复了原始权限。

下面可以看到之前添加的Usre02被删除了，说明ACL文件中原来的权限被恢复了。

授予用户对文件和文件夹的权限

通过学习 icacls 命令的基本语法，现在可以为文件和文件夹设置一些基本权限。 icacls 命令允许您通过开关授予、拒绝或删除文件或文件夹的权限。让我们介绍一下这些开关的使用方法。

也许您无法访问或修改文件或文件夹。在这种情况下，您可以使用 /grant 开关向用户授予适当的权限。

下面，该命令将向用户 (user01) 对 myfile.txt 授予 (`/grant`) 完全权限 (`F`) 文件。

也可以使用 Active Directory (AD) 或本地组名称来代替用户 ID (user01)。

icacls myfile.txt /grant user01:F

向用户授予对文件夹的权限与授予对文件的权限的方式不同。

下面，该命令将向用户 (user01) 对 MyFolder 授予 (/grant) 读取权限 (R)代码> 文件夹。

icacls Folder1 /grant user01:R

icacls 命令还允许您为文件或文件夹设置特殊权限。下面，您向用户 (user01）位于文件夹 (Folder1) 上。

icacls Folder1 /grant user02:(D,RD)

当您使用特殊权限（例如 RD，如下所示）时，必须将它们括在括号中。

拒绝用户对文件和文件夹的权限

在某些情况下，您可能想要明确拒绝用户或组对文件或文件夹的访问。您可以使用 /deny 开关来执行此操作。

使用以下命令拒绝单个用户对文件和文件夹的完全权限。以下命令将确保 user01 无法访问 MyFile.txt 文件和 MyFolder 文件夹。

# Deny (/deny) full permissions (F) for a user (user01) on a file (MyFile.txt) icacls MyFile.txt /deny user01:F # Deny (/deny) full permissions (F) for a user (user01) on a folder (MyFolder) icacls MyFolder /deny user01:(F)

删除用户对文件和文件夹的权限

也许您想要删除用户当前对文件或文件夹拥有的所有权限。在这种情况下，请结合使用 /remove 开关和 icacls 命令。

以下命令删除 user01 对文件和文件夹的所有权限。命令完成后，user01 无法再访问或修改 myfile.txt 文件和名为 Folder1 的文件夹。

# Removing all user01's permissions from myfile.txt icacls myfile.txt /remove user01 # Removing all user01's permissions from Folder1 icacls Folder1 /remove user01

使用完整性级别保护文件和文件夹

除了权限之外，Windows 中的所有对象（例如文件、文件夹、注册表项、正在运行的进程和用户会话）都包含完整性级别。

您可以将完整性级别应用于任何具有安全描述符的对象。即使用户对文件或文件夹具有完全权限，完整性级别也可以为不太可信的对象设置更严格的权限。

请参阅下表中的可以为 Windows 对象设置的完整性级别列表。

Integrity Level Name	Explanation	Example
Untrusted	Processes that are launched automatically are marked as Untrusted.	Apps like Edge and chrome launch their update processes automatically. They are marked as untrusted.
Low	Very restricted integrity level. Processes with low integrity level cannot write to registry and they have very limited access on files and folders.	Internet Explorer in protected mode has low integrity level.
Medium	This is the integrity level that most of the objects will have. Standard or non-admin users get this medium integrity level. Also objects that are not marked as low or high will be in medium integrity level by default.
High	Admins have the high integrity level by default. With this admins can interact with other objects with high integrity levels and objects with medium and low integrity levels.	Processes started with “Run as Administrator” option or elevated.
System	This integrity level is assigned to windows OS files and core services.	Windows Services that run under local service, network service or NT authority\system.
Installer	Installer integrity level is highest of all other integrity levels. Objects that has installer integrity level can also uninstall other objects as they are almost equal to High integrity level.

也许您很好奇为计算机上运行的每个 Windows 进程设置了哪个完整性级别。如果是这样，请启动 Microsoft Process Explorer，右键单击任意列标题，然后单击选择列，如下所示。

现在，通过选中选择列弹出窗口中的完整性级别选项，在表格列表中添加完整性列，然后点击确定。

请注意，完整性列将显示在进程表列表的最右侧部分，您将在其中看到每个进程的完整性级别。

限制非管理员用户修改文件或文件夹

在文件或文件夹上设置高完整性级别当您想要限制其他用户修改文件或文件夹时，请在该文件或文件夹上设置高完整性级别。只有管理员才能访问和修改具有高完整性级别的文件和文件夹。

让我们看看 icacls 命令如何实际设置完整性级别。

1. 在当前目录中创建一个文本文件，并使用以下命令将文件的完整性级别设置为高。

# Create a text file named demo.txt in the current directory echo . > demo.txt # Run icacls command to set the text file's (demo.txt) integrity level to high (H) icacls demo.txt /setintegritylevel H

2. 通过运行以下命令验证文件的完整性级别。在下面，您可以看到您拥有该文件的完全访问权限，但该文件的完整性级别设置为高。

icacls demo.txt

3. 现在，通过切换到 PC 上的非管理员帐户来测试文件的完整性级别，然后使用以下命令将文本添加到文本文件。

echo "Adding text to demo file" >> demo.txt

请注意，您将收到一条错误消息，指出访问被拒绝。即使您拥有该文件的完全访问权限，您也只能使用管理员组中的用户帐户修改该文件。

通过禁用继承来限制文件和文件夹修改

默认情况下，文件和文件夹继承其父文件夹的权限。也许您希望在创建新文件夹或文件时避免向用户提供不必要的访问权限。禁用继承是解决该问题的一种方法。

您不必是管理员才能禁用继承，但您应该拥有该对象的完全权限。

继承的一个示例是，当您创建文件夹 C:\myfolder\testdata 时，它将继承父文件夹 C:\myfolder 的权限。

要了解继承以及禁用继承的效果，请在文件资源管理器中查看 ~\Desktop 文件夹中任何文件的权限。您将看到与下面类似的权限。请注意，该文件_继承_其父文件夹的权限。

通过使用 inheritance 参数运行以下命令，使用 icacls 禁用此文件的继承。下面的命令指定 d 参数，该参数禁用继承并将继承转换为显式权限。

# Disabling inheritance on a file named Myfile.txt icacls ~/Desktop/Myfile.txt /inheritance:d

您还可以使用 inheritance 参数指定 e 启用继承，指定 r 禁用并删除对象中所有出现的继承 ACE ，例如，/inheritance:e 或 /inheritance:r。

禁用继承后，您可以在下面看到 icacls 将每个继承 ACE 转换为显式权限（从无继承）。

也许您希望在重新启用文件继承后删除这些显式权限。为此，您可以手动删除权限或重置文件的继承。重置文件的继承将删除所有权限，文件将继承父文件夹的权限。

下面的命令重置 (/reset) 文件 (demo.txt) 继承，同时抑制成功消息 (/q) 并忽略错误 ( <代码>/c）。

icacls demo.txt /q /c /reset

授予或拒绝不同继承级别的权限

NTFS 文件系统是一个大的文件夹层次结构，每个其他文件夹都有一个父文件夹，有时还有一个子文件夹。该层次结构有不同的“级别”。您可以在每个“级别”设置继承。例如，如果您有一个类似 C:\Folder\Subfolder 的路径，则可以在 C:\、Folder 和 <子文件夹。

当您使用 icacls 设置文件夹权限时，icacls 会自动设置该文件夹继承以将权限传播到其子文件夹。但也许您只想应用特定权限而不启用对该文件夹的子文件夹的继承？

以下命令向用户 (user02) 授予对 mydemo 文件夹的完全权限 (F)。但由于未指定继承选项，icacls 仅授予对 mydemo 文件夹的完全权限。如果没有指定继承选项，将自动应用默认选项 (OI)。

icacls mydemo /grant user02:(F)

也许您想向用户授予权限以及指定的继承。在这种情况下，请运行以下命令。

下面，您向从申请的用户 (`user02`) 授予 (`/grant`) 只读权限 (`R`) >mydemo 文件夹及其文件和子文件夹 (OI)(CI)。

icacls mydemo /grant user02:(OI)(CI)(R)

以下是设置文件或文件夹继承级别的选项列表：

OI - 对象继承 - 适用于此文件夹和文件。不会继承或传播到子文件夹。
CI - 容器继承 - 适用于该目录和子目录。
IO - 仅继承 - 不适用于当前文件或目录。
(OI)(CI) - 应用于此文件夹、子文件夹和文件。
(OI)(CI)(IO) - 仅适用于子文件夹和文件。
(CI)(IO) - 仅适用于子文件夹。
(OI)(IO) - 仅适用于文件。

更改文件共享的文件权限

到目前为止，您已经了解了如何更改本地 PC 上的权限。但是 icacls 也可以设置远程文件的权限，尽管没有直接的方法来实现这一点。

更改远程 PC 上的权限时，必须指定远程 PC 上文件的完整路径，如下所示。您还应该拥有实际文件夹、文件和共享路径的权限，以允许其他用户获得权限。

下面，您向用户 () 授予 (`/grant`) 或拒绝 (`/deny`) 完全权限 (`F`) user02）位于远程 PC (\\win10vm2) 的文本文件 (\c$\temp\testfile.txt) 上。

# Granting full permission to a user on a text file from a remote PC icacls \\win10vm2\c$\temp\testfile.txt /grant user02:F # Denying full permission to a user on a text file from a remote PC icacls \\win10vm2\c$\temp\testfile.txt /deny user02:F

结论

在本指南中，您学习了如何运行 icacls 命令来设置从基本到高级的权限。您还学会了在 AclFile 中备份文件和文件夹的 ACL，作为更改权限出错时的后备措施。

原文章地址：Icacls：终极指南

若依(ruoyi-cloud)脚手架解读

BigWind — Tue, 13 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/java/%E8%8B%A5%E4%BE%9Druoyi-cloud%E8%84%9A%E6%89%8B%E6%9E%B6%E8%A7%A3%E8%AF%BB/

一、教学目标

1.1 前置知识点

Java WEB 知识体系
Spring、SpringMVC、SpringBoot 传统MVC框架体系
MyBatis 持久层框架体系
SpringCloud Alibaba 微服务落地方案
Maven、Git、Idea 常规开发工具
MySQL、Redis 常见关系/非关系型数据库

1.2 教学目标

掌握陌生项目解读技巧
掌握若依(RuoYi-Cloud)框架
掌握SpringCloud Alibaba体系项目开发套路

二、框架介绍

2.1 简介

一直想做一款后台管理系统，看了很多优秀的开源项目但是发现没有合适的。于是利用空闲休息时间开始自己写了一套后台系统。如此有了若依。她可以用于所有的Web应用程序，如网站管理后台，网站会员中心，CMS，CRM，OA。所有前端后台代码封装过后十分精简易上手，出错概率低。同时支持移动客户端访问。系统会陆续更新一些实用功能。

性别男，若依是给女儿取的名字（寓意：你若不离不弃，我必生死相依）

若依是一套全部开源的快速开发平台，毫无保留给个人及企业免费使用。

2.2 内置功能

用户管理：用户是系统操作者，该功能主要完成系统用户配置。
部门管理：配置系统组织机构（公司、部门、小组），树结构展现支持数据权限。
岗位管理：配置系统用户所属担任职务。
菜单管理：配置系统菜单，操作权限，按钮权限标识等。
角色管理：角色菜单权限分配、设置角色按机构进行数据范围权限划分。
字典管理：对系统中经常使用的一些较为固定的数据进行维护。
参数管理：对系统动态配置常用参数。
通知公告：系统通知公告信息发布维护。
操作日志：系统正常操作日志记录和查询；系统异常信息日志记录和查询。
登录日志：系统登录日志记录查询包含登录异常。
在线用户：当前系统中活跃用户状态监控。
定时任务：在线（添加、修改、删除)任务调度包含执行结果日志。
代码生成：前后端代码的生成（java、html、xml、sql）支持CRUD下载。
系统接口：根据业务代码自动生成相关的api接口文档。
服务监控：监视当前系统CPU、内存、磁盘、堆栈等相关信息。
缓存监控：对系统的缓存查询，删除、清空等操作。
在线构建器：拖动表单元素生成相应的HTML代码。
连接池监视：监视当前系统数据库连接池状态，可进行分析SQL找出系统性能瓶颈。

2.3 主要特性

完全响应式布局（支持电脑、平板、手机等所有主流设备）
强大的一键生成功能（包括控制器、模型、视图、菜单等）
支持多数据源，简单配置即可实现切换。
支持按钮及数据权限，可自定义部门数据权限。
对常用js插件进行二次封装，使js代码变得简洁，更加易维护
完善的XSS防范及脚本过滤，彻底杜绝XSS攻击
Maven多项目依赖，模块及插件分项目，尽量松耦合，方便模块升级、增减模块。
国际化支持，服务端及客户端支持
完善的日志记录体系简单注解即可实现
支持服务监控，数据监控，缓存监控功能。

2.4 演示地址

http://demo.ruoyi.vip/login

账号：admin 密码：admin123

2.5 分类

2.5.1 传统版

2.5.1.1 源码地址

https://gitee.com/y_project/RuoYi

2.5.1.2 在线文档

http://doc.ruoyi.vip/ruoyi/

2.5.1.3 技术选型

2.5.1.4 代码结构

com.ruoyi     
├── common            // 工具类
│       └── annotation                    // 自定义注解
│       └── config                        // 全局配置
│       └── constant                      // 通用常量
│       └── core                          // 核心控制
│       └── enums                         // 通用枚举
│       └── exception                     // 通用异常
│       └── json                          // JSON数据处理
│       └── utils                         // 通用类处理
│       └── xss                           // XSS过滤处理
├── framework         // 框架核心
│       └── aspectj                       // 注解实现
│       └── config                        // 系统配置
│       └── datasource                    // 数据权限
│       └── interceptor                   // 拦截器
│       └── manager                       // 异步处理
│       └── shiro                         // 权限控制
│       └── web                           // 前端控制
├── ruoyi-generator   // 代码生成（不用可移除）
├── ruoyi-quartz      // 定时任务（不用可移除）
├── ruoyi-system      // 系统代码
├── ruoyi-admin       // 后台服务
├── ruoyi-xxxxxx      // 其他模块

2.5.2 前后端分离版本

2.5.2.1 源码地址

https://gitee.com/y_project/RuoYi-Vue

2.5.2.2 在线文档

http://doc.ruoyi.vip/ruoyi-vue/

2.5.2.3 技术选型

2.5.2.4 代码结构

后端结构

com.ruoyi     
├── common            // 工具类
│       └── annotation                    // 自定义注解
│       └── config                        // 全局配置
│       └── constant                      // 通用常量
│       └── core                          // 核心控制
│       └── enums                         // 通用枚举
│       └── exception                     // 通用异常
│       └── filter                        // 过滤器处理
│       └── utils                         // 通用类处理
├── framework         // 框架核心
│       └── aspectj                       // 注解实现
│       └── config                        // 系统配置
│       └── datasource                    // 数据权限
│       └── interceptor                   // 拦截器
│       └── manager                       // 异步处理
│       └── security                      // 权限控制
│       └── web                           // 前端控制
├── ruoyi-generator   // 代码生成（可移除）
├── ruoyi-quartz      // 定时任务（可移除）
├── ruoyi-system      // 系统代码
├── ruoyi-admin       // 后台服务
├── ruoyi-xxxxxx      // 其他模块

前端结构

├── build                      // 构建相关  
├── bin                        // 执行脚本
├── public                     // 公共文件
│   ├── favicon.ico            // favicon图标
│   └── index.html             // html模板
│   └── robots.txt             // 反爬虫
├── src                        // 源代码
│   ├── api                    // 所有请求
│   ├── assets                 // 主题 字体等静态资源
│   ├── components             // 全局公用组件
│   ├── directive              // 全局指令
│   ├── layout                 // 布局
│   ├── plugins                // 通用方法
│   ├── router                 // 路由
│   ├── store                  // 全局 store管理
│   ├── utils                  // 全局公用方法
│   ├── views                  // view
│   ├── App.vue                // 入口页面
│   ├── main.js                // 入口 加载组件 初始化等
│   ├── permission.js          // 权限管理
│   └── settings.js            // 系统配置
├── .editorconfig              // 编码格式
├── .env.development           // 开发环境配置
├── .env.production            // 生产环境配置
├── .env.staging               // 测试环境配置
├── .eslintignore              // 忽略语法检查
├── .eslintrc.js               // eslint 配置项
├── .gitignore                 // git 忽略项
├── babel.config.js            // babel.config.js
├── package.json               // package.json
└── vue.config.js              // vue.config.js

2.5.3 微服务版本

2.5.3.1 源码地址

https://gitee.com/y_project/RuoYi-Cloud

2.5.3.2 在线文档

http://doc.ruoyi.vip/ruoyi-cloud/

2.5.3.3 技术选型

2.5.3.4 代码结构

后端结构

com.ruoyi     
├── ruoyi-ui              // 前端框架 [80]
├── ruoyi-gateway         // 网关模块 [8080]
├── ruoyi-auth            // 认证中心 [9200]
├── ruoyi-api             // 接口模块
│       └── ruoyi-api-system                          // 系统接口
├── ruoyi-common          // 通用模块
│       └── ruoyi-common-core                         // 核心模块
│       └── ruoyi-common-datascope                    // 权限范围
│       └── ruoyi-common-datasource                   // 多数据源
│       └── ruoyi-common-log                          // 日志记录
│       └── ruoyi-common-redis                        // 缓存服务
│       └── ruoyi-common-seata                        // 分布式事务
│       └── ruoyi-common-security                     // 安全模块
│       └── ruoyi-common-swagger                      // 系统接口
├── ruoyi-modules         // 业务模块
│       └── ruoyi-system                              // 系统模块 [9201]
│       └── ruoyi-gen                                 // 代码生成 [9202]
│       └── ruoyi-job                                 // 定时任务 [9203]
│       └── ruoyi-file                                // 文件服务 [9300]
├── ruoyi-visual          // 图形化管理模块
│       └── ruoyi-visual-monitor                      // 监控中心 [9100]
├──pom.xml                // 公共依赖

前端结构

├── build                      // 构建相关  
├── bin                        // 执行脚本
├── public                     // 公共文件
│   ├── favicon.ico            // favicon图标
│   └── index.html             // html模板
├── src                        // 源代码
│   ├── api                    // 所有请求
│   ├── assets                 // 主题 字体等静态资源
│   ├── components             // 全局公用组件
│   ├── directive              // 全局指令
│   ├── layout                 // 布局
│   ├── plugins                // 通用方法
│   ├── router                 // 路由
│   ├── store                  // 全局 store管理
│   ├── utils                  // 全局公用方法
│   ├── views                  // view
│   ├── App.vue                // 入口页面
│   ├── main.js                // 入口 加载组件 初始化等
│   ├── permission.js          // 权限管理
│   └── settings.js            // 系统配置
├── .editorconfig              // 编码格式
├── .env.development           // 开发环境配置
├── .env.production            // 生产环境配置
├── .env.staging               // 测试环境配置
├── .eslintignore              // 忽略语法检查
├── .eslintrc.js               // eslint 配置项
├── .gitignore                 // git 忽略项
├── babel.config.js            // babel.config.js
├── package.json               // package.json
└── vue.config.js              // vue.config.js

2.5.4 移动版

2.5.4.1 源码地址

https://gitee.com/y_project/RuoYi-App

2.5.4.2 在线文档

http://doc.ruoyi.vip/ruoyi-app/

2.5.4.3 技术选型

2.5.4.4 代码结构

├── api                        // 所有请求  
├── components                 // 全局公用组件
├── pages                      // 页面文件
├── plugins                    // 通用方法
├── store                      // 全局 store管理
├── utils                      // 公用方法
├── static                     // 公共文件
│   ├── favicon.ico            // favicon图标
│   └── index.html             // html模板
│   └── logo.png               // logo图片
├── uni_modules                // uniui组件
│   ├── uni-badge              // 数字角标
│   ├── .........              // ........
│   ├── .........              // ........
├── App.vue                    // 应用配置
├── config.js                  // 环境配置
├── main.js                    // Vue初始化入口文件
├── manifest.json              // 配置打包
├── pages.json                 // 配置页面路由
├── permission.js              // 权限拦截
├── uni.scss                   // 全局样式变量

三、源码下载

3.1 说明

本教程以若依微服版(RuoYi-Cloud)为解读蓝本，所有源码、文件、截图、演示均为该版本。

3.2 下载

国内：https://gitee.com/y_project/RuoYi-Cloud

国外：https://github.com/yangzongzhuan/RuoYi-Cloud

3.3 Idea克隆

四、项目上手技巧

4.1 标准开源项目

标准开源项目：指符合特定标准和规范的开源软件项目。这些标准和规范通常由开源社区、行业组织或相关标准制定机构定义和推广。标准开源项目的目的是提供一致的质量标准和最佳实践，以促进开源软件的可靠性、互操作性和可持续发展。

大白话：代码、文件、教程等各种配套都齐全的项目。

4.1.1 看README.md

标准开源项目，都是有一个README.md这种文档，这个文档是项目的简介，一般会用大白话方式讲清楚项目背景，项目技术点，项目具体使用等。

4.1.2 看演示项目

http://vue.ruoyi.vip/login?redirect=%2Findex

好处：快速了解项目具体功能，能做啥，实现效果怎么样。

4.1.3 看文档

http://doc.ruoyi.vip/ruoyi-cloud/

好处：该有的都有了

一个问题：看文档，看哪些内容？

0>视频教程(如果有)

1>项目结构/架构(如果有)

2>技术选型

3>功能模块

4>项目部署

5>项目其他

4.2 非标准开源项目

非标准开源项目是指没有遵循特定标准或规范的开源软件项目。这些项目可能是由个人、小团队或组织开发，其开发方式和治理模式可能与传统的标准开源项目有所不同。

大白话：代码、文件、教程等各种配套都不齐全的项目。

4.2.1 看README.md

如果有，必须看。但一般情况，都是下面这种：啥都是没有

4.2.2 看Jar依赖

没有使用Maven/Gradle传统项目，比如Java SE/JavaWeb项目，Jar依赖一般放置在lib文件夹，优先找它

如果使用Maven/Gradle常规项目，找pom.xml文件或build.gradle

一个问题：看Jar依赖目的是啥？

1>大体把握项目技术栈

要求：结合技术栈，YY一下代码可能的结构，后续项目解读时有参照蓝本。

比如： MyBatis---domain----mapper.java-----mapper.xml

Springboot----Spring----Springmvc----Controller----启动类

SpringCloud Alibaba-----8个基本组件

2>大体推测项目有哪些功能

要求：常见的功能jar有熟悉，不认识，可以搜。

比如：

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>${swagger.fox.version}</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
</dependency>

4.2.3 看代码结构

没有文档的帮助，只能借助代码结构名称大体推测项目可能具有模块，拥有的功能。

4.2.4 YY联想

非开源项目最麻烦一个点就是文件不齐全，少文档，少sql数据库，甚至代码不完整。这时候想解读通这代码就需要很丰富的想象能力。

类似一拳超人中地表最强的男人：King ！哥的厉害全靠你想象

这个得结合个人开发经验，项目经验，生活阅历，连蒙靠猜推测去补齐项目逻辑啦。

比如：

缺SQL：找Mapper.xml/domain实体补齐

缺Jar包：根据项目启动报错信息，缺哪个补哪个

缺配置文件：项目依赖用到哪些jar，结合常规配置，补齐配置

缺少各种环境：结合个人开发经验，尝试补齐。

4.3 若依初探

若依脚手架算是一个较为标准的开源项目了，那它阶段就按照标准项目方式解读即可。

4.3.1 标准开源项目

4.3.1.1 看README.md

--了解项目整体

4.3.1.2 看演示项目

--了解项目效果

地址：http://vue.ruoyi.vip/index

账号密码：admin/admin123

4.3.1.3 看文档

--了解项目细节

地址：http://doc.ruoyi.vip/ruoyi-cloud/

4.3.2 架构设计图

从图中解析出RuoYi-Cloud 使用微服务技术栈

网关：Gateway

远程调用：Ribbon/Feign

注册中心：Nacos Discovery

熔断降级：Sentinel

配置中心：Nacos Config

链路追踪：Sleuth+ZipKin/SkyWalking （没有集成，需要自己加）

4.3.3 代码结构

com.ruoyi     
├── ruoyi-ui              // 前端框架 [80]
├── ruoyi-gateway         // 网关模块 [8080]
├── ruoyi-auth            // 认证中心 [9200]
├── ruoyi-api             // 接口模块
│       └── ruoyi-api-system                          // 系统接口
├── ruoyi-common          // 通用模块
│       └── ruoyi-common-core                         // 核心模块
│       └── ruoyi-common-datascope                    // 权限范围
│       └── ruoyi-common-datasource                   // 多数据源
│       └── ruoyi-common-log                          // 日志记录
│       └── ruoyi-common-redis                        // 缓存服务
│       └── ruoyi-common-seata                        // 分布式事务
│       └── ruoyi-common-security                     // 安全模块
│       └── ruoyi-common-swagger                      // 系统接口
├── ruoyi-modules         // 业务模块
│       └── ruoyi-system                              // 系统模块 [9201]
│       └── ruoyi-gen                                 // 代码生成 [9202]
│       └── ruoyi-job                                 // 定时任务 [9203]
│       └── ruoyi-file                                // 文件服务 [9300]
├── ruoyi-visual          // 图形化管理模块
│       └── ruoyi-visual-monitor                      // 监控中心 [9100]
├──pom.xml                // 公共依赖

五、环境准备

项目运行前提需要准备环境，如果项目提供文档，直接看文档操作即可，如果没有文档，就结合开发经验/项目经验来配置。一般来说，项目环境准备都按照下面几个步骤。

5.1 语言环境

项目运行离不开语言支持，若依(RuoYi-Cloud)后端为Java项目，需要java环境，前端为Vue项目，需要Node.js环境，运行若依前需要将这些环境安装成功。

5.1.1 Java环境

5.1.2 node.js环境

一个node.js环境，一个事npm 软件安装工具

5.2 数据库环境

若依(RuoYi-Cloud)目前使用的数据库暂时只有MySQL跟Redis，后续可以根据项目需要添加其他数据库，比如MongoDB，Elasticsearch等。

5.2.1 MySQL环境

5.2.2 Redis环境

5.3 组件环境

若依(RuoYi-Cloud)使用的是SpringCloud Alibaba体系微服务落地方法，那就得安装2个必须组件：Nacos跟Sentinel。

5.3.1 Nacos环境

若依(RuoYi-Cloud)使用Nacos做注册中心与配置中心，所以需要提前准备该环境。

下载路径：https://github.com/alibaba/nacos/releases

这里注意，若依(RuoYi-Cloud)要求是Nacos 2.x版本，不要下错

进入bin目录启动，执行startup.cmd命令，注意需要使用单例模式启动，否则闪退

使用cmd 命令，进入命令框，执行下面命令
startup.cmd -m standalone

5.3.2 Sentinel环境

若依(RuoYi-Cloud)使用Sentinel熔断降级组件，那么项目启动前，需要提前准备好

下载地址：https://github.com/alibaba/Sentinel/releases

下载完之后是一个jar包：sentinel-dashboard-1.8.0.jar，使用java 命令执行就行

java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

5.3.3 Seata环境

若依(RuoYi-Cloud)支持Seata实现分布式事务，如果需要，项目启动前就应该提前准备好

下载地址：https://github.com/seata/seata/releases

进入bin目录启动，执行seata-server.bat命令

seata-server.bat --add-opens=java.base/java.lang=ALL-UNNAMED

六、项目配置与启动

当上面环境全部准备好之后，接下来就是项目配置。需要将项目相关配置修改成当前相关环境。

6.1 后端配置

6.1.1 数据库

新建数据库：ry-cloud 存储常规数据

字符编码：utf8mb4

导入SQL：sql/ry_20230223.sql sql/quartz.sql(可选--需要定时任务操作必须导入)

一个bug补充

MySQL5.6 数据库 quartz.sql 语句导入异常：Specified key was too long; max key length is 767 bytes

**原因：**msyql5.6及以前版本，默认索引最大长度767bytes，若使用utf8mb4格式编码（utf8字符占用3字节，utf8mb4字符占用4字节），则单个字段长度不能超过191， 5.7及之后版本，限制放开到3072 bytes。

解决方案：

方案1：放弃使用utf8mb4，直接使用utf8！

方案2：

1、在my.ini中修改配置：

永久改动

innodb_large_prefix = ON   #这个属性在5.6上是默认关闭的，而在5.7上是默认开启的。
innodb_file_format = Barracuda 
innodb_file_per_table = ON

临时改动

SET GLOBAL INNODB_LARGE_PREFIX = ON;

2、在create中添加row_format=dynamic

create table sql_test(
id int ,
name VARCHAR(200),
server_id VARCHAR(30),
id_num1 VARCHAR(30),
id_num2 VARCHAR(30),
link VARCHAR(500),
PRIMARY KEY (id),
KEY sql_test_name (name)) 
engine=innodb row_format=dynamic;

方案3：使用MySQL5.7 版本

**新建数据库：ry-config ** 存储nacos配置数据

字符编码：utf8mb4

导入SQL：sql/ry_config_20220929.sql

6.1.2 Nacos配置

若依(RuoYi-Cloud) 配置中心的项目配置文件，持久化在ry-config.config_info 表中，项目启动需要将这些配置文件加载到配置中心，所以需要额外配置一下Nacos，以增加对mysql数据源的支持。

进入nacos-server-2.2.2/conf 目录找：application.properties

修改配置

# db mysql
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://localhost:3306/ry-config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user=数据库账号
db.password=数据库密码

6.1.3 项目配置文件

Nacos配置好之后，启动成功后访问：http://localhost:8848/nacos 账号/密码 nacos/nacos

修改下面画红线的服务配置文件

主要改动：

Redis 的ip，端口，密码

MySQL ip，端口，账号，密码，数据库等。

比如：

6.2 后端启动

打开项目，执行XxxxApplication的启动类（启动没有先后顺序）

RuoYiGatewayApplication （网关模块必须）
RuoYiAuthApplication （认证模块必须）
RuoYiSystemApplication （系统模块必须）
RuoYiMonitorApplication （监控中心可选）
RuoYiGenApplication （代码生成可选）
RuoYiJobApplication （定时任务可选）
RuoYFileApplication （文件服务可选）

加粗的启动即可。

6.3 前端配置与启动

若依(RuoYi-Cloud) 项目前端跟后端是保存在同一个目录夹的。

先进入这个目录，然后使用前端编辑工具打开即可，这里使用Visual Studio Code 打开

进入vscode之后，打开项目README.md文件

打开vscode 的终端，执行上面命令

6.4 访问

当后端，前端都启动成功之后，若依(RuoYi-Cloud) 项目就算运行成功啦。

访问地址：http://localhost/

七、模块解读

项目解读可以说分为2部分： 1>项目结构解读(静态解读) 2>业务模块解读(动态解读)

前面种种都属于项目结构范畴，解下来就是业务模块解读，这里选择鉴权，网关，代码生成器3个核心模块讲解若依(RuoYi-Cloud)脚手架的使用。

7.1 解读技巧

只要是Java Web项目，流程主干线永远不变： 发起请求---处理请求----响应请求

找一个业务逻辑相对简单的模块，围绕主线去追踪即可。根据以往的经验，请求到响应大体流程图如下：

把上面流程具体化之后就是：

前端

客户端如何发起请求（关注路径/方式/参数），一般使用浏览器的F12查看
后端

接口接收请求，处理请求，响应请求。(关注：单个服务操作/多服务协同操作)，一般追踪请求流程。

简单流程：网关---过滤器---拦截器--微服务(请求处理)

复杂流程：网关---上游过滤器---上游拦截器--上游微服务(处理)-----下游过滤器---下游拦截器--下游微服务(处理)

7.2 请求闭环

这里结合上面主线，走一个完整的请求闭环，以获取登录验证码获取为例子。

7.2.1 前端

项目进入第一个页面是登录页面

浏览器F12，查看到第一个接口：http://localhost/dev-api/code

**localhost：**前端项目启动默认访问ip，为本地

**端口：**没有端口，默认端口为80

**dev-api：**若依框架约定的开发环境使用上下文，可以在.env.development中配置

**code：**请求路径

完整的：http://locallhost:80/dev-api/code 是由下面异步请求发起的

当前端发起请求后，就到后端接收请求处理，处理请求，与响应请求啦。

7.2.2 后端

前端发起请求，后端接收请求，那请求最先去到哪呢？

看若依(RuoYi-Cloud)框架的架构图，请求最先进入的网关。当然也可以通过前端代理服务配置定位到请求会转发到网关服务。

当确认请求入口之后，只需快速定位ruoyi-gateway即可。

此时还存在一个问题，网关哪个类处理/code请求？

如果有WebFlux编程经验，大体能猜到RouterFunctionConfiguration类

@Configuration
public class RouterFunctionConfiguration
{
    @Autowired
    private ValidateCodeHandler validateCodeHandler;

    @SuppressWarnings("rawtypes")
    @Bean
    public RouterFunction routerFunction()
    {
        return RouterFunctions.route(
                RequestPredicates.GET("/code").and(RequestPredicates.accept(MediaType.TEXT_PLAIN)),
                validateCodeHandler);
    }
}

RouterFunction 是 Spring WebFlux 中定义路由的函数式编程方式。

在 Spring WebFlux 中，我们可以使用 RouterFunction 来定义路由规则，将请求映射到相应的处理器函数上。

上面代码意思是前端发过来/code由validateCodeHandler 来处理

@Component
public class ValidateCodeHandler implements HandlerFunction<ServerResponse>
{
    @Autowired
    private ValidateCodeService validateCodeService;

    @Override
    public Mono<ServerResponse> handle(ServerRequest serverRequest)
    {
        AjaxResult ajax;
        try
        {
            //构建验证码，封装成AjaxResult对象
            ajax = validateCodeService.createCaptcha();
        }
        catch (CaptchaException | IOException e)
        {
            return Mono.error(e);
        }
        return ServerResponse.status(HttpStatus.OK).body(BodyInserters.fromValue(ajax));
    }
}

@Override
public AjaxResult createCaptcha() throws IOException, CaptchaException
{
    AjaxResult ajax = AjaxResult.success();
    boolean captchaEnabled = captchaProperties.getEnabled();
    ajax.put("captchaEnabled", captchaEnabled);
    ....
    ajax.put("uuid", uuid);
    ajax.put("img", Base64.encode(os.toByteArray()));
    return ajax;
        
}

最终将生成的验证码封装在AjaxResult 响应回客户端。

那如果说没有Spring WebFlux经验怎么办？很简单，使用idea 搜/code 字符，然后借助ChatGPT猜测代码啥意思

到这，一个完整请求闭环就完成了，后续其他请求便是同理可得。

7.3 网关模块

网关为项目入口，若依(RuoYi-Cloud)项目入口结构可以简化为这样

在ruoyi-gateway网关微服务中配置了所有微服务路由映射

spring:
  cloud:
    gateway:
      discovery:
        locator:
          lowerCaseServiceId: true
          enabled: true
      routes:
        # 认证中心
        - id: ruoyi-auth
          uri: lb://ruoyi-auth
          predicates:
            - Path=/auth/**
          filters:
            # 验证码处理
            - CacheRequestFilter
            - ValidateCodeFilter
            - StripPrefix=1
        # 代码生成
        - id: ruoyi-gen
          uri: lb://ruoyi-gen
          predicates:
            - Path=/code/**
          filters:
            - StripPrefix=1
        # 定时任务
        - id: ruoyi-job
          uri: lb://ruoyi-job
          predicates:
            - Path=/schedule/**
          filters:
            - StripPrefix=1
        # 系统模块
        - id: ruoyi-system
          uri: lb://ruoyi-system
          predicates:
            - Path=/system/**
          filters:
            - StripPrefix=1
        # 文件服务
        - id: ruoyi-file
          uri: lb://ruoyi-file
          predicates:
            - Path=/file/**
          filters:
            - StripPrefix=1

前端发起所有请都统一经过网关，再借由网关路由统一转发。

访问ruoyi-file微服务路径规则： http://localhost:80/dev-api/file/**

访问ruoyi-gen微服务路径规则： http://localhost:80/dev-api/code/**

访问ruoyi-job微服务路径规则： http://localhost:80/dev-api/schedule/**

访问ruoyi-system微服务路径规则： http://localhost:80/dev-api/system/**

访问ruoyi-auth微服务路径规则： http://localhost:80/dev-api/auth/**

7.4 鉴权模块

若依(RuoYi-Cloud)鉴权模块涉及到这几个组件

若依(RuoYi-Cloud)框架登录鉴权有2种模式：

外部鉴权：客户端访问服务端(微服务)，以JWT令牌为判断依据，有且合法放行，没有或不合法`

内部鉴权：上游微服务访问下游微服务，以请求头标记：from-source=inner有无位依据，有放行，没有拒绝

7.4.1 外部鉴权

7.4.1.1 步骤1：JWT获取

登录页面点击登录发起：http://localhost/dev-api/auth/login 请求

请求中auth前缀为网关配置ry-auth服务路由映射

借助网格路由，进入ry-auth微服务，TokenController请求处理类

@RestController
public class TokenController
{
    @PostMapping("login")
    public R<?> login(@RequestBody LoginBody form)
    {
        // 用户登录
        LoginUser userInfo = sysLoginService.login(form.getUsername(), form.getPassword());
        // 获取登录token
        return R.ok(tokenService.createToken(userInfo));
    }
}

    /**
     * 创建令牌
     */
    public Map<String, Object> createToken(LoginUser loginUser)
    {
        String token = IdUtils.fastUUID();
        Long userId = loginUser.getSysUser().getUserId();
        String userName = loginUser.getSysUser().getUserName();
        loginUser.setToken(token);
        loginUser.setUserid(userId);
        loginUser.setUsername(userName);
        loginUser.setIpaddr(IpUtils.getIpAddr());
        refreshToken(loginUser);  //redis缓存令牌

        // Jwt存储信息
        Map<String, Object> claimsMap = new HashMap<String, Object>();
        claimsMap.put(SecurityConstants.USER_KEY, token);
        claimsMap.put(SecurityConstants.DETAILS_USER_ID, userId);
        claimsMap.put(SecurityConstants.DETAILS_USERNAME, userName);

        // 接口返回信息
        Map<String, Object> rspMap = new HashMap<String, Object>();
        rspMap.put("access_token", JwtUtils.createToken(claimsMap));
        rspMap.put("expires_in", expireTime);
        return rspMap;
    }

响应返回：

7.4.1.2 步骤2：JWT鉴权

当客户登录成功之后，后续请求进入网关，网关转发到对应的微服务，该微服务会引用：ruoyi-common-security 鉴权模块，请求进来后，切面判断请求持有的JWT令牌，有且合法放行，没有或不合法拒绝

7.4.1.3 步骤3：JWT鉴权实现

@Aspect
@Component
public class PreAuthorizeAspect
{
    /**
     * 构建
     */
    public PreAuthorizeAspect()
    {
    }

    /**
     * 定义AOP签名 (切入所有使用鉴权注解的方法)
     */
    public static final String POINTCUT_SIGN = " @annotation(com.ruoyi.common.security.annotation.RequiresLogin) || "
            + "@annotation(com.ruoyi.common.security.annotation.RequiresPermissions) || "
            + "@annotation(com.ruoyi.common.security.annotation.RequiresRoles)";

    /**
     * 声明AOP签名
     */
    @Pointcut(POINTCUT_SIGN)
    public void pointcut()
    {
    }

    /**
     * 环绕切入
     * 
     * @param joinPoint 切面对象
     * @return 底层方法执行后的返回值
     * @throws Throwable 底层方法抛出的异常
     */
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable
    {
        // 注解鉴权
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        checkMethodAnnotation(signature.getMethod());
        try
        {
            // 执行原有逻辑
            Object obj = joinPoint.proceed();
            return obj;
        }
        catch (Throwable e)
        {
            throw e;
        }
    }

    /**
     * 对一个Method对象进行注解检查
     */
    public void checkMethodAnnotation(Method method)
    {
        // 校验 @RequiresLogin 注解
        RequiresLogin requiresLogin = method.getAnnotation(RequiresLogin.class);
        if (requiresLogin != null)
        {
            AuthUtil.checkLogin();
        }

        // 校验 @RequiresRoles 注解
        RequiresRoles requiresRoles = method.getAnnotation(RequiresRoles.class);
        if (requiresRoles != null)
        {
            AuthUtil.checkRole(requiresRoles);
        }

        // 校验 @RequiresPermissions 注解
        RequiresPermissions requiresPermissions = method.getAnnotation(RequiresPermissions.class);
        if (requiresPermissions != null)
        {
            AuthUtil.checkPermi(requiresPermissions);
        }
    }
}

阅读上面的切面代码，最终得出

只要接口方法只要贴有上面3个注解，都需要进行外部鉴权。比如：

/**
* 获取用户列表
*/
@RequiresPermissions("system:user:list")
@GetMapping("/list")
public TableDataInfo list(SysUser user)
{
    startPage();
    List<SysUser> list = userService.selectUserList(user);
    return getDataTable(list);
}

7.4.2 内部鉴权

内部鉴权是微服务与微服务间鉴权，发生在上游微服务访问下游微服务，以请求头标记：from-source=inner有无位依据，有放行，没有拒绝，其目的是实现网络隔离。

来自网关请求，以JWT进行鉴权，来自内部远程调用请求，以from-source=inner进行鉴权，其他非法请求直接拒绝。

还是以ry-auth微服务的TokenController类的登录方法为案例

7.4.2.1 步骤1：远程调用过程

登录请求，先到TokenController类login方法

@RestController
public class TokenController
{
    @Autowired
    private TokenService tokenService;

    @Autowired
    private SysLoginService sysLoginService;

    @PostMapping("login")
    public R<?> login(@RequestBody LoginBody form)
    {
        // 用户登录
        LoginUser userInfo = sysLoginService.login(form.getUsername(), form.getPassword());
        // 获取登录token
        return R.ok(tokenService.createToken(userInfo));
    }
}

login方法中用到：SysLoginService接口login逻辑

private SysLoginService sysLoginService;
sysLoginService.login(form.getUsername(), form.getPassword());

观察SysLoginService类，里面引用了接口：RemoteUserService

@Component
public class SysLoginService
{
    @Autowired
    private RemoteUserService remoteUserService;

    /**
     * 登录
     */
    public LoginUser login(String username, String password)
    {
        ......
        // 查询用户信息
        R<LoginUser> userResult = remoteUserService.getUserInfo(username, SecurityConstants.INNER);
		......
       
    }
}

观察RemoteUserService接口所在位置，明显与TokenController/SysLoginService不在同一微服务。

RemoteUserService 属于ry-system微服务，而TokenController类属于ry-auth微服务，那么此处的remoteUserService.getUserInfo为远程调用。

一个问题：既然为远程调用，跟普通接口调用有啥区别？

定义区别：

使用feign组件，定义远程接口

@FeignClient(contextId = "remoteUserService", value = ServiceNameConstants.SYSTEM_SERVICE, fallbackFactory = RemoteUserFallbackFactory.class)
public interface RemoteUserService
{
    /**
     * 通过用户名查询用户信息
     *
     * @param username 用户名
     * @param source 请求来源
     * @return 结果
     */
    @GetMapping("/user/info/{username}")
    public R<LoginUser> getUserInfo(@PathVariable("username") String username, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);

}

接口定义，除了正常的username参数之外，多了一个请求头

@RequestHeader(SecurityConstants.FROM_SOURCE) String source

调用区别：

使用Feign组件发起远程接口调用，需要多传一个SecurityConstants.INNER 参数

remoteUserService.getUserInfo(username, SecurityConstants.INNER);

这是为何？

SecurityConstants.INNER为内部微服务间远程调用请求头标识，上游微服务调用时，添加该标识的请求头，下游微服务接收请求前，进行请求头校验。

即：

定义是指定请求头key：SecurityConstants.FROM_SOURCE

getUserInfo(
      @PathVariable("username") String username,
      @RequestHeader(SecurityConstants.FROM_SOURCE) String source);

调用时，指定请求头value：SecurityConstants.INNER

remoteUserService.getUserInfo(username, SecurityConstants.INNER);

最终合并

SecurityConstants.FROM_SOURCE = SecurityConstants.INNER

from-source = inner

7.4.2.2 步骤2：远程正式调用

上面定义的远程接口，最终通过feign方式调用到ruoyi-system微服务SysUserController类的info接口

SysUserController类的info接口

@RestController
@RequestMapping("/user")
public class SysUserController extends BaseController
{    /**
     * 获取当前用户信息
     */
    @InnerAuth
    @GetMapping("/info/{username}")
    public R<LoginUser> info(@PathVariable("username") String username)
    {
        SysUser sysUser = userService.selectUserByUserName(username);
        if (StringUtils.isNull(sysUser))
        {
            return R.fail("用户名或密码错误");
        }
        // 角色集合
        Set<String> roles = permissionService.getRolePermission(sysUser);
        // 权限集合
        Set<String> permissions = permissionService.getMenuPermission(sysUser);
        LoginUser sysUserVo = new LoginUser();
        sysUserVo.setSysUser(sysUser);
        sysUserVo.setRoles(roles);
        sysUserVo.setPermissions(permissions);
        return R.ok(sysUserVo);
    }
}

这里留意，info方法上面有个**@InnerAuth** 注解，表示当前info方法为远程调用方法，需要进行远程校验，也即：内部鉴权。

7.4.2.3 步骤3：内部鉴权

@Aspect
@Component
public class InnerAuthAspect implements Ordered
{
    @Around("@annotation(innerAuth)")
    public Object innerAround(ProceedingJoinPoint point, InnerAuth innerAuth) throws Throwable
    {
        String source = ServletUtils.getRequest().getHeader(SecurityConstants.FROM_SOURCE);
        // 内部请求验证
        if (!StringUtils.equals(SecurityConstants.INNER, source))
        {
            throw new InnerAuthException("没有内部访问权限，不允许访问");
        }

        String userid = ServletUtils.getRequest().getHeader(SecurityConstants.DETAILS_USER_ID);
        String username = ServletUtils.getRequest().getHeader(SecurityConstants.DETAILS_USERNAME);
        // 用户信息验证
        if (innerAuth.isUser() && (StringUtils.isEmpty(userid) || StringUtils.isEmpty(username)))
        {
            throw new InnerAuthException("没有设置用户信息，不允许访问 ");
        }
        return point.proceed();
    }

    /**
     * 确保在权限认证aop执行前执行
     */
    @Override
    public int getOrder()
    {
        return Ordered.HIGHEST_PRECEDENCE + 1;
    }
}

阅读上面的切面代码，发起切面是切入点事贴有@InnerAuth接口方法。

7.5 代码生成模块

若依(RuoYi-Cloud)代码生成模块是一个简单模块，功能顾名思义，用于构建若依体系的代码。

启动后，访问页面：

这里演示一下代码生成器使用过程。

7.5.1 步骤1：创建表

在ry-cloud库中创建一个Employee表

CREATE TABLE `sys_employee` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(255) DEFAULT NULL COMMENT '名称',
  `age` int DEFAULT NULL COMMENT '年龄',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  COMMENT='员工表';

7.5.2 步骤2：导入新建表

在代码生成界面导入新建表

7.5.3 步骤3：定制代码信息

7.5.3.1 基本信息

7.5.3.2 字段信息

字段列名：表中列的名称

字段描述：生成实体类属性注释

物理类型：表中列的类型

Java类型：生成实体类属性变量类型

Java属性：生成实体类属性名

插入：定义添加操作模态框表单控件，选中表示模态框有这个输入空间

编辑：定义编辑操作模态框表单控件，选中表示模态框有这个输入空间

列表：表中数据在列表时，该列数据是否显示，选中为要显示

查询：该列是否作为列表的查询条件，选中为需要作为查询条件

查询方式：作为查询条件时，使用匹配方式

显示类型：查询条件输入类型

字典类型：查询条件显示类型如果是下拉框，使用字典类型，实现下拉选择

7.5.3.3 生成信息

生成模板：一般不动，以单表操作为主

生成包路径：指定当前代码生成根包路径

生成模块名：该功能所属模块，落地到代码就是所在微服务名称，ruoyi-gateway配置的路由映射路径名

生成业务名：该功能英文名，落地到代码就是controller中操作资源名，比如：/employee

生成功能名：该功能中文名称

上级菜单：该功能页面展示菜单连接挂载在哪个上级菜单。

7.5.3.4 预览

配置上面各种信息成功之后，可以点击预览，根据需要微调

7.5.3.5 生成代码

确定无误之后，直接点生成代码

7.5.4 步骤4：使用代码

压缩包解压得到几个文件：

7.5.4.1 employeeMenu.sql

涉及要添加的菜单，菜单权限，在navicat中执行即可。

-- 菜单 SQL
insert into sys_menu (menu_name, parent_id, order_num, path, component, is_frame, is_cache, menu_type, visible, status, perms, icon, create_by, create_time, update_by, update_time, remark)
values('员工', '1', '1', 'employee', 'system/employee/index', 1, 0, 'C', '0', '0', 'system:employee:list', '#', 'admin', sysdate(), '', null, '员工菜单');

-- 按钮父菜单ID
SELECT @parentId := LAST_INSERT_ID();

-- 按钮 SQL
insert into sys_menu (menu_name, parent_id, order_num, path, component, is_frame, is_cache, menu_type, visible, status, perms, icon, create_by, create_time, update_by, update_time, remark)
values('员工查询', @parentId, '1',  '#', '', 1, 0, 'F', '0', '0', 'system:employee:query',        '#', 'admin', sysdate(), '', null, '');

insert into sys_menu (menu_name, parent_id, order_num, path, component, is_frame, is_cache, menu_type, visible, status, perms, icon, create_by, create_time, update_by, update_time, remark)
values('员工新增', @parentId, '2',  '#', '', 1, 0, 'F', '0', '0', 'system:employee:add',          '#', 'admin', sysdate(), '', null, '');

insert into sys_menu (menu_name, parent_id, order_num, path, component, is_frame, is_cache, menu_type, visible, status, perms, icon, create_by, create_time, update_by, update_time, remark)
values('员工修改', @parentId, '3',  '#', '', 1, 0, 'F', '0', '0', 'system:employee:edit',         '#', 'admin', sysdate(), '', null, '');

insert into sys_menu (menu_name, parent_id, order_num, path, component, is_frame, is_cache, menu_type, visible, status, perms, icon, create_by, create_time, update_by, update_time, remark)
values('员工删除', @parentId, '4',  '#', '', 1, 0, 'F', '0', '0', 'system:employee:remove',       '#', 'admin', sysdate(), '', null, '');

insert into sys_menu (menu_name, parent_id, order_num, path, component, is_frame, is_cache, menu_type, visible, status, perms, icon, create_by, create_time, update_by, update_time, remark)
values('员工导出', @parentId, '5',  '#', '', 1, 0, 'F', '0', '0', 'system:employee:export',       '#', 'admin', sysdate(), '', null, '');

执行成功后，刷新前端项目，可以看到菜单

7.5.4.2 vue

ruoyi-ui前端employee这个模块设计到vue页面，与js

分别拷贝到项目api目录，跟views目录

刷新之后，点击员工菜单，缺少后端接口

7.5.4.3 main

后端接口代码，将main代码拷贝到ruoyi-system main目录中即可

然后，重启ruoyi-system服务，再访问。

八、定制微服务

8.1 需求

定制微服务-ruoyi-modules-test

8.2 代码结构

对外api：ruoyi-api-test

微服务：ruoyi-modules-test

8.3 实现步骤

8.3.1 步骤1：定义ruoyi-api-test

导入依赖参考ruoyi-api-system

创建包结构参考ruoyi-api-system

这里注意包命名规则：

com.ruoyi-----公司域名倒写

system------微服务名

api------模块名

8.3.2 步骤2：等级ruoyi-api-test依赖

去父项目ruoyi pom.xml文件中登记新建的api

<!-- test接口 -->
<dependency>
    <groupId>com.ruoyi</groupId>
    <artifactId>ruoyi-api-test</artifactId>
    <version>${ruoyi.version}</version>
</dependency>

8.3.3 步骤3：定义ruoyi-modules-test

导入依赖参考，ruoyi-system 注意要导入ruoyi-api-test依赖

创建包结构参考ruoyi-system

8.3.4 步骤4：定制微服务配置文件

nacos克隆一份配置文件--克隆自ruoyi-system-dev.yml

8.3.5 步骤5：定制网关微服务路由

到这，定制微服务就结束了，剩下操作就是常规crud了。

九、小结

将整篇教程总结一下：若依(Ruoyi-Cloud)版本使用

启动

1>官网克隆项目到idea

2>按照文档，建库，建表，配置nacos

3>准备各种环境，修改本地配置

4>前后端启动，测试。

模块解读

1>网关模块，所有请求入口

2>鉴权模块，外部鉴权，内部鉴权

3>代码生成模块，先建表，再定制，后覆盖

微服务定制

1>拷贝模仿现有api/modules

2>配置中心加配置文件

3>网关配置转发路由

如何使用呼叫转移拦截骚扰电话

BigWind — Fri, 09 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/life/%E6%8B%A6%E6%88%AA%E9%AA%9A%E6%89%B0%E7%94%B5%E8%AF%9D/

拦截骚扰电话

我拦截骚扰电话一般使用空号回应，效果最好，

首先在三家运营商那里开启呼叫转移功能，功能是免费的，

只有呼转成功才收费，然后，在手机的通话设置中，找到呼叫转移，将其中的遇忙转移，转移到一个运营商级别的空号，

移动呼转到+8613800000000
联通呼转到+8613000000000
电信呼转到+8618100000000

请按照运营商设置，别妄想想着设置别的运营商的号码，没用。

在设置之前，如果骚扰电话打过来，你挂断，对方听到的是用户正忙或者正在通话中，对方就知道这个号码一定有人用，如果你设置了上面的号码，你挂断，对方听到的就是空号的提示。

另外，为了防止误伤，例如你正在通话，你的熟人打电话过来，可能直接听到的也是空号，需要在运营商那里打开呼叫等待功能，功能也是免费，

然后拨号盘输入*43#按拨号键打开，打开后你正在通话，你的熟人打电话给你，听到的就是，请不要挂机，您拨打的电话正在通话中，降低误伤。

最后，因为现在运营商已经大量关闭2G和3G网络，现在手机通话基本上是通过VoLTE和VoNR进行，在2G/3G模式下只要手机有信号，就可以设置，但是VoLTE模式下，并不是所有手机都可以设置，例如小米5，支持联通VoLTE，但是无法在联通VoLTE状态下设置联通的呼叫转移，到了小米6才解决，因为4G和5G时代设置呼叫转移，手机的运营商配置文件必须支持才可以，不支持就别想了，而且设置的时候，必须打开数据流量开关，不然绝对不会成功。如果自己手机设置不成功，那就换别人手机试试，只要设置好了就行。反正我是用这个方法，拦截了很多骚扰电话，对方听到空号，基本不会打过来，会认为是个无效号码

Spring Cache笔记

BigWind — Thu, 01 Aug 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/java/springboot-cache/

Spring Cache

2.1.1 介绍

Spring Cache 是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。

Spring Cache 提供了一层抽象，底层可以切换不同的缓存实现，例如：

EHCache
Caffeine
Redis(常用)

起步依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>                                          <version>2.7.3</version> 
</dependency>

2.1.2 常用注解

在SpringCache中提供了很多缓存操作的注解，常见的是以下的几个：

注解	说明
@EnableCaching	开启缓存注解功能，通常加在启动类上
@Cacheable	在方法执行前先查询缓存中是否有数据，如果有数据，则直接返回缓存数据；如果没有缓存数据，调用方法并将方法返回值放到缓存中
@CachePut	将方法的返回值放到缓存中
@CacheEvict	将一条或多条数据从缓存中删除

在spring boot项目中，使用缓存技术只需在项目中导入相关缓存技术的依赖包，并在启动类上使用@EnableCaching开启缓存支持即可。

例如，使用Redis作为缓存技术，只需要导入Spring data Redis的maven坐标即可。

操作系统导论

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E4%B8%80-%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AF%BC%E8%AE%BA/

计算机操作系统学习笔记(一)-操作系统导论

操作系统导论

1）计算机操作系统的主要目标？

计算机操作系统的主要目标包括：

方便性：使计算机系统易于使用，提供友好的用户界面和操作方式。
有效性：提高系统资源的利用率和系统的吞吐量，以便更多的任务可以在更短的时间内完成。
可扩充性：为适应计算机硬件、体系结构以及计算机应用发展的要求，容易升级。
开放性：系统能遵循世界标准规范，特别是遵循开放系统互连 (OSI)国际标准。

2）操作系统的基本特征是什么？

操作系统的四个基本特征是：并发性、共享性、虚拟性和异步性

并发性：指两个或多个事件在同一时间间隔内发生。
共享性：指系统中的资源可供内存中多个并发执行的进程共同使用。
虚拟性：指通过某种技术把一个物理实体变成若干个逻辑上的对应物。
异步性：即不确定性。在多道程序设计中，各个程序之间存在着直接或间接的联系，程序的推进速度受它的运行环境的影响。这时同一程序和数据的多次运行可能得到不同的结果；程序的运行时间、运行顺序也具有不确定性；外部输入的请求、运行故障发生的时间难以预测。这些都是不确定性的表现。

3）多道批处理、分时系统，实时系统的概念，特点

多道批处理系统、分时系统和实时系统是操作系统的三种基本类型。

1. 多道批处理：是操作系统的一种运行方式，它允许内存中同时存放多个程序，并轮流占有CPU，交替执行，当某个程序因某种原因如IO操作时二不能继续执行而放弃CPU时，操作系统调度另一程序允许，这样以达到提高系统效率的作用

其主要特点包括：

多道性：内存中同时存放多个作业，一个时刻只有一个作业运行，这些作业共享CPU和外部设备等资源。
宏观上并行，微观上串行：内存中多道程序轮流占有CPU，交替执行。
资源利用率高：当某道程序因某种原因如执行I/O操作时而不能继续运行放弃CPU时，操作系统便调度另一程序运行，这样CPU就尽量忙碌，达到提高系统效率的目的。
平均周转时间长：由于多道程序系统中有多个作业在内存中，因此每个作业的处理时间会相对较长。
无交互能力：多道程序系统中的作业是批量提交的，因此用户无法与系统进行交互。

2. 分时系统：在一台主机上连接了多个带有显示器和键盘的终端，同时允许多个用户通过自己的终端，以交互方式使用计算机，共享主机中的资源。

其主要特点包括：

多路性：指一台计算机与若干台终端相连接，终端上的这些用户可以按照分时原则共享计算机资源。
独立性：指用户和用户之间都是独立操作系统的，在同时操作时并不会发生冲突、破坏、混淆等现象。
及时性：指系统能以最快的速度将结果显示给用户。
交互性：指用户可以通过终端进行广泛的人机交互。

3. 实时系统：系统能及时响应外部事件的请求，在规定的时间内完成对该事件的处理，并控制所有实时任务协调一致的运行。

其主要特点包括：

多路性：信息查询系统表现为系统按分时原则为多个终端用户服务；实时控制系统表现为系统周期的对多路现场信息进行采集，以及对多个对象或执行机构进行控制
独立性：信息查询系统表现为用户终端查询互相干扰，实时控制系统表现为采集和控制功能互不干扰
及时性：指系统能够在规定的时间响应外部事件并返回处理结果。
交互性：指用户可以通过终端进行有限的人机交互。

处理机调度和死锁

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E4%B8%89-%E5%A4%84%E7%90%86%E6%9C%BA%E8%B0%83%E5%BA%A6%E5%92%8C%E6%AD%BB%E9%94%81/

计算机操作系统学习笔记（三）-处理机调度和死锁

处理机调度和死锁

1、阐述动态分区分配的分区回收机制？

如果回收分区与插入点的前一个空闲分区f1相邻接，将两个空闲分区合并成一个大的空闲分区，新分区的首址为f1的首址，大小为两者之和。
如果回收分区与插入点的后一个空闲分区f2相邻接，将两个空闲分区合并成一个大的空闲分区，新分区的首址为回收分区的首址，大小为两者之和。
如果回收分区同时与插入点的前后两个分区邻接，将三个空闲分区合并成一个大的空闲分区，新分区的首址为f1的首址，大小为三者之和。
如果回收分区既不与前一个分区邻接，也不与后一个分区邻接，为回收分区单独建立一个新表项，新分区的首址为回收分区的首址，大小为回收分区大小，将表项插入到空闲分区链表合适位置中。

2、死锁的定义是什么，其必要条件有那些？

操作系统中一组进程的每一个进程都在等待由且仅有该组进程的其他进程才能引发的事件，则该组进程死锁

死锁的产生需要满足以下 4 个条件：

互斥条件：指运进程对所分配到的资源具有排它性，也就是说在一段时间内某个锁资源只能被一个进程所占用。
请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
不可剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺。
循环等待条件：指在发生死锁时，必然存在运算单元和资源的环形链，即进程正在等待另一个进程占用的资源，而对方又在等待自己占用的资源，从而造成环路等待的情况。

3、什么是高级、中级、低级调度？优先级倒置概念是什么？

高级调度（作业调度）按某种算法从外存上处于后备队列的作业中挑选一个（或多个）作业调度进入内存。

中级调度（内存调度）为了使内存中的进程过多，将一些暂时不能运行的进程从内存中对换到外存中等待。

低级调度（进程调度）主要任务是按照某种方法和策略从就绪队列中选取一个进程，将处理机分配给它。进程调度是操作系统中最基本的一种调度，在一般的操作系统中都必须配置进程调度。进程调度的频率很高，一般几十毫秒一次。

优先级倒置是高优先级的进程（线程）被一个低优先级进程（线程）延迟或堵塞。

文件管理

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E4%B8%83-%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86/

计算机操作系统学习笔记（七）-文件管理

文件管理

1、文件的定义

文件是记录在外存上的相关信息的命名组合。从用户角度来看，文件是逻辑外存的最小分配单元，也就是说，数据只有通过文件才能写到外存。通常，文件表示程序（源形式和目标形式）和数据。数据文件可以是数字的、字符的、字符数字的或二进制的。文件可以是自由形式的，例如文本文件，或者可以是具有严格格式的。通常，文件为位、字节、行或记录的序列，其含义由文件的创建者和用户定义。因此，文件概念非常通用。文件信息由创建者定义。文件可存储许多不同类型的信息，如源程序或可执行程序、数字或文本数据、照片、音乐、视频等。文件具有某种定义的结构，这取决于其类型。比如：文本文件为按行（可能还有页）组织的字符序列；源文件为函数序列，而每个函数包括声明和可执行语句；可执行文件为一系列代码段，以供加载程序调入内存并执行。文件的属性因操作系统而异，但通常包括：名称、标识符、类型、位置、尺寸、保护、时间、日期和用户标识等

2、目录的定义，文件系统对目录管理有什么要求？

文件系统中的目录是一种特殊的文件，用于存储其他文件的信息。目录中的每个条目都包含有关文件的信息，例如文件名、大小、创建日期和位置等。目录可以帮助用户组织和管理文件，使其更容易找到所需的文件。

文件系统对目录管理要求：

实现“按名存取”。即用户只需提供所需访问文件的名称，便能快速准确地找到指定文件在外存上的存储位置。
提高对目录的检索速度。通过合理地组织目录结构的方法，可加快对目录的检索速度，从而提高对文件的存取速度。
文件共享。在多用户系统中，应允许多个用户共享一个文件。这样就须在外存中只保留一份该文件的副本，供不同用户使用，以节省大量的存储空间，并方便用户和提高文件利用率。
允许文件重名。系统应允许不同用户对不同文件采用相同的名称，以便于用户按照自己的习惯给文件命名和使用文件。

3、文件的逻辑结构、物理结构的概念是什么，常见文件逻辑结构的基本特点？

文件的逻辑结构是指文件在用户面前所呈现的形式，即用户可以直接处理的数据及其结构，它独立于文件的物理特性，又称为文件组织。

文件的物理结构，又称为文件的存储结构，是指文件在外存上的存储组织形式，这不仅与存储介质的存储性能有关，而且与所采用的外存分配方式有关。

文件的逻辑结构有两种形式：记录式文件和字符流式文件。其中，记录式文件是由一系列的记录组成的，记录的长度可分为定长和不定长两类。定长记录指文件中所有记录的长度都是相同的，所有记录中的各数据项都处在记录中相同的位置，具有相同的顺序和长度。变长记录指文件中各记录的长度不相同。

常见的文件逻辑结构的基本特点包括：

提高检索速度
便于用户修改
降低文件的存储费用

进程的描述和控制

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E4%BA%8C-%E8%BF%9B%E7%A8%8B%E7%9A%84%E6%8F%8F%E8%BF%B0%E5%92%8C%E6%8E%A7%E5%88%B6/

计算机操作系统学习笔记（二）-进程的描述和控制

进程的描述和控制

1）程序顺序执行、并发执行的特征是什么，同步、异步的概念是什么？

顺序执行：

顺序性：程序严格按照顺序执行，前一个程序结束后一个程序才能执行。
封闭性：程序在封闭环境下运行，程序运行时独占资源，各种资源的状态（除初始状态）仅由本程序·才能改变，程序一旦开始运行，其结果不受外界因素影响。
可再现性：程序重复执行时，只要程序执行的环境和初始条件相同，无论执行方式是连续还是间断，程序结果相同。

并发执行：

间断性：程序因并发执行共享资源，以及为完成某一任务相互合作，使这些并发执行的程序之间存在相互制约的关系。
失去封闭性：当系统中存在多个并发执行的程序，因其共享资源，致使这些资源被改变时，其任一程序受其影响。
不可再现性：因失去封闭性，重复执行的程序不一定有相同的执行结果。

同步：同步是指一个进程在执行某个请求的时候，如果该请求需要一段时间才能返回信息，那么这个进程会一直等待下去，直到收到返回信息才继续执行下去。

异步：异步是指进程不需要一直等待下去，而是继续执行下面的操作，不管其他进程的状态，当有信息返回的时候会通知进程进行处理

2）进程同步控制应遵循那些原则？

空闲让进：当无进程处于临界区时，表明临界资源处于空闲状态，应允许一个请求进入临界区的进程立即进入自己的临界区，以有效地利用临界资源。
忙则等待：当已有进程进入临界区时，表明临界资源正在被访问，因而其它试图进入临界区的进程必须等待，以保证对临界资源的互斥访问。
有限等待：对要求访问临界资源的进程，应保证在有限时间内能进入自己的临界区，避免陷入 “死等” 状态。
让权等待：当进程不能进入自己的临界区时，应立即释放处理机，避免进程陷入 “忙等” 状态。

3）进程的概念，进程实体由什么构成

进程是进程实体的运行过程，是系统进行资源和调度的一个独立单位。

进程实体由程序段、数据段和进程控制块（PCB）三部分组成。其中，程序段是指进程所执行的程序代码，数据段是指进程所使用的数据及堆栈等，PCB是进程控制块的缩写，是操作系统用来管理进程的数据结构，包含了进程的各种信息，如进程状态、进程优先级、进程ID等。

4）管程的定义和组成是什么？

管程是由代表共享资源的一组数据以及对该共享数据结构实施一组过程所组成的资源管理程序共同构成的一个操作系统的资源管理模块。

管程由以下四部分组成:

管程的名称
局部于管程的共享数据结构说明
对该数据结构进行操作的一组过程
对局部于管程的共享数据设置初始值的语句

5）进程的三种基本状态是什么？

就绪 (Ready) 状态：当进程已分配到除 CPU 以外的所有必要的资源，只要获得 CPU 便可立即执行，这时的进程状态称为就绪状态。
执行（Running）状态：当进程已获得 CPU，其程序正在 CPU 上执行，此时的进程状态称为执行状态。
阻塞（Blocked）状态：当进程由于某些原因无法执行时，如等待某个事件的发生或等待某个资源的释放，此时的进程状态称为阻塞状态。

6）进程的五种状态是什么？为什么要引入挂起?

进程的五种状态:

新建（New）状态：进程被创建但尚未进入就绪队列。
就绪（Ready）状态：进程已分配到除 CPU 以外的所有必要的资源，只要获得 CPU 便可立即执行。
运行（Running）状态：进程已获得 CPU，其程序正在 CPU 上执行。
阻塞（Blocked）状态：进程由于某些原因无法执行，如等待某个事件的发生或等待某个资源的释放。
终止（Exit）状态：进程已完成任务或出现无法克服的错误而异常终止。

引入挂起状态是因为五种不同的需要：

终端用户需要
父进程请求
负荷调节需要
操作系统需要
对换需要

7）解释PCB,TCB

PCB是进程控制块（Process Control Block）的缩写，是操作系统用来管理进程的数据结构，包含了进程的各种信息，如进程状态、进程优先级、进程ID等。

TCB是线程控制块（Thread Control Block）的缩写，是系统为每个线程配置的一个线程控制块，用于控制和管理线程的信息，如线程标识符、线程运行状态、优先级等。

8）线程的概念是什么？与进程比较各自的特点

线程是操作系统调度和分配的基本单位

比较特点：

均有并发性
进程拥有更多的系统资源
线程独立性小
线程切换比进程切换系统开销小
均支持多处理机

虚拟存储器

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E4%BA%94-%E8%99%9A%E6%8B%9F%E5%AD%98%E5%82%A8%E5%99%A8/

计算机操作系统学习笔记（五）-虚拟存储器

虚拟存储器

1、什么是虚拟存储器？

指具有调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统

2、局部性原理是什么？什么是时间局限性，什么是空间局限性？

局部性原理是指程序在执行时呈现出局部性规律，即在一段时间内，整个程序的执行仅限于程序中的某一部分。相应地，执行所访问的存储空间也局限于某个内存区域。局部性原理又表现为：时间局部性和空间局部性。

时间局部性是指如果程序中的某条指令一旦执行，则不久之后该指令可能再次被执行；如果某数据被访问，则不久之后该数据可能再次被访问。

空间局部性是指一旦程序访问了某个存储单元，则不久之后，其附近的存储单元也将被访问

3、什么是系统抖动？

系统抖动是指在请求分页存储管理中，从主存中刚刚换出某一页面，根据请求马上又换入该页，这种反复换出换入的现象叫系统抖动

磁盘存储器的管理

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E5%85%AB-%E7%A3%81%E7%9B%98%E5%AD%98%E5%82%A8%E5%99%A8%E7%9A%84%E7%AE%A1%E7%90%86/

计算机操作系统学习笔记（八）-磁盘存储器的管理

磁盘存储器的管理

1、成组链接法的特点？

成组链接法是一种文件存储空间管理方法，它将空闲块分成若干组，每组的第一个空闲块登记了下一组空闲块的物理盘块号和空闲块总数。如果一组的第一个空闲块号等于0，则有特殊的含义，意味着该组是最后一组，即无下一个空闲块。成组链接法的优点是可以有效地降低问题的复杂度，提高问题的解决效率。通过将问题划分为若干个组，并对每个组内的元素进行排序和连接，可以将原本复杂的问题转化为简单的子问题，从而简化了问题的求解过程。

2、位示图法盘块如何定位，举例说明

位示图法是一种文件存储空间管理方法，用于记录磁盘中的空闲块和已分配块的使用情况。在位示图法中，每个盘块都有一个二进制位与之对应，这样，由所有盘块所对应的位构成一个集合，称为位示图。当其值为“0”时，表示对应的盘块空闲；为“1”时，表示已经分配。盘块的分配过程如下：

顺序扫描位示图，找到一个或一组代表空闲盘块的二进制位（如果是0代表空闲盘块就找0，如果1代表空闲盘块就找1）。
将所找到的一个或一组二进制位的行号和列号转换成相应的盘块号。
将位示图对应的一个或一组二进制位修改为代表已分配盘块的二进制位（如果1代表已分配，就修改为1，如果0代表已分配，就修改为0）。

盘块的回收过程如下：

将要回收的盘块号转换成对应的行号和列号。
修改位示图，令对应的二进制位为代表空闲盘块的二进制位（如果0代表空闲盘块就修改为0，如果1代表空闲盘块就修改为1）。

3、FAT12、FAT16、FAT32技术能够管理的盘块数量和磁盘空间大小的换算，试举例说明

FAT12、FAT16和FAT32是三种常见的文件系统，它们都使用了FAT表来管理磁盘空间。FAT12适用于小容量的磁盘，FAT16适用于中等容量的磁盘，而FAT32适用于大容量的磁盘。下面是它们能够管理的盘块数量和磁盘空间大小的换算123:

FAT12：最大容量为32MB，最大盘块数为4084个。

FAT16：最大容量为2GB，最大盘块数为65536个。

FAT32：最大容量为2TB，最大盘块数为268435456个。

如果需要将盘块数量转换为磁盘空间大小，可以使用以下公式：

对于FAT12和FAT16：磁盘空间大小 = 盘块数量 × 盘块大小

对于FAT32：磁盘空间大小 = 盘块数量 × 4KB

其中，盘块大小为512字节。

存储器管理

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E5%9B%9B-%E5%AD%98%E5%82%A8%E5%99%A8%E7%AE%A1%E7%90%86/

计算机操作系统学习笔记（四）-存储器管理

存储器管理

1、分页存储中页、块、页表、快表定义是什么？在地址变换过程中的作用；

分页存储是操作系统中的一种内存管理方式。在分页存储中，物理内存被划分为大小固定的块，即页面。每个页面都有自己的页号和页长，页内地址是相对地址。每个进程的地址空间被分成若干逻辑段，每段又被划分成若干大小固定的页。页表记录了每个页在内存中的起始位置（又称“基址”）和页的长度。快表是存放在高速缓存存储器中的部分页表，用于加速地址变换过程，减少直接访问主存的次数。下面是它们的定义和作用：

页：将用户进程的（逻辑）地址空间划分为固定且大小相等的一个个区域。
块：物理内存被划分为大小固定的块，即页面。
页表：记录了每个页在内存中的起始位置（又称“基址”）和页的长度，用于实现逻辑地址到物理地址的映射关系。
快表：存放在高速缓存存储器中的部分页表，用于加速地址变换过程，减少直接访问主存的次数。

在地址变换过程中，页表和快表的作用如下：

页表：在用动态重定位方式装入作业时，利用页表做地址转换工作。当CPU访问一个逻辑地址时，通过页表将逻辑地址转换为物理地址。
快表：存放最近访问的页所对应的页框号，用于加速地址变换过程，减少直接访问主存的次数。当CPU访问一个逻辑地址时，先在快表中查找，如果找到则直接得到物理地址；否则再在页表中查找，得到物理地址后将其存入快表中，以便下次访问时直接得到物理地址。

2、分段与分页存储的对比有什么差异？

分段和分页是操作系统中的两种内存管理方式。

分页存储的页是物理单位，分页存储是离散型分配；分段存储中的段是信息的逻辑单位，通常包含一组相对完整的信息
分段是将程序分为若干个段，每个段的大小不固定，逻辑上连续的地址空间被划分为一个个段，每个段都有自己的段号和段长，段内地址是相对地址。分页是将程序分为若干个页，每个页的大小固定，物理上不连续的地址空间被划分为一个个页，每个页都有自己的页号和页长，页内地址是相对地址。
分段的作业地址空间是二维的，在标识一个地址时，既需给出段名，又需给出段内地址；分页的作业地址空间是一维的，只须利用一个记忆符，即可表示一地址。

分段的优点是能够更好地实现信息的共享，因为段的大小不固定，可以根据需要动态地分配内存，而且段表比页表短，可以缩短查找时间，提高访问速度；

分页的优点是能够更好地利用内存，因为页的大小固定，不会产生外碎片，更有效地利用了内存，但会产生一些内碎片，即分配给进程的最后一个页往往不能正好用完。

3、分段的地址结构是1维的吗？段的大小是否必须相等？

分段是操作系统中的一种内存管理方式，其地址结构是二维的。程序员在标识一个地址时，既需给出段名，又需给出段内地址。段的大小不必相等，可以根据需要动态地分配内存。

4、段页式存储管理中，物理内存是被划分为段，还是被划分为块来分配？

段页式存储管理中，物理内存是被划分为块来分配。在段页式存储管理中，一个进程的地址空间首先被分成若干逻辑段，每段都有自己的段号，然后再将每一段划分成若干大小固定的页。对内存空间的管理仍然和分页存储管理一样，将其分成若干和页面大小相同的存储块，对内存的分配以存储块为单位。因此，物理内存是被划分为块，而不是被划分为段来分配。

5、已知某分页系统，主存容量为128KB，分成64块，对一个4页大的作业，其0、1、2、3页分别被分配到主存的2、5、7、11块中。该系统的分页大小为多少？作业的总长度是多少？将逻辑地址2023、5500转换成物理地址是多少？

该分页系统的分页大小为 2KB。作业的总长度为 16KB。

逻辑地址2023转换成物理地址得到 11019

将逻辑地址5500转换成物理地址得到 28676

输入输出系统

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/computer/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E5%85%AD-%E8%BE%93%E5%85%A5%E8%BE%93%E5%87%BA%E7%B3%BB%E7%BB%9F/

计算机操作系统学习笔记（六）-输入输出系统

输入输出系统

1、什么是字符设备，什么是块设备，试举例常见的字符设备和块设备

字符设备是一种按字符流的方式被有序访问的设备，例如键盘和串口。

块设备是一种可以随机访问固定大小数据片（chunks）的设备，例如硬盘、软盘驱动器、CD-ROM驱动器和闪存等等许多其他块设备.

下面是一些常见的字符设备和块设备：

字符设备：

键盘
鼠标
串口
声卡
打印机

块设备：

硬盘
固态硬盘
U盘
CD-ROM
DVD-ROM

2、I/O的基本控制方式由那些，各有什么特点？

I/O的基本控制方式有四种：使用轮询的可编程IO方式、使用中断的可编程IO方式、DMA（直接存储器访问）方式和通道控制方式.

这些方式各有不同的特点：

使用轮询的可编程IO方式：CPU需要不断地测试I/O设备的状态，造成了CPU资源的极大浪费。CPU和I/O设备只能串行化工作，CPU利用率很低。

使用中断的可编程IO方式：I/O控制器会通过中断信号主动报告I/O已完成，CPU不再需要不停的轮询。CPU和I/O设备可并行工作，CPU利用率得到明显提升。

DMA方式：数据传输效率以“块”为单位，仅在传送一个或多个数据块的开始和结束时，才需要CPU的干预，CPU的介入性进一步降低。CPU和I/O设备的并行性进一步提升。

通道控制方式：CPU、通道、I/O设备可并行工作，资源利用率极高。实现复杂，需要专门的通道硬件支持。

3、什么是设备独立性，虚拟设备、逻辑设备，物理设备的概念是什么？

设备独立性是指应用程序独立于具体使用的物理设备。为了实现设备独立性，引入了逻辑设备和物理设备这两个概念。在应用程序中，使用逻辑设备名称来请求使用某类设备；而系统在实际执行时，还必须使用物理设备名称。

逻辑设备是指应用程序中使用的设备名称

物理设备是指实际的硬件设备

虚拟设备是指由操作系统模拟出来的设备，例如虚拟内存、虚拟磁盘等。

4、SPOOLing系统的概念，其组成是什么？

SPOOLing系统是一种假脱机系统，它可以在联机的情况下实现外围操作。

SPOOLing系统由以下几个部分组成：

输入井和输出井：输入井和输出井的存储区域是在磁盘上开辟出来的。输入输出井中的数据一般以文件的形式组织管理，这些文件称之为井文件。一个文件仅存放某一个进程的输入或输出数据，所有进程的数据输入或输出文件链接成一个输入输出队列。
输入缓存区和输出缓存区：输入缓冲区和输出缓冲区的存储区域是在内存中开辟出来的。主要用于缓和CPU和磁盘之间速度不匹配的矛盾。输入缓冲区用于暂存有输入设备传送的数据，之后再传送到输入井；输出缓冲区同理。
输入进程和输出进程：输入进程也称为预输入进程，用于模拟脱机输入时的外围控制机，将用户要求的数据从输入设备传送到输入缓冲区，再放到输入井。当CPU需要的时候，直接从输入井将数据读入内存。反之，输出的同理。
井管理程序：用于控制作业与磁盘井之间信息的交换。

5、设备从磁盘驱动器中读出一块数据主要由那几步时间花销构成？

设备从磁盘驱动器中读出一块数据主要由以下三个步骤构成:

寻道时间：磁头移动到指定磁道所需的时间。寻道时间包括启动磁臂的时间和磁头移动n条磁道所花费的时间之和。寻道时间是磁盘读写数据所花费的时间中最长的部分。
旋转延迟时间：指定扇区移动到磁头下面所经历的时间。旋转延迟时间取决于磁盘的转速，通常为4-12毫秒。
传输时间：从磁盘读出或将数据写入磁盘的时间。传输时间取决于数据传输速率和数据块大小。

6、假定当前磁头在100号磁道上，并正在由里向外移动，目前有下面的请求访问磁盘磁道的序列：79、58、110、138、65、148、18、45。请写出：（1）用最短寻道时间优先（SSTF），电梯算法、循环扫描、先来先服务等算法，列出响应的磁道次序，并计算平均寻道长度。

最短寻道时间优先算法（SSTF）的响应磁道次序：

平均寻道长度为：34.875

循环扫描算法的响应磁道次序：

平均寻道长度为：33.375

电梯算法的响应磁道次序：

平均寻道长度为：34.375

先来先服务算法的响应磁道次序：

平均寻道长度为：34.25

Git 如何将fork的GitHub项目与原项目同步极客教程

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/git-%E5%A6%82%E4%BD%95%E5%B0%86fork%E7%9A%84github%E9%A1%B9%E7%9B%AE%E4%B8%8E%E5%8E%9F%E9%A1%B9%E7%9B%AE%E5%90%8C%E6%AD%A5%E6%9E%81%E5%AE%A2%E6%95%99%E7%A8%8B/

Git 如何将fork的GitHub项目与原项目同步

在本文中，我们将介绍如何使用Git将fork的GitHub项目与原项目进行同步。当我们在GitHub上fork一个项目后，我们可以通过同步操作来跟踪和合并原项目的更新。这样我们就能保持我们fork出来的项目与原项目保持同步，同时还能享受到原项目的更新和改进。

阅读更多：Git 教程

1. 配置远程仓库

首先，我们需要配置本地仓库与fork的远程仓库和原项目的远程仓库的连接。在命令行中进入本地仓库所在的目录，并执行以下命令：

git remote -v

这会列出本地仓库当前配置的远程仓库。通常情况下，我们会看到两个远程仓库，一个是fork的远程仓库（origin），另一个是原项目的远程仓库（upstream）。

如果我们没有配置原项目的远程仓库，我们可以通过以下 <原项目仓库的URL>

这样，我们就成功地配置了本地仓库与原项目的远程仓库的链接。

2. 同步原项目的更新

当原项目有新的更新时，我们需要将这些更新同步到我们自己的forked项目中。以下是同步的步骤：

步骤1：拉取原项目的更新

这个命令会从原项目的远程仓库中获取最新的更新。

git fetch upstream

步骤2：切换到主分支

git checkout master

确保我们在主分支上进行同步操作。

步骤3：合并更新

这个命令会将原项目的更新与我们自己的forked项目进行合并。

git merge upstream/master

步骤4：推送到forked远程仓库

git push origin master

将合并后的更新推送到我们自己的forked远程仓库。

3. 同步我们的forked项目

在我们将原项目的更新同步到我们自己的forked项目后，我们也可能在我们自己的forked项目中进行了一些修改。接下来，我们将学习如何将我们自己的修改同步回原项目。

步骤1：切换到主分支

git checkout master

确保我们在主分支上进行同步操作。

步骤2：拉取forked项目的更新

git pull origin master

这个命令将获取我们自己的forked项目的最新更新。

步骤3：推送到原项目的远程仓库

git push upstream master

通过这个命令，我们将修改推送到原项目的远程仓库。

总结

通过Git，我们可以方便地将fork的GitHub项目与原项目进行同步。配置远程仓库，拉取原项目的更新，合并更新，推送到我们自己的forked项目，以及将我们自己的修改同步回原项目，是同步forked项目与原项目的基本步骤。掌握这些技巧，可以使我们更好地跟踪和合并原项目的更新，同时还能将我们自己的修改和改进回馈到原项目中。通过这样的同步操作，我们可以更好地参与到开源项目中，为其发展做出贡献。

在HBuilderX中添加Yarn npm pnpm命令

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/add-yarn-npm-and-pnpm-commands-in-hbuilderx/

在HBuilderX中添加Yarn/npm/pnpm命令

首先，确保你已经正确安装了Yarn。如果还没有安装，你可以从Yarn官方网站下载对应的安装包，并按照提示进行安装。安装完成后，可以在终端或命令提示符窗口运行yarn --version命令，如果成功显示Yarn的版本号，说明安装成功。
接下来，在HBuilderX中添加Yarn的外部命令。打开HBuilderX，在菜单栏中选择“工具”-"外部命令"-"自定义外部命令"。

在"用户设置"窗口中添加如下命令代码，保存配置。这样，HBuilderX就会有Yarn作为外部命令。

[
 {
        "name":"Yarn install",
        "command":"yarn install",
        "type": "terminal",
        "workingDir" : "${projectDir}"
    },
    {
           "name":"Yarn run dev",
           "command":"yarn run dev",
           "type": "terminal",
            "workingDir" : "${projectDir}"
       },
    {
           "name":"Yarn run build:prod",
           "command":"yarn run build:prod",
           "type": "terminal",
            "workingDir" : "${projectDir}"
       }   
]

在项目中测试配置是否生效。自己打开或者新建一个项目，先使用yarn install 再使用yarn run dev 命令
看到项目运行成功，web网页链接出现
其他yarn命令或pnpm命令可自行配置
PS: 网上一堆关于HbulidX的教程害人不浅，最终决定自己写一个

Windows搭建Typecho个人博客并发布公网访问【内网穿透】

BigWind — Wed, 31 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/web/windows%E6%90%AD%E5%BB%BAtypecho%E4%B8%AA%E4%BA%BA%E5%8D%9A%E5%AE%A2%E5%B9%B6%E5%8F%91%E5%B8%83%E5%85%AC%E7%BD%91%E8%AE%BF%E9%97%AE%E5%86%85%E7%BD%91%E7%A9%BF%E9%80%8F/

前言

Typecho是一款PHP语言编写的开源博客程序，它是一个轻量级的内容管理系统，专注于博客领域。支持多用户、多站点、多语言等功能，可以满足不同用户的需求。

同时，Typecho还有丰富的插件和模板资源，用户可以根据自己的需要自由选择和配置。

Typecho的安装非常简单，用户只需要将Typecho的安装包上传到自己的服务器上，然后通过浏览器访问相应的URL进行安装即可。

cpolar内网穿透工具主要是将本地端口转发到公网环境,通过此工具我们很容易将本地服务转发到公网.

下面介绍在windwos系统搭建typecho博客+cpolar内网穿透工具将博客发布到公共网络环境,实现远程也可以访问和操作。

1. 环境安装

Typecho博客是PHP语言写的,运行它需要安装一系列环境,如PHP,数据库和运行web容器等,为了方便搭建那些环境,我们使用一个第三方工具XAMPP,这个工具集成了我们所需的工具环境,一键即可安装,减少了繁琐的配置,这是下载地址:https://www.apachefriends.org/,我们选择windwos版本安装.

安装时候点击next即可,安装路径可以自定义设置,安装后,我们打开,点击界面启动apache测试:

启动服务后,在浏览器输入localhost:80,即可看到apache的欢迎页面,然后停止Apache

2.安装Typecho

进入Typecho 官网下载,

下载好后,我们找一个叫htdocs的文件夹,这个文件夹就是apache的web访问目录,点击XAMPP右边Explorer

然后找到htdocs文件夹

先把htdocs里面的文件全部删除,我们把Typecho的压缩包解压到htdocs的文件夹下.

然后我们再次启动apache,在浏览器输入localhost:80,自动跳转到了typecho页面

3.安装cpolar内网穿透

cpolar官网：https://www.cpolar.com/

访问cpolar官网，注册一个账号，然后下载并安装客户端，具体安装教程可以参考官网文档教程。

windows系统：在官网下载安装包后，双击安装包一路默认安装即可。
linux系统：支持一键自动安装脚本，详细请参考官网文档——入门指南

cpolar安装成功后，在浏览器上访问本地9200端口【http://localhost:9200】，使用cpolar账号登录。

点击左侧仪表盘的隧道管理——创建隧道，创建一个80端口 http隧道,即Apache 的端口

隧道名称：可自定义命名，注意不要与已有的隧道名称重复
协议：选择http
本地地址：80
域名类型：免费选择随机域名
地区：选择China vip

点击创建

隧道创建成功后，点击左侧的状态——在线隧道列表,查看所生成的公网地址，然后复制地址

打开浏览器,使用上面公网地址进行连访问,即可看到typecho博客欢迎页,此时即可使用公网地址进行远程访问

4. 固定公网地址

由于以上使用cpolar所创建的隧道使用的是随机公网地址，24小时内会随机变化，不利于长期远程访问。因此我们可以为其配置二级子域名，该地址为固定地址，不会随机变化【ps：cpolar.cn已备案】

注意需要将cpolar套餐升级至基础套餐或以上，且每个套餐对应的带宽不一样。

登录cpolar官网，点击左侧的预留，选择保留二级子域名，设置一个二级子域名名称，点击保留,保留成功后复制保留的二级子域名名称

保留成功后复制保留的二级子域名地址

访问http://127.0.0.1:9200/，登录cpolar web UI管理界面，点击左侧仪表盘的隧道管理——隧道列表，找到所要配置的80端口隧道，点击右侧的编辑

修改隧道信息，将保留成功的二级子域名配置到隧道中

域名类型：选择二级子域名
Sub Domain：填写保留成功的二级子域名

点击更新

更新完成后,打开在线隧道列表,此时可以看到公网地址已经发生变化,地址名称也变成了保留过的二级子域名名称,将其复制下来

然后使用固定https地址打开浏览器访问,同样访问成功,且域名不会发生变化,然后下面typecho继续配置

5.配置Typecho

点击开始下一步,然后出现数据库配置,

在XAMPP启动数据库

启动后,点击Admin,进入数据库管理界面

然后我们添加一个数据库,名字叫”typecho”

创建好后,我们打开typecho数据库设置页面,填写参数,由于是本地数据库,没有设置密码,所以我们不需要填写密码,填写好后我们确认开始安装

然后,到了设置用户名和密码页面,还有一个邮箱信息,设置完后,点击继续安装

安装成功,在页面显示了登陆用户名和密码,然后点击用户名和密码下面的字样访问控制面板

然后配置完成,即可愉快写文章啦,且支持远程访问

How to customize code box

BigWind — Thu, 18 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/how-to-customize-code-box/

添加行号

此方法仅在 `Shiki` 中可用， `Prism` 无法通过 CSS 直接生成行号。

在 v2.2.1 更新后默认添加行号。

在 src\styles\global.scss 中添加以下内容：

pre .line {
  counter-increment: line;
  padding-left: 2.5em;
}

pre :not(:last-child).line::before {
  content: counter(line);
  position: absolute;
  left: 0;
  width: 3em;
  text-align: right;
  margin-right: 10px;
  color: #888;
}

改变主题

Frosti 使用 Shiki 来渲染代码框， Shiki 已经提供了足够多的主题，不推荐使用 Prism。

有关于 Shiki 的主题详见：https://shiki.style/themes

在 astro.config.mjs 中修改内容：

markdown: {
  shikiConfig: {
    themes: {
      light: 'github-light',
      dark: 'github-dark',
    },
  },
},

Using mdx in Frosti

BigWind — Fri, 12 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/frosti-mdx/

import Collapse from "../../components/mdx/Collapse.astro"; import Diff from "../../components/mdx/Diff.astro"; import Error from "../../components/mdx/Error.astro"; import Info from "../../components/mdx/Info.astro"; import Kbd from "../../components/mdx/Kbd.astro"; import Success from "../../components/mdx/Success.astro"; import Warning from "../../components/mdx/Warning.astro"; import TimeLine from "../../components/mdx/TimeLine.astro"; import LinkCard from "../../components/mdx/LinkCard.astro";

Preface

This article describes how to use the components provided by Frosti in mdx to realize the functions that can't be realized by normal md.

Main text

Getting started

First you need to create an mdx file, which is as simple as changing the extension to .mdx.

Introducing

The components provided by Frosti are placed in the /mdx folders. Write something under the document properties (frontmatter):

import Collapse from "../../components/mdx/Collapse.astro";
import Diff from "../../components/mdx/Diff.astro";
import Error from "../../components/mdx/Error.astro";
import Info from "../../components/mdx/Info.astro";
import Kbd from "../../components/mdx/Kbd.astro";
import Success from "../../components/mdx/Success.astro";
import Warning from "../../components/mdx/Warning.astro";
import TimeLine from "../../components/mdx/TimeLine.astro";
import LinkCard from "../../components/mdx/LinkCard.astro";

Example

Collapse

This is the hidden content!

<Collapse title="This is an example text.">
  This is the hidden content!
</Collapse>

Diff

<Diff l="/image/l.png" r="/image/r.png" />

Error

Maybe something went wrong?

<Error>Maybe something went wrong? </Error>

Warning

Hey! Watch out for potholes!

<Warning>Hey! Watch out for potholes! </Warning>

Message

It's just a message.

<Info>It's just a message. </Info>

Success

Congratulations on your successful deployment!

<Success>Congratulations on your successful deployment! </Success>

Kbd

Ctrl + C to copy the text.

<Kbd>Ctrl</Kbd> + <Kbd>C</Kbd> to copy the text.

TimeLine

<TimeLine
  items={[
    { year: "1984", event: "First Macintosh computer" },
    { year: "1998", event: "iMac" },
    { year: "2001", event: "iPod" },
    { year: "2007", event: "iPhone" },
    { year: "2015", event: "Apple Watch" },
  ]}
/>

LinkCard

<LinkCard
  title="Frosti"
  desc="My blog project!"
  url="https://github.com/EveSunMaple/Frosti"
  img="/logo.png"
/>

PowerDesigner安装教程（含下载+汉化+去试用）

BigWind — Fri, 12 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/powerdesigner%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B%E5%90%AB%E4%B8%8B%E8%BD%BD%E6%B1%89%E5%8C%96%E5%8E%BB%E8%AF%95%E7%94%A8/

PowerDesigner安装教程（含下载+汉化+去试用）

1.准备工作，下载安装包及其他文件

2、PowerDesigner安装图文教程：

1、解压下载的压缩文件，进入解压文件夹，并双击PowerDesigner.exe；

2、欢迎来到PowerDesigner安装界面，点击 Next；

3.4、选择Hong Kong，点击I AGREE，再点击Next；

5、选择一个安装目录，默认是安装在C盘。再点击Next；

6、这一步直接Next；

点击General和Notaion，再点击Next；

点击Next开始安装

打开软件，点击help

可以看到试用期为15天

PowerDesigner破解步骤：

1、先关闭软件，进入刚才的解压文件夹，将“PowerDesigner破解文件”文件夹下的“pdflm16.dll”复制；

2.粘贴并覆盖到你软件安装的目录中，可能需要管理员权限，同意即可；

3.这时我们再打开软件发现已经没有了试用期限；

PowerDesigner汉化步骤：

1、先关闭软件，进入刚才的解压文件夹，将PowerDesigner汉化文件”文件夹下的所有文件全选复制；

2、粘贴并覆盖到你软件安装的目录中，可能需要管理员权限，同意即可；

重新打开软件汉化成功

Using mdx in Frosti

BigWind — Fri, 12 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/frosti-mdx/

Preface

This article describes how to use the components provided by Frosti in mdx to realize the functions that can't be realized by normal md.

Main text

Getting started

First you need to create an mdx file, which is as simple as changing the extension to .mdx.

Introducing

The components provided by Frosti are placed in the /blog and /page folders. Write something under the document properties (frontmatter):

import Collapse from "../../components/mdx/Collapse.astro";
import Diff from "../../components/mdx/Diff.astro";
import Error from "../../components/mdx/Error.astro";
import Info from "../../components/mdx/Info.astro";
import Kbd from "../../components/mdx/Kbd.astro";
import Success from "../../components/mdx/Success.astro";
import Warning from "../../components/mdx/Warning.astro";
import TimeLine from "../../components/mdx/TimeLine.astro";
import LinkCard from "../../components/mdx/LinkCard.astro";

Example

Collapse

This is the hidden content!

<Collapse title="This is an example text.">
  This is the hidden content!
</Collapse>

Diff

<Diff r="/image/r.png" l="/image/l.png" />

Error

Maybe something went wrong? www.baidu.com

<Error>Maybe something went wrong? </Error>

Warning

Hey! Watch out for potholes!

<Warning>Hey! Watch out for potholes! </Warning>

Message

It's just a message.

<Info>It's just a message. </Info>

Success

Congratulations on your successful deployment!

<Success>Congratulations on your successful deployment! </Success>

Kbd

Ctrl + C to copy the text.

<Kbd>Ctrl</Kbd> + <Kbd>C</Kbd> to copy the text.

TimeLine

<TimeLine
  items={[
    { year: "1984", event: "First Macintosh computer" },
    { year: "1998", event: "iMac" },
    { year: "2001", event: "iPod" },
    { year: "2007", event: "iPhone" },
    { year: "2015", event: "Apple Watch" },
  ]}
/>

LinkCard

<LinkCard
  title="Frosti"
  desc="My blog project!"
  url="https://github.com/EveSunMaple/Frosti"
  img="/favicon.ico"
/>

测试文档

BigWind — Tue, 02 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/using-mdx-copy/

标题

Markdown 支持多级标题，使用 # 符号表示。一个 # 表示一级标题，两个 # 表示二级标题，以此类推。

三级标题

这是一个三级标题。

列表

无序列表

项目一
项目二
项目三

有序列表

第一项
第二项
第三项

格式化文本

你可以使用加粗和斜体来格式化文本。

加粗示例

斜体示例

~~删除线示例~~

链接

这是一个链接

图片

代码

你可以在文档中插入代码片段：

def hello_world():
    print("Hello, world!")

Mathematics Examples

BigWind — Mon, 01 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/mathematics-examples/

This post demonstrates various mathematical notations and equations that can be used in blog posts.

Basic Mathematical Notation

Inline Math

You can include inline mathematical expressions like $E = mc^2$ or $\pi \approx 3.14159$.

Block Math

For larger equations, use block math:

$$ \int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi} $$

Common Mathematical Formulas

Quadratic Formula

$$ x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} $$

Euler's Identity

$$ e^{i\pi} + 1 = 0 $$

Summation

$$ \sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6} $$

Matrix Operations

Matrix Multiplication

$$ \begin{bmatrix} a & b \ c & d \end{bmatrix} \begin{bmatrix} e & f \ g & h \end{bmatrix}

\begin{bmatrix} ae + bg & af + bh \ ce + dg & cf + dh \end{bmatrix} $$

Determinant

$$ \det(A) = \begin{vmatrix} a & b \ c & d \end{vmatrix} = ad - bc $$

Calculus Examples

Derivative

$$ \frac{d}{dx} \left( x^n \right) = nx^{n-1} $$

Integral

$$ \int x^n dx = \frac{x^{n+1}}{n+1} + C \quad \text{for } n \neq -1 $$

Limit

$$ \lim_{x \to 0} \frac{\sin(x)}{x} = 1 $$

Statistics

Normal Distribution

$$ f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2}\left(\frac{x-\mu}{\sigma}\right)^2} $$

Standard Deviation

$$ \sigma = \sqrt{\frac{1}{N} \sum_{i=1}^{N} (x_i - \mu)^2} $$

Conclusion

These examples show how to properly format mathematical expressions in blog posts. Make sure to use the appropriate delimiters for inline ($...$) and block ($$...$$) math expressions.

Markdown Style Guide

BigWind — Mon, 01 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/markdown-style-guide/

Here is a sample of some basic Markdown syntax that can be used when writing Markdown content in Astro.

Headings

The following HTML <h1>—<h6> elements represent six levels of section headings. <h1> is the highest section level while <h6> is the lowest.

H1

H2

H3

H4

H5

H6

Paragraph

Xerum, quo qui aut unt expliquam qui dolut labo. Aque venitatiusda cum, voluptionse latur sitiae dolessi aut parist aut dollo enim qui voluptate ma dolestendit peritin re plis aut quas inctum laceat est volestemque commosa as cus endigna tectur, offic to cor sequas etum rerum idem sintibus eiur? Quianimin porecus evelectur, cum que nis nust voloribus ratem aut omnimi, sitatur? Quiatem. Nam, omnis sum am facea corem alique molestrunt et eos evelece arcillit ut aut eos eos nus, sin conecerem erum fuga. Ri oditatquam, ad quibus unda veliamenimin cusam et facea ipsamus es exerum sitate dolores editium rerore eost, temped molorro ratiae volorro te reribus dolorer sperchicium faceata tiustia prat.

Itatur? Quiatae cullecum rem ent aut odis in re eossequodi nonsequ idebis ne sapicia is sinveli squiatum, core et que aut hariosam ex eat.

Images

Syntax

![Alt text](./full/or/relative/path/of/image)

Output

Blockquotes

The blockquote element represents content that is quoted from another source, optionally with a citation which must be within a footer or cite element, and optionally with in-line changes such as annotations and abbreviations.

Blockquote without attribution

Syntax

> Tiam, ad mint andaepu dandae nostion secatur sequo quae.
> **Note** that you can use _Markdown syntax_ within a blockquote.

Output

Tiam, ad mint andaepu dandae nostion secatur sequo quae. Note that you can use Markdown syntax within a blockquote.

Blockquote with attribution

Syntax

> Don't communicate by sharing memory, share memory by communicating.<br>
> — <cite>Rob Pike[^1]</cite>

Output

Don't communicate by sharing memory, share memory by communicating.
— Rob Pike[^1]

[^1]: The above quote is excerpted from Rob Pike's talk during Gopherfest, November 18, 2015.

Tables

Syntax

| Italics   | Bold     | Code   |
| --------- | -------- | ------ |
| _italics_ | **bold** | `code` |

Output

Italics	Bold	Code
italics	bold	`code`

Code Blocks

Syntax

we can use 3 backticks ``` in new line and write snippet and close with 3 backticks on new line and to highlight language specific syntac, write one word of language name after first 3 backticks, for eg. html, javascript, css, markdown, typescript, txt, bash

```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N];
long long ans;
vector<int> v[N];
int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        v[i % k].push_back(a[i]);
    }
    for (int i = 0; i < k; i++)
        sort(v[i].rbegin(), v[i].rend());
    for (int i = 0; i < k; i++)
    {
        for (int j = 0; j + 1 < v[i].size(); j += 2)
        {
            ans += v[i][j] + v[i][j + 1];
        }
    }
    printf("%lld\n", ans);
    return 0;
}
```

Output

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N];
long long ans;
vector<int> v[N];
int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        v[i % k].push_back(a[i]);
    }
    for (int i = 0; i < k; i++)
        sort(v[i].rbegin(), v[i].rend());
    for (int i = 0; i < k; i++)
    {
        for (int j = 0; j + 1 < v[i].size(); j += 2)
        {
            ans += v[i][j] + v[i][j + 1];
        }
    }
    printf("%lld\n", ans);
    return 0;
}

List Types

Ordered List

Syntax

1. First item
2. Second item
3. Third item

Output

First item
Second item
Third item

Unordered List

Syntax

- List item
- Another item
- And another item

Output

List item
Another item
And another item

Nested list

Syntax

- Fruit
  - Apple
  - Orange
  - Banana
- Dairy
  - Milk
  - Cheese

Output

Fruit
- Apple
- Orange
- Banana
Dairy
- Milk
- Cheese

Other Elements

Syntax

<abbr title="Graphics Interchange Format">GIF</abbr> is a bitmap image format.

H<sub>2</sub>O

X<sup>n</sup> + Y<sup>n</sup> = Z<sup>n</sup>

Press <kbd>CTRL</kbd>+<kbd>ALT</kbd>+<kbd>Delete</kbd> to end the session.

Most <mark>salamanders</mark> are nocturnal, and hunt for insects, worms, and other small creatures.

Output

GIF is a bitmap image format.

H₂O

Xⁿ + Yⁿ = Zⁿ

Press CTRL+ALT+Delete to end the session.

Most salamanders are nocturnal, and hunt for insects, worms, and other small creatures.

Markdown Style Guide

BigWind — Mon, 01 Jul 2024 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/markdown-style-guide/

Here is a sample of some basic Markdown syntax that can be used when writing Markdown content in Astro.

Headings

The following HTML <h1>—<h6> elements represent six levels of section headings. <h1> is the highest section level while <h6> is the lowest.

H1

H2

H3

H4

H5

H6

Paragraph

Itatur? Quiatae cullecum rem ent aut odis in re eossequodi nonsequ idebis ne sapicia is sinveli squiatum, core et que aut hariosam ex eat.

Images

Syntax

![Alt text](./full/or/relative/path/of/image)

Output

Blockquotes

Blockquote without attribution

Syntax

> Tiam, ad mint andaepu dandae nostion secatur sequo quae.  
> **Note** that you can use _Markdown syntax_ within a blockquote.

Output

Tiam, ad mint andaepu dandae nostion secatur sequo quae.
Note that you can use Markdown syntax within a blockquote.

Blockquote with attribution

Syntax

> Don't communicate by sharing memory, share memory by communicating.<br>
> — <cite>Rob Pike[^1]</cite>

Output

Don't communicate by sharing memory, share memory by communicating.
— Rob Pike[^1]

[^1]: The above quote is excerpted from Rob Pike's talk during Gopherfest, November 18, 2015.

Tables

Syntax

| Italics   | Bold     | Code   |
| --------- | -------- | ------ |
| _italics_ | **bold** | `code` |

Output

Italics	Bold	Code
italics	bold	`code`

Code Blocks

Syntax

```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N];
long long ans;
vector<int> v[N];
int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        v[i % k].push_back(a[i]);
    }
    for (int i = 0; i < k; i++)
        sort(v[i].rbegin(), v[i].rend());
    for (int i = 0; i < k; i++)
    {
        for (int j = 0; j + 1 < v[i].size(); j += 2)
        {
            ans += v[i][j] + v[i][j + 1];
        }
    }
    printf("%lld\n", ans);
    return 0;
}
```

Output

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N];
long long ans;
vector<int> v[N];
int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        v[i % k].push_back(a[i]);
    }
    for (int i = 0; i < k; i++)
        sort(v[i].rbegin(), v[i].rend());
    for (int i = 0; i < k; i++)
    {
        for (int j = 0; j + 1 < v[i].size(); j += 2)
        {
            ans += v[i][j] + v[i][j + 1];
        }
    }
    printf("%lld\n", ans);
    return 0;
}

List Types

Ordered List

Syntax

1. First item
2. Second item
3. Third item

Output

First item
Second item
Third item

Unordered List

Syntax

- List item
- Another item
- And another item

Output

List item
Another item
And another item

Nested list

Syntax

- Fruit
  - Apple
  - Orange
  - Banana
- Dairy
  - Milk
  - Cheese

Output

Fruit
- Apple
- Orange
- Banana
Dairy
- Milk
- Cheese

Other Elements — abbr, sub, sup, kbd, mark

Syntax

<abbr title="Graphics Interchange Format">GIF</abbr> is a bitmap image format.

H<sub>2</sub>O

X<sup>n</sup> + Y<sup>n</sup> = Z<sup>n</sup>

Press <kbd><kbd>CTRL</kbd>+<kbd>ALT</kbd>+<kbd>Delete</kbd></kbd> to end the session.

Most <mark>salamanders</mark> are nocturnal, and hunt for insects, worms, and other small creatures.

Output

GIF is a bitmap image format.

H₂O

Xⁿ + Yⁿ = Zⁿ

Press CTRL+ALT+Delete to end the session.

Most salamanders are nocturnal, and hunt for insects, worms, and other small creatures.

Using MDX

BigWind — Sat, 02 Jul 2022 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/using-mdx/

This theme comes with the @astrojs/mdx integration installed and configured in your astro.config.mjs config file. If you prefer not to use MDX, you can disable support by removing the integration from your config file.

Why MDX?

MDX is a special flavor of Markdown that supports embedded JavaScript & JSX syntax. This unlocks the ability to mix JavaScript and UI Components into your Markdown content for things like interactive charts or alerts.

If you have existing content authored in MDX, this integration will hopefully make migrating to Astro a breeze.

Example

Here is how you import and use a UI component inside of MDX.
When you open this page in the browser, you should see the clickable button below.

Using MDX

BigWind — Sat, 02 Jul 2022 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/using-mdx/

Why MDX?

If you have existing content authored in MDX, this integration will hopefully make migrating to Astro a breeze.

Example

Here is how you import and use a UI component inside of MDX.
When you open this page in the browser, you should see the clickable button below.

CSDN新版Markdown编辑器(Alpha 2.0版) 使用示例

BigWind — Fri, 01 Jul 2022 00:00:00 GMT

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://bigwind.cn/blog/tutorial/welcome_to_use_csdn-markdown_editor_new/

import Kbd from "../../../components/mdx/Kbd.astro";

具体更新: CSDN 新版 Markdown 编辑器（Alpha 2.0 版）使用须知-CSDN 论坛 https://bbs.csdn.net/topics/392449440

@TOC

欢迎使用 Markdown 编辑器

你好！这是你第一次使用 Markdown 编辑器 所展示的欢迎页。如果你想学习如何使用 Markdown 编辑器, 可以仔细阅读这篇文章，了解一下 Markdown 的基本语法知识。

新的改变

我们对 Markdown 编辑器进行了一些功能拓展与语法支持，除了标准的 Markdown 编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX 数学公式 语法；
增加了支持甘特图的 mermaid 语法[^1] 功能；
增加了 多屏幕编辑 Markdown 文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。 [^1]: mermaid 语法说明

功能快捷键

撤销：Ctrl/Command + Z

重做：Ctrl/Command + Y

加粗：Ctrl/Command + Shift + B

斜体：Ctrl/Command + Shift + I

标题：Ctrl/Command + Shift + H

删除线：Ctrl/Command + Shift + S

无序列表：Ctrl/Command + Shift + U

有序列表：Ctrl/Command + Shift + O

检查列表：Ctrl/Command + Shift + C

插入代码：Ctrl/Command + Shift + K

插入链接：Ctrl/Command + Shift + L

插入图片：Ctrl/Command + Shift + G

合理的创建标题，有助于目录的生成

直接输入 1 次#，并按下space后，将生成 1 级标题。输入 2 次#，并按下space后，将生成 2 级标题。以此类推，我们支持 6 级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

==标记文本==

~~删除文本~~

引用文本

H2O is 是液体。

2^10^ 运算结果是 1024.

插入链接与图片

链接: link.

图片:

带尺寸的图片: ![Alt](https://avatar.csdn.net/7/7/B/1_ralf_hx163com.jpg =30x30)

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = "bar";

生成一个适合你的列表

项目
- 项目
  - 项目

项目 1
项目 2
项目 3

计划任务
完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中

使用:----------居左

使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants 将 ASCII 标点字符转换为“智能”印刷标点 HTML 实体。例如：

TYPE	ASCII	HTML
Single backticks	`'Isn't this fun?'`	'Isn't this fun?'
Quotes	`"Isn't this fun?"`	"Isn't this fun?"
Dashes	`-- is en-dash, --- is em-dash`	-- is en-dash, --- is em-dash

创建一个自定义列表

Markdown : Text-to-HTML conversion tool

Authors : John : Luke

如何创建一个注脚

一个具有注脚的文本。^2

注释也是必不可少的

Markdown 将文本转换为 HTML。

*[HTML]: 超文本标记语言

KaTeX 数学公式

您可以使用渲染 LaTeX 数学表达式 KaTeX:

Gamma 公式展示 $\Gamma(n) = (n-1)!\quad\forall n\in\mathbb N$ 是通过欧拉积分

$$ \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt,. $$

你可以找到更多关于的信息 LaTeX 数学表达式[here][1].

新的甘特图功能，丰富你的文章

gantt
        dateFormat  YYYY-MM-DD
        title Adding GANTT diagram functionality to mermaid
        section 现有任务
        已完成               :done,    des1, 2014-01-06,2014-01-08
        进行中               :active,  des2, 2014-01-09, 3d
        计划一               :         des3, after des2, 5d
        计划二               :         des4, after des3, 5d

关于 甘特图 语法，参考 [这儿][2],

UML 图表

可以使用 UML 图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:

sequenceDiagram
张三 ->> 李四: 你好！李四, 最近怎么样?
李四-->>王五: 你最近怎么样，王五？
李四--x 张三: 我很好，谢谢!
李四-x 王五: 我很好，谢谢!
Note right of 王五: 李四想了很长时间, 文字太长了<br/>不适合放在一行.

李四-->>张三: 打量着王五...
张三->>王五: 很好... 王五, 你怎么样?

这将产生一个流程图。:

graph LR
A[长方形] -- 链接 --> B((圆))
A --> C(圆角长方形)
B --> D{菱形}
C --> D

关于 Mermaid 语法，参考 [这儿][3],

FLowchart 流程图

我们依旧会支持 flowchart 的流程图：

flowchat
st=>start: 开始
e=>end: 结束
op=>operation: 我的操作
cond=>condition: 确认？

st->op->cond
cond(yes)->e
cond(no)->op

关于 Flowchart 流程图 语法，参考 [这儿][4].

🧊 BigWind's Blog

3月6日小杂感

Adding Comment Systems to Frosti

Introduction

Creating Comment Components in Astro

Component Structure

Integrating Waline

Step 1: Set Up Waline Backend

Step 2: Create the Waline Component

Step 3: Using the Waline Component

Troubleshooting

Common Issues

随笔 虚拟生命

结尾

自由在两种文化环境下的核心

在西方

在东方的起源和变迁

自由在西方的阶级性变化

结语

What is Const in CPP

作用

const 的指针与引用

const 的判断技巧

复杂度分析复习笔记

算法效率评估

实际测试

理论估算

迭代与递归

迭代

递归

对比

时间复杂度

常见类型

空间复杂度

Q & A

参考

开启Windows自带剪切板

为什么要使用剪切板

开启剪贴板

键位介绍

结语

如何测试自建邮箱的得分

推荐测试网站

测试步骤

向测试邮箱发信

点击 查看你的邮件得分

等待结果

结语

见近日青海路虎女逆行打人事件有感

事件起由

疑点

罗翔老师推崇的幸福者退让原则

什么是幸福者退让原则

谁幸福？

在实际生活中，往往是“不幸福”的人退让

“幸福”永远都是斗争出来的

改革到了“闯险滩，涉难关”的硬仗

结语

使用Lark企业邮箱服务启用自定义域名邮箱

什么是自定义域名邮箱？

为什么要有一个自定义域名邮箱

为什么要用Lark企业邮箱

使用步骤

点击Lark官网注册账号

点击 管理后台

选择 产品设置-邮箱

选择 开始设置

配置域名邮箱后缀

选择 立即验证 通过后点击 下一步

选择 立即配置

选择自己的账号 配置后点击保存

设置 公共邮箱

保存后 再次点击 编辑 即可看到 IMAP/SMTP 服务参数

开启 DMARC

选择需要启用 DKIM 的域名，点击 启用

使用默认2048 密钥长度

到域名服务商设置域名解析增加TXT记录，添加完之后，点击立即验证

验证成功后的效果

如何在第三方邮箱平台使用

管理员账号开启第三方登录(默认)

随笔虚拟生命

点击查看你的邮件得分

点击管理后台

选择产品设置-邮箱

选择开始设置

选择立即验证通过后点击下一步

选择立即配置

选择自己的账号配置后点击保存

设置公共邮箱

保存后再次点击编辑即可看到 IMAP/SMTP 服务参数

选择需要启用 DKIM 的域名，点击启用

点击邮箱

输入你的域名邮箱点击继续

添加成功后你的所有域名邮箱都会发给你的接收邮箱

第一步、从Cloudflare主页选择你的域名，进入到域名功能界面

第二步，展开左侧菜单，点击`规则`——`页面规则`，进入页面规则设置页面

第三步、点击`创建页面规则`按钮，一共添加3条规则，如下

第二步、展开左侧菜单，点击`缓存`——`Cache Rules`，进入缓存规则设置页面

第三步、点击`创建规则`按钮，添加1条规则，如下

方法一：可以在界面中添加多个`Or`字段，表示符合其中任何一种就行。

方法二、因为静态资源的类型比较多，也可以直接点击`编辑表达式`，把下面的内容直接粘贴进去即可

第四步、其他设置