C++模拟实现-----日期计算器（超详细解析，小白一看就会！）

news2024/9/24 1:26:01

目录

一、前言

 二、日期类计算器

 三、日期计算器的实现

🍎日期计算器各个接口的实现

🍐日期计算器的需求 

 🍉打印当前日期（并检查日期是否合理）

 💦检查日期是否合理

 💦日期类构造函数（用于日期的初始化）

 ⭐效果展示

 🍓日期之间的大小比较

 💦<  运算符重载

 💦== 运算符重载

 💦<= 运算符重载

 💦>  运算符重载

 💦>= 运算符重载

 💦!= 运算符重载

 ⭐效果展示

🍌日期的加减天数计算 

 💦日期 + 天数

 💦日期 + = 天数

💦 日期 -= 天数

💦日期 - 天数 

 💦日期 前置++

  💦日期 后置++

 💦日期 前置--

 💦日期 后置--

 ⭐效果展示

 🍊日期与日期之间的减法运算

 💦日期 - 日期

 ⭐效果展示

 四、日期计算器的完整代码

🍇Date.h 

🍋Date.cpp 

🥝Test.cpp

 🍍代码运行的界面

 五、共勉

一、前言

        在之前的博客学习中，我们已经详细的讲解了C++中的引用、缺省函数、this指针、构造函数、析构函数、拷贝构造函数、运算符重载等非常重要的知识，但是对于这些知识如何如何的使用还没有进行讲解，所以本次博客将以日期计算器为例，将以上知识融合起来讲解，帮助大家更好的理解。

 二、日期类计算器

        在我们的日常生活中，我们可能需要计算几天后的日期，或计算日期差等，现如今计算日期的方式有很多，简单粗暴的直接查看日历，快捷点的直接使用日期计算器来求得，先给一个网络上的日期计算器截图：

        现在，就让我们用代码来实现其工作原理吧。

 三、日期计算器的实现

🍎日期计算器各个接口的实现

 这里先建立三个文件：
1️⃣ ：Date.h文件，用于类中---函数声明
2️⃣ ：Date.cpp文件，用于类中---函数的定义
3️⃣ ：Test.cpp文件，用于测试函数
建立三个文件的目的： 将日期计算器作为一个项目来进行书写，方便我们的学习与观察。

🍐日期计算器的需求 

这里我们需要考虑，我们实现的这个日期计算器，需要实现怎样的需求呢？

  1. 需要打印当前的日期（请检查日期是否合理）
  2. 实现日期之间的大小比较
  3. 实现日期的加减天数计算
  4. 实现日期与日期之间的减法运算

 🍉打印当前日期（并检查日期是否合理）

        实现日期类首先就得检查日期的合法性，这其中就包括大小月，闰年的2月有29天，一年只有12个月等等细节都要考虑到。

 💦检查日期是否合理

//判断是否为闰年
bool Date::isLeaveYear(int year)
{
	// （四年一润，百年不润） 或者 四百年一润
	return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// 获取每个月的天数
int Date::GetMonthDay(int year, int month)
{
	int monthday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && isLeaveYear(year))
	{
		return 29;
	}
	else
	{
		return monthday[month];
	}
}

 💦日期类构造函数（用于日期的初始化）

//判断是否为闰年
bool Date::isLeaveYear(int year)
{
	// （四年一润，百年不润） 或者 四百年一润
	return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// 获取每个月的天数
int Date::GetMonthDay(int year, int month)
{
	int monthday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && isLeaveYear(year))
	{
		return 29;
	}
	else
	{
		return monthday[month];
	}
}

 ⭐效果展示

1️⃣：错误的日期演示   ------  -1 / -1 / -1 （年/月/日）

// 测试初始化
void Test()
{
	Date d1(-1,-1,-1);
	d1.Printf();
}
int main()
{
	Test();
	return 0;
}


1️⃣：正确的日期演示  --------  2023 / 10 / 28 （年/月/日）

// 测试初始化
void Test()
{
	cout << "请输入今日的日期" << endl;
	Date d1(2023,10,28);
	d1.Printf();
}
int main()
{
	Test();
	return 0;
}

 🍓日期之间的大小比较

 💦<  运算符重载

  • 思路：

< 运算符重载在我上一篇博文已经详细讲解过，主要是先把大于的情况全部统计出来，就比如我要比较实例化对象d1是否小于实例化对象d2，只需考虑如下三种满足的情况：

  • d1的年小于d2的年
  • d1与d2年相等，d1的月小于d2的月
  • d1与d2年相等月相等，d1的天小于d2的天

这三种全是小于的情况，返回true，其余返回false

  • 代码如下：
// "<" 运算符重载
bool Date::operator<(const Date& d)
{
	if (_year < d._year ||
		_year == d._year && _month < d._month ||
		_year == d._year && _month == d._month && _day < d._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}

 💦== 运算符重载

  •  思路：

 == 运算符重载其实非常简单，只需要判断d1和d2的年、月、天是否对应相等即可：

  • 代码如下：
// "==" 运算符重载
bool Date::operator==(const Date& d)
{
	return _year == d._year && _month == d._month && _day == d._day;
}

 💦<= 运算符重载

  • 思路： --  复用 (这里复用的意思是：用之前写好的运算符重载，可以减少我们的代码量)

<= 的运算符重载，这里要仔细想一想 <= 成立的条件是啥。不就是 要么 < 要么 = 吗？我们只需要复用先前写的 < 运算符重载和 <=运算符重载，无需自己费老大劲推导其内部原理。

  • 代码如下：
// "<=" 运算符重载
bool Date::operator<=(const Date& d)
{
	// 运算符重载的复用
	return *this < d || *this == d;
}

 💦>  运算符重载

  • 思路： --  复用

> 的反义就是 <=，所以我们只需要复用 <= 运算符重载，再对其取反即可解决此问题。

  • 代码如下：
// ">" 运算符重载
bool Date::operator>(const Date& d)
{
	return !(*this <= d);
}

 💦>= 运算符重载

  • 思路： --  复用

>= 的反义就是 <，所以我们只需要复用 < 运算符重载，再对其取反即可。

  • 代码如下：
// ">="运算符重载、
bool Date::operator>=(const Date& d)
{
	return !(*this < d);
}

 💦!= 运算符重载

  • 思路： --  复用

有了前面的基础，写个 != 也很简单，对 == 取反即可

  • 代码如下：
//"!="运算符重载
bool Date::operator!=(const Date& d)
{
	return !(*this == d);
}

 ⭐效果展示

此时我们拿   "<"运算符   举例子

// 测试"<"运算符
void Test1()
{
	Date d1(2023,10,28);
	cout << "d1的日期为：";
	d1.Printf();
	cout << "d2的日期为：";
	Date d2(2023, 10, 27);
	d2.Printf();
	cout << endl;
	if (d2 < d1)
	{
		cout << "d1的日期 < d2的日期" << endl;
	}
	else
	{
		cout << "d2的日期 > d1的日期" << endl;
	}
}

int main()
{
	Test1();
	return 0;
}

🍌日期的加减天数计算 

 💦日期 + 天数

  • 思路：

对于日期 + 天数，我们得到的还是一个日期。特别需要注意进位的问题（天满了往月进，月满了往年进），主要考虑如下几个特殊点：

  • 加过的天数超过该月的最大天数，需要进位
  • 当月进位到13时，年进位+1，月置为1

  • 法一：
Date Date::operator+(int day) 
{
	Date ret(*this); //拷贝构造，拿d1去初始化ret
	ret._day += day;
	while (ret._day > GetMonthDay(ret._year, ret._month))
	{
		ret._day -= GetMonthDay(ret._year, ret._month);
		ret._month++;
		if (ret._month == 13)
		{
			ret._year++;
			ret._month = 1;
		}
	}
	return ret;
}

        出了作用域，对象ret不在，它是一个局部对象，我们这里不能用引用，用了的话，返回的就是ret的别名，但是ret又已经销毁了，访问野指针了，所以出了作用域，如果对象不在了，就不能用引用返回，要用传值返回

  • 法二：复用日期+=天数

此法是建立在日期+=天数的基础上完成的，这里各位可以先看下文日期+=天数，然后我们进行复用：

Date Date::operator+(int day) 
{
	//法二：复用日期 += 天数
	Date ret(*this);
	ret += day;
	return ret;
}
  • 法一和法二熟优？

答案：法二更好，也就是用+去复用+=，具体原因在下文会解释。
 

 💦日期 + = 天数

 这里实现 += 其实有两种方案

  • 法一：

前面我实现的日期+天数，仔细观察我的代码，函数的第一行，我就调用了一个拷贝构造：

Date ret(*this); //拷贝构造，拿d1去初始化ret

        这里调用拷贝构造，是为了不在*this本身上做变动，只在ret上进行操作，其理由是日期+天数得到的是另一个日期，而不用拷贝构造直接在*this上做改动只会导致原有的日期也变化，而这个变化正是我日期 += 天数的需求

        仔细想想：+=天数就是在原有的日期上再加一定的天数，直接对*this做手脚即可，因此只需对日期+天数的代码进行小改动即可：

Date& Date::operator+=(int day) //传引用返回
{
	//如果day小于0，要单独处理
	if (day < 0)
	{
		return *this -= -day;
	}
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;
}

注意这里是传引用返回，原因就在于我返回的*this是全局的，出了作用域还在
 

  • 法二：复用日期 +天数
Date& Date::operator+=(int day)
{
	//法二：复用
	* this = *this + day; //让d1+过天数后再返回给自己从而实现+=
	return *this;
}
  • 法一和法二熟优？

答案：法一。其实讨论这个问题就是在讨论用+去复用+=好还是用+=复用+好，答案是用+=去复用+好，因为+有两次拷贝，而+=没有拷贝，所以实现+，并且用+=去复用+效率更高
 

💦 日期 -= 天数

  • 思路：

日期-=天数得到的还是一个日期，且是在原日期的基础上做改动。合法的日期减去天数后的day只要>0就没问题，若小于0就要借位了。要注意当减去的天数<0时单独讨论。具体步骤如下：

  1. 当减的天数为负数，则为+=，直接调用
  2. 若减后的day<0，月-1
  3. 若月 = 0，则年-1，月置为12

 
  • 代码如下：
// 日期-= 天数 ：d1 d1 - 100
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += (-day);
	}
	_day -= day;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

💦日期 - 天数 

有了先前日期+和+=的基础，这里实现日期 - 天数直接复用日期 -= 天数即可：

// 日期-天数 ： d1 - 100
Date Date::operator-(int day)
{
	// 调用拷贝构造
	Date temp(*this);
	// 复用 "-="
	temp -= day;
	return temp;
}

 💦日期 前置++

  • 思路：

        C++里有前置++和后置++，这就导致一个巨大的问题，该如何区分它们，具体实现过程不难（直接复用+=即可），难的是如何区分前置和后置。因此C++规定，无参的为前置，有参的为后置。

  • 代码如下：
// 前置++ （无参的为前置，有参的为后置）
Date& Date::operator++()
{
	// 直接复用 +=
	*this += 1;
	return *this;
}

  💦日期 后置++

  • 思路：

        有参的即为后置，后置++拿到的返回值应该是自己本身未加过的，因此要先把自己保存起来，再++*this，随后返回自己。

  • 代码如下：
// 后置++（无参的为前置，有参的为后置）
// int i 这里的形参可以写，可以不写
Date Date::operator++(int i)
{
	Date temp(*this);
	*this += 1;
	return temp;
}

 💦日期 前置--

  • 思路：

前置--和前置++没啥区别，只不过内部复用的是-=

  • 代码如下：
// 前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}

 💦日期 后置--

  • 思路：

后置--和后置++类似，只不过内部复用的是-=，不再赘述

  • 代码如下：
//后置--
Date Date::operator--(int i)
{
	Date temp(*this);
	*this -= 1;
	return temp;
}

 ⭐效果展示

 举例：将日期 + 100 天  ：2023 / 10 / 28  + 100

// d1+=100 测试
void Test3()
{
	Date d1(2023, 10, 28);
	cout << "d1的日期为：";
	d1.Printf();
	cout << endl;
	d1 += 100;
	cout << "d1的日期+100为：";
	d1.Printf();
}

int main()
{
	Test3();
	return 0;
}

 🍊日期与日期之间的减法运算

 💦日期 - 日期

  • 思路：

       日期 - 日期得到的是天数，首先我们得判断两个日期的大小，用min和max代替小的和大的，随后，算出min和max之间的差距，若min!=max，则min就++，随即定义变量n也自增++，最后返回n（注意符号）

  • 代码如下：
// 日期 - 日期
int Date::operator-(const Date& d)
{
	// 方便后续计算正负
	int flag = 1;
	Date max = *this;
	Date min = d;
	// 确保max是大的  min是小的
	if (*this < d)
	{
		min = *this;
		max = d;
		flag = -1;  //计算正负
	}
	int n = 0;
	// 计算min和max之间的绝对值差距
	while (min != max)
	{
		min++;
		n++;
	}
	return n * flag;
}

 ⭐效果展示

 举例：计算 2023 / 10 /28  -------------   2023  / 11 / 11  的天数差距 

// 日期 - 日期
void Test4()
{
	Date d1(2023, 11, 11);
	cout << "d1的日期为：";
	d1.Printf();
	cout << "d2的日期为：";
	Date d2(2023, 10, 28);
	d2.Printf();
	cout << endl;
	cout << "d1与d2之间的天数差距为：";
	int ret = d1 - d2;
	cout << ret << endl;

}

int main()
{
	Test4();
	return 0;
}

 四、日期计算器的完整代码

🍇Date.h 

#pragma once
#include <iostream>
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
using std::cout;
using std::cin;
using std::endl;

class Date
{
public:
	// 构造函数用于初始化 -- 声明 
	// 在声明中缺省函数需要 写清楚  在定义中缺省函数就不要写了 防止编译器分不清
	Date(int year = 1, int month = 1, int day = 1);

	//判断是否为闰年
	bool isLeaveYear(int year);
	
	// 获取每个月的天数
	int GetMonthDay(int year, int month);
	
	// 打印
	void Printf();

	// "<" 运算符重载
	bool operator<(const Date& d);

	// "==" 运算符重载
	bool operator==(const Date& d);

	// "<=" 运算符重载
	bool operator<=(const Date& d);

	// ">" 运算符重载
	bool operator>(const Date& d);

	// ">="运算符重载、
	bool operator>=(const Date& d);

	//"!="运算符重载
	bool operator!=(const Date& d);

	
	// 日期+= 天数: d1 = d1 + 100
	Date& operator+= (int day);

	// 日期 + 天数 d1+100  d1不变
	Date operator+(int day);

	// 日期-= 天数 ：d1 = d1 - 100
	Date& operator-=(int day);

	// 日期-天数 ： d1 - 100
	Date operator-(int day);

	// 前置++ （无参的为前置，有参的为后置）
	Date& operator++();

	// 后置++（无参的为前置，有参的为后置）
	Date operator++(int i);
	
	// 前置--
	Date& operator--();

	//后置--
	Date operator--(int i);

	// 日期 - 日期
	int operator-(const Date& d);
private:
	int _year;
	int _month;
	int _day;
};

🍋Date.cpp 

#define  _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"

// 构造函数用于初始化
Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
	if (_year < 1 || _month < 1 || _month>12 || _day<1 || _day>GetMonthDay(_year, _month))
	{
		assert(false);
	}
}

//判断是否为闰年
bool Date::isLeaveYear(int year)
{
	// （四年一润，百年不润） 或者 四百年一润
	return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// 获取每个月的天数
int Date::GetMonthDay(int year, int month)
{
	int monthday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && isLeaveYear(year))
	{
		return 29;
	}
	else
	{
		return monthday[month];
	}
}

void Date::Printf()
{
	cout << _year << " / " << _month << " / " << _day << endl;
}

// "<" 运算符重载
bool Date::operator<(const Date& d)
{
	if (_year < d._year ||
		_year == d._year && _month < d._month ||
		_year == d._year && _month == d._month && _day < d._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}

// "==" 运算符重载
bool Date::operator==(const Date& d)
{
	return _year == d._year && _month == d._month && _day == d._day;
}

// "<=" 运算符重载
bool Date::operator<=(const Date& d)
{
	// 运算符重载的复用
	return *this < d || *this == d;
}

// ">" 运算符重载
bool Date::operator>(const Date& d)
{
	return !(*this <= d);
}

// ">="运算符重载、
bool Date::operator>=(const Date& d)
{
	return !(*this < d);
}

//"!="运算符重载
bool Date::operator!=(const Date& d)
{
	return !(*this == d);
}

// 日期+= 天数: d1 = d1 + 100
Date& Date::operator+=(int day)
{
	// 防止传入的天数为 负数（-100）
	if (day < 0)
	{
		return *this -= (-day);
	}
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;
}

// 日期 + 天数 d1+100  d1不变
Date Date::operator+(int day)
{
	// 调用拷贝构造
	Date temp(*this);
	temp += day;
	return temp;
}

// 日期-= 天数 ：d1 d1 - 100
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += (-day);
	}
	_day -= day;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

// 日期-天数 ： d1 - 100
Date Date::operator-(int day)
{
	// 调用拷贝构造
	Date temp(*this);
	// 复用 "-="
	temp -= day;
	return temp;
}

// 前置++ （无参的为前置，有参的为后置）
Date& Date::operator++()
{
	// 直接复用 +=
	*this += 1;
	return *this;
}

// 后置++（无参的为前置，有参的为后置）
// int i 这里的形参可以写，可以不写
Date Date::operator++(int i)
{
	Date temp(*this);
	*this += 1;
	return temp;
}

// 前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}

//后置--
Date Date::operator--(int i)
{
	Date temp(*this);
	*this -= 1;
	return temp;
}

// 日期 - 日期
int Date::operator-(const Date& d)
{
	// 方便后续计算正负
	int flag = 1;
	Date max = *this;
	Date min = d;
	// 确保max是大的  min是小的
	if (*this < d)
	{
		min = *this;
		max = d;
		flag = -1;  //计算正负
	}
	int n = 0;
	// 计算min和max之间的绝对值差距
	while (min != max)
	{
		min++;
		n++;
	}
	return n * flag;
}

🥝Test.cpp

#define  _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"

// 测试初始化
void Test()
{
	cout << "请输入今日的日期" << endl;
	Date d1(2023,10,28);
	d1.Printf();
}

// 测试"<"运算符
void Test1()
{
	Date d1(2023,10,28);
	cout << "d1的日期为：";
	d1.Printf();
	cout << "d2的日期为：";
	Date d2(2023, 10, 27);
	d2.Printf();
	cout << endl;
	if (d2 < d1)
	{
		cout << "d1的日期 < d2的日期" << endl;
	}
	else
	{
		cout << "d2的日期 > d1的日期" << endl;
	}
}

// d1 + 100 测试
void Test2()
{
	Date d1(2023,10,27);
	cout << "d1的日期为：";
	d1.Printf();
	Date d2;
	d2 = d1 + 100;
	cout << "d1的日期+100为：";
	d2.Printf();
}

// d1+=100 测试
void Test3()
{
	Date d1(2023, 10, 28);
	cout << "d1的日期为：";
	d1.Printf();
	cout << endl;
	d1 += 100;
	cout << "d1的日期+100为：";
	d1.Printf();
}

// 日期 - 日期
void Test4()
{
	Date d1(2023, 11, 11);
	cout << "d1的日期为：";
	d1.Printf();
	cout << "d2的日期为：";
	Date d2(2023, 10, 28);
	d2.Printf();
	cout << endl;
	cout << "d1与d2之间的天数差距为：";
	int ret = d1 - d2;
	cout << ret << endl;

}

void Test5()
{

	cout << " ***********   欢迎来到  日期计算器   ***********" << endl<<endl;
	cout << "输入今日的日期: >" ;
	int y, m, d;
	cin >> y >> m >> d;
	cout << endl;
	Date d1(y, m, d);
	//d1.Printf();
	cout << "输入需要对比的日期: >";
	int y1, m1, dd;
	cin >> y1 >> m1 >> dd;
	cout << endl;
	Date d2(y1, m1, dd);
	//d2.Printf();
	cout << "两个日期之间的天数差距为：";
	int ret = d - dd;
	cout << ret << endl;
}

int main()
{
	Test5();
	return 0;
}

 🍍代码运行的界面

 五、共勉

  以下就是我对C++日期计算器的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对C++ 类和对象的理解，请持续关注我哦！！！  

 

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

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

相关文章

操作系统 (1)

操作系统 (1)

进程的概念 进程同步/进程互斥 进程互斥的软件实现 进程互斥的硬件实现 信号量机制 生产者消费者问题 以下wei8最终情况,不可调换位置,否则会发生死锁 预防死锁 避免死锁
阅读更多...
剖析C语言中的自定义类型（结构体、枚举常量、联合）兼内存对齐与位段

剖析C语言中的自定义类型（结构体、枚举常量、联合）兼内存对齐与位段

目录 前言 一、结构体 1. 基本定义与使用 2. 内存对齐 3. 自定义对齐数 4. 函数传参 二、位段 三、枚举 四、联合&#xff08;共同体&#xff09; 总结​​​​​​​ 前言 本篇博客将介绍C语言中的结构体&#xff08;struct&#xff09;、枚举&#xff08;enum&…
阅读更多...
YOLOv8改进之C2f模块融合CVPR2023 SCConv

YOLOv8改进之C2f模块融合CVPR2023 SCConv

目录 1. SCConv SCConv模块的设计 SCConv模块的性能 2. YOLOv8 C2f融合SCConv模块 1. SCConv 卷积在各种计算机视觉任务中表现出色&#xff0c;但是由于卷积层提取冗余特征&#xff0c;其计算资源需求巨大。虽然过去用于改善网络效率的各种模型压缩策略和网络设计&#xff0c…
阅读更多...
C++前缀和算法的应用：使数组相等的最小开销

C++前缀和算法的应用：使数组相等的最小开销

本文涉及的基础知识点 C算法&#xff1a;前缀和、前缀乘积、前缀异或的原理、源码及测试用例 包括课程视频 题目 给你两个下标从 0 开始的数组 nums 和 cost &#xff0c;分别包含 n 个 正 整数。 你可以执行下面操作 任意 次&#xff1a; 将 nums 中 任意 元素增加或者减小…
阅读更多...
PCL 半径滤波剔除噪点

PCL 半径滤波剔除噪点

目录 一、算法原理二、注意事项三、代码实现一、算法原理 PCL半径滤波是删除在输入的点云一定范围内没有达到足够多领域的所有数据点。通俗的讲：就是以一个点p给定一个范围r，领域点要求的个数为m，r若在这个点的r范围内部的个数大于m则保留，小于m则删除。因此，使用该算法时…
阅读更多...
arduino抢答器

arduino抢答器

按键传感器 &#xff1a; 1&#xff0c;如果按键传感器没有按下 他返回的值是1 2&#xff0c;如果按下 返回的值为0逻辑运算符有两种状态 True False 如果返回的是数字 0代表Fales 非0代表True 了解 比较运算和逻辑运算 如果两个传感器同时按下两个小灯才会亮 只要其中一…
阅读更多...
【Android知识笔记】热修复专题

【Android知识笔记】热修复专题

Android类加载与双亲委派知识回顾 Android 中的 ClassLoader 继承关系： 双亲委派模型： 在 Android 系统中，应用程序中默认的 ClassLoader 是 PathClassLoader 对象，即通过Context.getClassLoader()获取到的是一个 PathClassLoader 对象，而 PathClassLoader 对象的parent是…
阅读更多...
[AUTOSAR][诊断管理][ECU][$22] 读取相关的数据

[AUTOSAR][诊断管理][ECU][$22] 读取相关的数据

文章目录 一、简介$22服务的实际用途是什么？$22服务的应用场景有哪些呢？$22服务的诊断格式如何？常见DID总结请求实例服务响应负响应NRCNRC优先级二、示例代码uds22_read_data_by_ld.c一、简介 22服务作为诊断服务种的基础服务，可以简单理解为就是一个用于读取ECU数据的外部…
阅读更多...
Redis（05）| 数据结构-哈希表

Redis（05）| 数据结构-哈希表

哈希表是一种保存键值对&#xff08;key-value&#xff09;的数据结构。 哈希表中的每一个 key 都是独一无二的&#xff0c;程序可以根据 key 查找到与之关联的 value&#xff0c;或者通过 key 来更新 value&#xff0c;又或者根据 key 来删除整个 key-value等等。 在讲压缩列表…
阅读更多...
【torch高级】一种新型的概率学语言pyro（01/2）

【torch高级】一种新型的概率学语言pyro（01/2）

一、说明 贝叶斯推理&#xff0c;也就是变分概率模型估计&#xff0c;属于高级概率学模型&#xff0c;极有学习价值&#xff1b;一般来说&#xff0c;配合实际活动学习可能更直观&#xff0c;而pyro是pytorch的概率工具&#xff0c;不同于以往的概率工具&#xff0c;只是集中于…
阅读更多...
【咕咕送书 | 第四期】《ChatGPT 驱动软件开发：AI 在软件研发全流程中的革新与实践》

【咕咕送书 | 第四期】《ChatGPT 驱动软件开发：AI 在软件研发全流程中的革新与实践》

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏:《粉丝福利》 《C语言进阶篇》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 文章目录 ⛳️ 写在前面参与规则一、前言1.0 人工智能新技术如何创新工作 &#xff1f; 二、内容简介三、作者简介四、专家推…
阅读更多...
Makefile三个版本的编写

Makefile三个版本的编写

1.Makefile Makefile是一个工程管理文件&#xff0c;简化编译的流程&#xff0c;完成自动化编译的过程 在Makefile中&#xff0c;会把编译的过程分为两步&#xff0c;先生成.o文件&#xff0c;再对.o文件链接&#xff0c;生成可执行文件 Makefile由变量、函数、和规则构成 2.引…
阅读更多...
Linux 系统调用IO口，利用光标偏移实现文件复制

Linux 系统调用IO口，利用光标偏移实现文件复制

用系统调用IO函数实现从一个文件读取最后2KB数据并复制到另一个文件中&#xff0c;源文件以只读方式打开&#xff0c;目标文件以只写的方式打开&#xff0c;若目标文件不存在&#xff0c;可以创建并设置初始值为0664&#xff0c;写出相应代码&#xff0c;要对出错情况有一定的处…
阅读更多...
从入门到精通Ansible Playbook，一篇就够了

从入门到精通Ansible Playbook，一篇就够了

Playbook 一、Host Inventory(主机清单)1.1 简介1.2 inventory 文件1.2 inventory 中的变量 二、Playbook 剧本2.1 简介2.2 Playbook的组成部分2.3 如何编写Playbook&#xff1f;2.3.1 基本格式2.3.2 语句的横向/纵向写法 三、Playbook实例和知识点补充3.1 编写yum安装nginx的p…
阅读更多...
si24r1/nrf24l01

si24r1/nrf24l01

Si24R1 可配置为 Shutdown、 Standby、 Idle-TX、 TX 和 RX 五种工作模式。 芯片上电后为shutdown模式。此模式下不可以通过芯片收发数据&#xff0c;但MCU和芯片可以通过spi协议通信&#xff0c;更改内部寄存器的状态&#xff08;如设置 CONFIG 寄存器下的 PWR_UP 位的值为 1&…
阅读更多...
Java练习题2020 -1

Java练习题2020 -1

统计1到N的整数中&#xff0c;被A除余A-1的偶数的个数 输入说明&#xff1a;整数 N(N<10000), A, (A 输出说明&#xff1a;符合条件的数的个数 输入样例&#xff1a;10 3 输出样例&#xff1a;2 (说明&#xff1a;样例中符合条件的2个数是 2、8) import java.util.Scanner;p…
阅读更多...
Java SE 学习笔记（十四）—— IO流（3）

Java SE 学习笔记（十四）—— IO流（3）

目录 1 缓冲流1.1 缓冲流概述1.2 字节缓冲流1.3 字符缓冲流 2 转换流2.1 字符输入转换流2.1 字符输出转换流 3 序列化3.1 对象序列化3.2 对象反序列化 4 打印流5 与Properties结合使用6 IO 框架 1 缓冲流 1.1 缓冲流概述 我们之前学习的字节流、字符流属于基础流、原始流&…
阅读更多...
引流大法，助你销量翻倍！亚马逊新卖家必备的六种流量来源！

引流大法，助你销量翻倍！亚马逊新卖家必备的六种流量来源！

作为亚马逊的一个新卖家&#xff0c;我们在新店上传产品之后&#xff0c;第一个目标就是引流&#xff0c;因为流量是支撑店铺销量的重要环节&#xff0c;那么我们引流的方式都有哪些呢&#xff1f; ​首先我们要知道亚马逊的一些流量来源分别有哪几块&#xff01; 一、平台自…
阅读更多...
计算机网络重点概念整理-第五章 传输层【期末复习|考研复习】

计算机网络重点概念整理-第五章 传输层【期末复习|考研复习】

第五章 传输层 【期末复习|考研复习】 计算机网络系列文章传送门&#xff1a; 第一章 计算机网络概述 第二章 物理层 第三章 数据链路层 第四章 网络层 第五章 传输层 第六章 应用层 第七章 网络安全 计算机网络整理-简称&缩写 文章目录 第五章 传输层 【期末复习|考研复习…
阅读更多...
通过宏定义解决编程难题

通过宏定义解决编程难题

大家好&#xff0c;我们今天来通过我们的define定义宏解决C语言上的难题。 实例一&#xff1a; offsetof这个宏我们在学习结构体的时候就已经了解过了&#xff0c;这个宏是我们在计算结构体大小的时候来查看每个结构体成员的偏移量的&#xff0c;那么我们在这里就来模拟实现一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023