【C++复习】C++11经典语法

news2024/10/3 22:41:50

文章目录

  • {}列表初始化
      • 1. 初始化内置类型变量
      • 2. 初始化数组
      • 3. 初始化标准容器
      • 4. 初始化自定义类型
      • 5. 构造函数初始化列表
      • 6. 初始化列表（initializer_list）
      • 7. 返回值初始化
      • 8. 静态成员变量和全局变量的就地初始化
      • 9. 防止类型收窄
      • 总结
  • decltype
  • 右值引用
  • 完美转发--由右值引用引发的问题
  • delete default
  • 逗号表达式
      • 特性
      • 示例
      • 注意事项
  • 可变参数模板
    • 展开参数包
  • emplace_back
  • 仿函数
  • function包装器/适配器/类模板
  • bind函数模板/包装器/适配器

{}列表初始化

1. 初始化内置类型变量

  • 直接初始化：int a{10};。明确表达初始化过程，避免与赋值混淆。
  • 空列表初始化：如果{}内为空，则内置类型变量会被初始化为该类型的零值，如int b{};会将b初始化为0。

2. 初始化数组

  • C++98风格：在C++98中，数组初始化就需要使用{}，如int arr1[] = {1, 2, 3};。
  • C++11风格：C++11引入了更简洁的数组初始化方式，允许省略=，如int arr2[]{1, 2, 3};。

3. 初始化标准容器

  • STL容器：如vector、map等，可以使用{}进行初始化，

    vector<int> v{1, 2, 3};
map<int, float> m{ {1, 1.0f}, {2, 2.0f} };

4. 初始化自定义类型

  • 无模板类：对于自定义的无模板类，可以在构造函数中使用{}初始化成员变量，也可以在对象创建时直接使用{}进行初始化，如struct A { A(int a = 0, int b = 0) : _a(a), _b(b) {} }; A a{1, 2};。
  • 模板类：模板类同样支持使用{}进行初始化，如template<class T> struct B { B(T c = 0, T d = 0) : _c(c), _d(d) {} }; B<int> b{3, 4};。

5. 构造函数初始化列表

  • 在类的构造函数中，可以使用{}来初始化成员变量，这有助于确保成员变量在构造函数体执行之前就被正确初始化。

6. 初始化列表（initializer_list）

  • C++11引入了initializer_list，允许构造函数接收一个初始化列表作为参数，从而可以更方便地初始化容器或自定义类型。
  • 示例：class C { C(initializer_list<int> lt) : _arr(lt) {} private: vector<int> _arr; }; C c = {1, 2, 3, 4};

7. 返回值初始化

  • 在函数返回时，也可以使用{}来初始化返回值，这有助于确保返回值的正确性和类型安全。

8. 静态成员变量和全局变量的就地初始化

  • 在C++11中，除了构造函数初始化列表外，还允许使用=或{}对静态成员变量和全局变量进行就地初始化。

9. 防止类型收窄

  • 列表初始化可以防止类型收窄，即当尝试将一种类型的值初始化为另一种类型（且这种转换可能会导致精度损失或范围超出）时，编译器会报错。

总结

int a{10}; //明确表达初始化过程，避免与赋值混淆
int b{}; //空列表初始化 内置类型变量会被初始化为该类型的零值

int arr1[] = {1, 2, 3};
int arr2[]{1, 2, 3};

int* pa = new int[4]{ 1,2,3,4 };

vector<int> v{1, 2, 3};
map<int, float> m{ {1, 1.0f}, {2, 2.0f} };

struct A 
{ 
    A(int a = 0, int b = 0) : _a(a), _b(b) 
    {

    } 
}; 
A a{1, 2};

template<class T> 
struct B 
{ 
    B(T c = 0, T d = 0) : _c(c), _d(d) 
    {
        
    } 
}; 
B<int> b{3, 4};

class C 
{ 
    C(initializer_list<int> lt) : _arr(lt) 
    {
        
    } 
private: 
    vector<int> _arr; 
}; 
C c = {1, 2, 3, 4};

std::string createString() 
{  
    return {"Hello, World!"}; // 使用 {} 初始化返回值  
}

static int staticVar = 42; // 使用 = 初始化  
static std::string staticStringVar{"Static String"}; // 使用 {} 初始化  
  
int globalVar = 100; // 使用 = 初始化  
std::string globalStringVar{"Global String"}; // 使用 {} 初始化  

char c1 = 256; // 可能不会报错，但值会被截断  
// char c2{256}; // 这会编译错误，因为256超出了char的表示范围  
  
// 尝试将浮点数转换为整数，同样使用 {} 可以防止类型收窄  
float f = 3.14;  
int i1 = f; // 隐式转换，f的值被截断为整数  
// int i2{f}; // 这会编译错误，因为浮点数到整数的转换可能不安全  
int i3 = static_cast<int>(f); // 显式转换，明确意图 // 安全的转换  

int main()
{
    auto i = { 10,20,30 };
    cout << typeid(i).name() << endl; // class std::initializer list<int>

    return 0;
}


int main()
{
    vector<int> v1 = { 1,2,3,4,5 }; //  initializer_list构造函数
    list<int> l1 = { 10, 20, 30 }; //  initializer_list构造函数
    Date d1 = { 2024, 1, 9 }; // 参数匹配Date构造==》构造+拷贝=直接构造；
    						  // 参数不匹配，{ 2024, 1, 9, 0}被识别成 initializer_list类型，参数不匹配报错
    
	//vector& operator= (initializer_list<value_type> il);
    v1 = {10, 20, 30}; // 这个时候调的是赋值重载，而不是 initializer_list 的构造
    return 0;
}

decltype

将变量的类型声明为表达式指定的类型。decltype 可以推导对象的类型，这个类型是可以用来模板实参，或者再定义对象。

template<class T1, class T2>
void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret;
    cout << typeid(ret).name() << endl;
}

int main()
{
    const int x = 1;
    double y = 2.2;

    decltype(x * y) ret;  // ret的类型是double
    decltype(&x) p;       // p的类型是int*

    // 类型以字符串形式获取到
    cout << typeid(ret).name() << endl;
    cout << typeid(p).name() << endl;

    vector<decltype(ret)> v;   // 使用 ret 的类型去实例化 vector

    F(1, 'a');
    return 0;
}

右值引用

右值引用的出现

左值引用解决了：传引用传参 传引用返回；

左值引用无法解决：局部变量传引用返回。那么传值返回就要经历【构造+拷贝构造】

移动构造

移动构造本质是将参数右值的资源窃取过来，占为已有，就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

https://blog.csdn.net/LHRan_ran_/article/details/133823688?fromshare=blogdetail&sharetype=blogdetail&sharerId=133823688&sharerefer=PC&sharesource=LHRan_ran_&sharefrom=from_link

// 移动构造: 传过来的s是右值 比如 返回值或 ("hello" + "world")
//ape::string ret2 = (s1 + '!'); 右值拷贝 ret2.string( (s1 + '!') );
string(string&& s) noexcept
	:_str(nullptr)
{
	cout << "  string(string&& s)    -- 右值移动拷贝" << endl;
	swap(s); //直接换过来

	s._str = nullptr;
}

ape::string int_to_string(int value)
{
    //return str; 构造一个右值tmp + 调用移动构造 使得s获得返回值

	return move(str);// 这里只是为了调用我们的移动构造输出调试信息 
				 	 // 实际应用中 str是一个出了函数就销毁的变量 这是错误代码 仅为演示！

	// ape::string s = int_to_string(1234);
}

在这里插入图片描述

c++库里移动构造的行为

在这里插入图片描述

总结

左值引用通过引用直接操作 省去中间额外的拷贝
右值引用通过识别是左值还是右值 如果是右值 直接移动拷贝

为什么要有右值引用

为了提高效率 即 右值直接移动拷贝而非深拷贝 因为拷贝时拷贝对象获取到右值的资源后 右值就不再具有价值

因为想提升效率所以搞了右值 但是移动拷贝转移资源时需要”左值“属性 于是这样被设计：s作为”右值引用“ 但是s的属性是左值！

在这里插入图片描述

完美转发–由右值引用引发的问题

Fun(forward(t));将t的属性置为原有属性 当原有属性为左值 你还是左值 是右值 你还是右值 当需要把原有属性是右值但是在该函数需要当成左值来用时 不加forward<T>(t) 即可

void Fun(int& x) 
{ 
	cout << "左值引用" << endl; 
}
void Fun(const int& x) 
{ 
	cout << "const 左值引用" << endl; 
}

void Fun(int&& x) 
{ 
	cout << "右值引用" << endl;
}
void Fun(const int&& x)
{ 
	cout << "const 右值引用" << endl;
}

//万能引用/引用折叠：既可以引用左值 又可以引用右值
template<typename T>
//这里是一个右值引用 当这个函数被调用 t是参数的右值引用 但是此时 t的属性变为了左值
void PerfectForward(T&& t)//模板中的 && 不代表右值引用，而是万能引用，其既能接收左值又能接收右值
{
	//Fun(forward<T>(t));
	Fun(t);
}

int main()
{
	PerfectForward(10);           // 右值

	int a;
	PerfectForward(a);            // 左值
	PerfectForward(move(a));      // 右值

	const int b = 8;
	PerfectForward(b);		      // const 左值
	PerfectForward(move(b));      // const 右值

	return 0;
}

应用场景：如果不使用完美转发就只能手动把forward改成move()

在这里插入图片描述

在这里插入图片描述

右值引用的移动语义出来以后，对深拷贝的类的影响比较大，自定义类的深拷贝传值返回影响也较大，因为移动构造和移动赋值出来以后减少了它们的深拷贝；一些容器的插入接口也新增了右值版本，也减少了深拷贝。但是右值引用对于浅拷贝的类是没有意义的，因为它们没有资源可以转移

默认移动构造/赋值

在这里插入图片描述

delete default

Person(Person&& p) = delete; 		// 不让生成实现
Person(const Person& p) = default;  // 强制编译器生成

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用 default 关键字显示指定移动构造生成。

逗号表达式

逗号表达式的求值顺序是从左到右。整个逗号表达式的值是最后一个表达式的值。

特性

  1. 求值顺序：逗号表达式中的表达式按照从左到右的顺序被求值。
  2. 结果：逗号表达式的结果是最后一个表达式的值，而不是一个列表或者集合。
  3. 副作用：逗号表达式常用于利用其副作用，比如对变量进行多次赋值或调用具有副作用的函数。

示例

#include <iostream>  

int main() 
{  
    int a = 0, b = 0;  

    // 逗号表达式  
    (a = 5, b = a + 1, a + b); 
    // a 被赋值为 5，b 被赋值为 6，表达式的结果是 a + b = 11，但赋值给变量时仅使用最后一个表达式的值  

    // 注意：逗号表达式通常用于语句中，而不是直接赋值给变量  
    // 下面的赋值仅会接收逗号表达式的最后一个表达式的值  
    int result = (a = 2, b = a + 1, a + b); // result 被赋值为 3（即 a + b 的结果）  

    std::cout << "a = " << a << ", b = " << b << ", result = " << result << std::endl;  

    return 0;  
}

注意事项

逗号操作符与逗号分隔符（在函数参数列表、初始化列表等中使用的）在语法上是不同的。逗号操作符用于创建逗号表达式，而逗号分隔符用于分隔列表中的元素。

可变参数模板

template <class ...Args>
void ShowList(Args... args)
{
    cout << sizeof...(args) << endl;
}
int main()
{
    ShowList(1, 2, 3, 4, 5);
    ShowList(1, "abcde", 3.33);

    return 0;
}

展开参数包

编译时的递归推演

// 递归终止函数
void _ShowList()
{
    cout << endl;
}

// 展开函数
template <class T, class ...Args>
void _ShowList(const T& val, Args... args)
{
    cout << val << " ";
    _ShowList(args...);
}

template <class ...Args>
void ShowList(Args... args)
{
    _ShowList(args...);
}

int main()
{
    ShowList(1, 2, 3, 4, 5);
    ShowList(1, "abcde", 3.33);

    return 0;
}

逗号表达式

template <class T>
void PrintArg(T t)
{
    cout << t << " ";
}

template <class ...Args>
void ShowList(Args... args)
{
    // int arr[] = { PrintArg(args)... };
     (PrintArg(args), ...);
    cout << endl; 
}

int main()
{
    ShowList(1, 2, 3, 4, 5);
    ShowList(1, "abcde", 3.33);

    return 0;
}

emplace_back

在这里插入图片描述

int main()
{
    list<string> lt;
    lt.push_back("abc");	// const char* 构造string + string移动构造node
    lt.emplace_back("abc"); //  const char*直接移动构造node(完美转发)

    // 同样的 多参数也是如此
    list<pair<string,int>> lt;
    lt.push_back(make_pair("abc",1));
    lt.emplace_back("abc",1);
    return 0;
}

修改list模拟实现类

template <class... Args>
list_node(Args&&... args)
: _data(args...)
, _next(nullptr)
, _prev(nullptr)
{
    
}

template <class... Args>
void emplace_back(Args&&... args)
{
    Node* newnode = new Node(args...);
    // 链接节点
}

在这里插入图片描述

仿函数

在这里插入图片描述

function的构造函数接收Functor()的临时对象将其封装为一个可调用对象

class TD
{
public:
	void operator()()
	{
		cout << "Thread3" << endl;
	}
};

int main()
{
	function<void()> f = TD();
	f();

	TD td;
	f = td;
	f();

	// 线程函数为仿函数
	thread t1((TD())); // ( TD() ) 必须这样写 原因不明 不重要
	thread t2(td);

	t1.join();
	t2.join();
	cout << "Main thread!" << endl;

	return 0;
}

function包装器/适配器/类模板

https://blog.csdn.net/LHRan_ran_/article/details/133930224?fromshare=blogdetail&sharetype=blogdetail&sharerId=133930224&sharerefer=PC&sharesource=LHRan_ran_&sharefrom=from_link

// 类模板原型如下
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

通过给这些可调用对象加上一层包装器，使得函数模板只实例化一份

function的构造函数接收Functor()的临时对象将其封装为一个可调用对象

在这里插入图片描述

包装器的应用

class Solution
{
	typedef long long Long;
public:
	int evalRPN(vector<string>& tokens)
	{
		stack<Long> st;
		map< string, function<Long(Long, Long)> > m =
		{
			{"+", [](Long a, Long b) { return a + b; }},
			{"-", [](Long a, Long b) { return a - b; }},
			{"*", [](Long a, Long b) { return a * b; }},
			{"/", [](Long a, Long b) { return a / b; }}
		};
		for (auto& e : tokens)
		{
			if (m.count(e))
			{
				Long right = st.top();
				st.pop();
				Long left = st.top();
				st.pop();

				st.push(m[e](left, right));
			}
			else
				st.push(stoll(e));
		}
		return st.top();
	}
};

bind函数模板/包装器/适配器

  1. 接收一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表

调整参数顺序

int Sub(int a, int b)
{
    return a - b;
}

int main()
{
    function<int(int, int)> f1 = Sub;
    cout << f1(10, 5) << endl;

    // 调整参数顺序
    function<int(int, int)> f2 = bind(Sub, placeholders::_2, placeholders::_1);
    cout << f2(10, 5) << endl;// 10传给b 5传给a

    return 0;
}

调整参数个数

int main()
{
    function<int(int, int)> f1 = Sub;
    cout << f1(10, 5) << endl;

    // 调整参数个数，有些参数可以使用 bind 时固定
    function<int(int)> f3 = bind(Sub, 20, placeholders::_1);
    cout << f3(5) << endl;//20给a 5给b

    return 0;
}

调整参数个数的应用

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}

	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	// 静态成员函数名会自动退化为指向该函数的指针 
	// 写成&Plus::plusi也对 没必要
	function<int(int, int)> f1 = Plus::plusi;
	cout << f1(1, 2) << endl;

	// 普通成员函数 必须加&
	function<double(Plus*, double, double)> f2 = &Plus::plusd;
	Plus ps;
	cout << f2(&ps, 1.1, 2.2) << endl;

	// 这里传 Plus 编译器会进行特殊处理，实际上是 Plus*
	function<double(Plus, double, double)> f3 = &Plus::plusd;
	cout << f3(Plus(), 1.11, 2.22) << endl;

	// 通过提前bind简化调用的编写并显得统一
	function<double(double, double)> f4 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);
	cout << f4(1.11, 2.22) << endl;

	return 0;
}

应用

在这里插入图片描述

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

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

相关文章

图像处理案例04

图像处理案例04

图像处理 问题&#xff1a;把不规则的图片按照参考图摆放 步骤&#xff1a; 1. 用ORB找关键点 2. 关键点匹配 3. 根据上一步匹配的关键点得出单应性矩阵 4. 根据单应性矩阵对不规则进行透视变换 import cv2 import numpy as np import matplotlib.pyplot as pltimgl cv2.imrea…
阅读更多...
精华帖分享 | 因子构建思考1

精华帖分享 | 因子构建思考1

本文来源于量化小论坛股票量化板块精华帖&#xff0c;作者为z-coffee。 以下为精华帖正文&#xff1a; 一段时间没写帖子&#xff0c;其实一直在研究策略&#xff0c;只是从不同的角度去思考而已。熟悉我的老板其实清楚&#xff0c;我的炉子水平一般&#xff0c;基本不太依托…
阅读更多...
什么是 Web 应用中的 Facet 控件

什么是 Web 应用中的 Facet 控件

在 Web 页面设计和开发中&#xff0c;facet 是一个十分重要的概念&#xff0c;尤其在电子商务、数据搜索和筛选功能中非常常见。Facet 通常指的是一种分类或过滤的方式&#xff0c;用于让用户能够通过多维度的条件来细化和调整数据结果&#xff0c;从而找到更符合需求的内容。F…
阅读更多...
资源《Arduino 扩展板5-单电机驱动》说明。

资源《Arduino 扩展板5-单电机驱动》说明。

资源链接&#xff1a; Arduino 扩展板5-单电机驱动 1.文件明细&#xff1a; 2.文件内容说明 包含&#xff1a;AD工程、原理图、PCB。 3.内容展示 4.简述 该文件为PCB工程&#xff0c;采用AD做的。 该文件打板后配合Arduino使用&#xff0c;属于Arduino的扩展板。
阅读更多...
ECP 集成字段非必填配置

ECP 集成字段非必填配置

导读 INTRODUCTION 非必填设置&#xff1a;ECP主数据同步的时候&#xff0c;经常遇到一个问题&#xff0c;就是ECP报错&#xff0c;但是这个字段两边的ecp顾问与sf顾问都觉得没实际意思&#xff0c;觉得没有传输的必要性&#xff0c;这个时候我们就可以考虑非必输的字段不必输…
阅读更多...
Linux命令--04----文件目录类命令

Linux命令--04----文件目录类命令

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 文件目录类命令pwdls 、llcdmkdirrmdirtouchcprmmv 查看文件catmorelessheadtail 打印信息echo\> 覆盖和>>追加lnhistory 文件目录类命令 pwd ls 、ll cd…
阅读更多...
C--编译和链接见解

C--编译和链接见解

欢迎各位看官&#xff01;如果您觉得这篇文章对您有帮助的话 欢迎您分享给更多人哦 感谢大家的点赞收藏评论 感谢各位看官的支持&#xff01;&#xff01;&#xff01; 一&#xff1a;翻译环境和运行环境 在ANSIIC的任何一种实现中&#xff0c;存在两个不同的环境1&#xff0c;…
阅读更多...
动手学深度学习（李沐）PyTorch 第 7 章 现代卷积神经网络

动手学深度学习（李沐）PyTorch 第 7 章 现代卷积神经网络

7.1 深度卷积神经网络&#xff08;AlexNet&#xff09; 在计算机视觉中&#xff0c;直接将神经网络与其他机器学习方法进行比较也许不公平。这是因为&#xff0c;卷积神经网络的输入是由原始像素值或是经过简单预处理&#xff08;例如居中、缩放&#xff09;的像素值组成的。但…
阅读更多...
【C++】——list的介绍和模拟实现

【C++】——list的介绍和模拟实现

P. S.&#xff1a;以下代码均在VS2019环境下测试&#xff0c;不代表所有编译器均可通过。 P. S.&#xff1a;测试代码均未展示头文件stdio.h的声明&#xff0c;使用时请自行添加。 博主主页&#xff1a;Yan. yan.                        …
阅读更多...
亚马逊云乱扣费，被不知不觉扣钱真的好气呀

亚马逊云乱扣费，被不知不觉扣钱真的好气呀

之前申请了亚马逊云12个月免费&#xff0c;一直也没用&#xff0c;也没登录&#xff0c;今天突然看到银行扣费信息&#xff0c;扣了我21美元&#xff0c;已经扣了我几个月了&#xff0c;登录亚马逊后台&#xff0c;实例为0的情况下&#xff0c;每个月都能扣21美元&#xff0c;国…
阅读更多...
【HTML+CSS】留言板plus实现全过程

【HTML+CSS】留言板plus实现全过程

创建一个具有动态留言的简约风格留言板 在本教程中&#xff0c;我们将学习如何创建一个简约风格的留言板&#xff0c;它具备动态留言显示和一些基本动画效果。这个留言板将使用HTML和CSS构建&#xff0c;最终实现一个既美观又实用的界面。 准备工作 首先&#xff0c;确保你的…
阅读更多...
UNRAID使用rclone挂在alist网盘

UNRAID使用rclone挂在alist网盘

UNRAID使用rclone挂在alist网盘 需求&#xff1a;考虑异地备份&#xff0c;将部分重要的资料上传至网盘&#xff0c;保证nas中的资料安全。 考虑&#xff1a;当然网盘备份存在安全性问题&#xff0c;后续也可以通过加密的方式进行上传&#xff0c;不过这是后话&#xff0c;有精…
阅读更多...
Python常见问题解答：从基础到进阶

Python常见问题解答：从基础到进阶

Python常见问题解答&#xff1a;从基础到进阶 Python 是一种简单易学、功能强大的编程语言&#xff0c;广泛应用于数据分析、Web 开发、自动化脚本、人工智能等领域。即便如此&#xff0c;Python 开发者在编写代码的过程中&#xff0c;常常会遇到各种各样的问题。本文将从基础…
阅读更多...
java集合 -- 面试

java集合 -- 面试

Java集合框架体系 ArrayList底层实现是数组 LinkedList底层实现是双向链表 HashMap的底层实现使用了众多数据结构&#xff0c;包含了数组、链表、散列表、红黑树等 List ps : 数据结构 -- 数组 ArrayList源码分析 ArrayList底层的实现原理是什么? ArrayList list new…
阅读更多...
HKMG工艺为什么要用金属栅极？

HKMG工艺为什么要用金属栅极？

知识星球里的学员问&#xff1a;在HKMG工艺中&#xff0c;会用到HfO2等作为栅介质层&#xff0c;为什么不能再用多晶硅做栅极&#xff0c;而是改为金属栅极&#xff1f; 什么是HKMG工艺&#xff1f; HKMG&#xff08;High-K Metal Gate &#xff09;&#xff0c;是45nm&#…
阅读更多...
《深度学习》OpenCV 背景建模 原理及案例解析

《深度学习》OpenCV 背景建模 原理及案例解析

目录 一、背景建模 1、什么是背景建模 2、背景建模的方法 1&#xff09;帧差法(backgroundSubtractor) 2&#xff09;基于K近邻的背景/前景分割算法BackgroundSubtractorKNN 3&#xff09;基于高斯混合的背景/前景分割算法BackgroundSubtractorMOG2 3、步骤 1&#xff09;初…
阅读更多...
利士策分享，年前如何合理规划，轻松搞点小钱？

利士策分享，年前如何合理规划，轻松搞点小钱？

利士策分享&#xff0c;年前如何合理规划&#xff0c;轻松搞点小钱&#xff1f; 随着春节的日益临近&#xff0c;不少人开始为过年期间的开销而犯愁。 如何在年前合理规划&#xff0c;轻松搞点小钱&#xff0c;成了大家热议的话题。 别担心&#xff0c;这里有几个既实用又不伤…
阅读更多...
华为OD机试 - 分班问题（Java 2024 E卷 200分）

华为OD机试 - 分班问题（Java 2024 E卷 200分）

华为OD机试 2024E卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试&#xff08;JAVA&#xff09;真题&#xff08;E卷D卷A卷B卷C卷&#xff09;》。 刷的越多&#xff0c;抽中的概率越大&#xff0c;私信哪吒&#xff0c;备注华为OD&#xff0c;加…
阅读更多...
华为OD机试 - 密室逃生游戏（Python/JS/C/C++ 2024 E卷 100分）

华为OD机试 - 密室逃生游戏（Python/JS/C/C++ 2024 E卷 100分）

华为OD机试 2024E卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试真题&#xff08;Python/JS/C/C&#xff09;》。 刷的越多&#xff0c;抽中的概率越大&#xff0c;私信哪吒&#xff0c;备注华为OD&#xff0c;加入华为OD刷题交流群&#xff0c;…
阅读更多...
杀疯啦-yolov11+deepsort的目标跟踪实现

杀疯啦-yolov11+deepsort的目标跟踪实现

目录 yolov11介绍——实时端到端物体检测 概述 主要特征 支持的任务和模式 性能指标 总结 deepsort介绍&#xff1a; yolov11结合deepsort实现目标跟踪 效果展示 训练与预测 UI设计 其他功能展示 完整代码实现UI界面 yolov11介绍——实时端到端物体检测 概述 YOLO…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023