常用的c++特性--＞day02

可调用对象

案例

#include <iostream>
#include <string>
#include <vector>
using namespace std;using funcptr = void(*)(int, string);int print(int a, double b)
{cout << a << ", " << b << endl;return 0;
}
// 定义函数指针
int (*func)(int, double) = &print;struct Test
{int m_id;// ()操作符重载void operator()(string msg){cout << "msg: " << msg << endl;}//属于类的static void world(int a, string b){cout << "name: " << b << ", age: " << a << endl;}//属于对象void hello(int a, string b){cout << "name: " << b << ", age: " << a << endl;}// 将类对象转换为函数指针 ----> 指定world被调用operator funcptr(){//return hello;//errreturn world;}
};int main(void)
{func(1, 2);Test t;t("hello world");Test tt;// 对象转换为函数指针, 并调用tt(19, "Monkey D. Luffy");//-----------------------------------------------------------------------------//类的函数指针//左侧是不属于类的函数指针，右侧是属于类的函数指针//funcptr f = Test::hello;//err//函数名就是地址 下面两个写法都对funcptr f1 = Test::world;f1(10, "冬狮郎");funcptr f2 = &Test::world;f2(0, "黑崎一护");using fptr = void(Test::*)(int, string);fptr f3 = &Test::hello;Test ttt;(ttt.*f3)(2, "碎蜂");//---------------------------------------------------------------//类的成员指针(变量)using ptr1 = int Test::*;ptr1 pt = &Test::m_id;ttt.*pt = 1008611;cout << "m_id:" << ttt.m_id << endl;return 0;
}

在这里插入图片描述

可调用对象包装器

std::function是可调用对象的包装器。它是一个类模板，可以容纳除了类(非静态)成员（函数）指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。

语法

#include <functional>
std::function<返回值类型(参数类型列表)> diy_name = 可调用对象;

案例

#include <iostream>
#include <string>
#include <vector>
#include <functional>
using namespace std;using funcptr = void(*)(int, string);int print(int a, double b)
{cout << a << ", " << b << endl;return 0;
}
// 定义函数指针
int (*func)(int, double) = &print;struct Test
{int m_id;// ()操作符重载 >>> 仿函数void operator()(string msg){cout << "msg: " << msg << endl;}//属于类的static void world(int a, string b){cout << "name: " << b << ", age: " << a << endl;}//属于对象void hello(int a, string b){cout << "name: " << b << ", age: " << a << endl;}// 将类对象转换为函数指针 ----> 指定world被调用operator funcptr(){//return hello;//errreturn world;}
};int main(void)
{//1、函数指针func(1, 2.2);//2、仿函数Test t;t("hello world");Test tt;//对象转换为函数指针, 并调用 >>>>>>>>>>>>>>>>>>>> operator 对应函数tt(19, "Monkey D. Luffy");//3、类的函数指针//左侧是不属于类的函数指针，右侧是属于类的函数指针//funcptr f = Test::hello;//err//函数名就是地址 下面两个写法都对funcptr f1 = Test::world;f1(10, "冬狮郎");funcptr f2 = &Test::world;f2(0, "黑崎一护");using fptr = void(Test::*)(int, string);fptr f3 = &Test::hello;Test ttt;(ttt.*f3)(2, "碎蜂");//4、类的成员指针(变量)using ptr1 = int Test::*;ptr1 pt = &Test::m_id;ttt.*pt = 1008611;cout << "m_id:" << ttt.m_id << endl;//*********************************************************************************************cout << endl << endl << endl;
//*********************************************************************************************//1、包装普通函数function<void(int, double)>f4 = print;f4(1, 2.2);//2、包装静态函数function<void(int, string)>f5 = Test::world;f5(5, "蓝染");//3、包装仿函数Test ta;function<void(string)>f6 = ta;f6("浦原喜助");//4、包装转换为函数指针的对象Test tb;function<void(int, string)>f7 = tb;f7(11, "更木剑八");return 0;
}

在这里插入图片描述

可调用对象包装器作为函数参数

#include <iostream>
#include <string>
#include <vector>
#include <functional>
using namespace std;using funcptr = void(*)(int, string);int print(int a, double b)
{cout << a << ", " << b << endl;return 0;
}
// 定义函数指针
int (*func)(int, double) = &print;struct Test
{int m_id;// ()操作符重载 >>> 仿函数void operator()(string msg){cout << "msg: " << msg << endl;}//属于类的static void world(int a, string b){cout << "name: " << b << ", age: " << a << endl;}//属于对象void hello(int a, string b){cout << "name: " << b << ", age: " << a << endl;}// 将类对象转换为函数指针 ----> 指定world被调用operator funcptr(){//return hello;//errreturn world;}
};class A
{
public:// 构造函数参数是一个包装器对象A(const function<void(int,string)>& f) : callback(f){}void notify(int id, string name){callback(id, name); // 调用通过构造函数得到的函数指针}
private:function<void(int,string)> callback;
};int main(void)
{//1、函数指针func(1, 2.2);//2、仿函数Test t;t("hello world");//2.5、是一个可被转换为函数指针的类对象Test tt;//对象转换为函数指针, 并调用 >>>>>>>>>>>>>>>>>>>> operator 对应函数tt(19, "Monkey D. Luffy");//3、类的函数指针//左侧是不属于类的函数指针，右侧是属于类的函数指针//funcptr f = Test::hello;//err//函数名就是地址 下面两个写法都对funcptr f1 = Test::world;f1(10, "冬狮郎");funcptr f2 = &Test::world;f2(0, "黑崎一护");using fptr = void(Test::*)(int, string);fptr f3 = &Test::hello;Test ttt;(ttt.*f3)(2, "碎蜂");//4、类的成员指针(变量)using ptr1 = int Test::*;ptr1 pt = &Test::m_id;ttt.*pt = 1008611;cout << "m_id:" << ttt.m_id << endl;//*********************************************************************************************cout << endl << endl;
//*********************************************************************************************//1、包装普通函数function<void(int, double)>f4 = print;f4(1, 2.2);//2、包装静态函数function<void(int, string)>f5 = Test::world;f5(5, "蓝染");//3、包装仿函数Test ta;function<void(string)>f6 = ta;f6("浦原喜助");//4、包装转换为函数指针的对象Test tb;function<void(int, string)>f7 = tb;f7(11, "更木剑八");//*********************************************************************************************cout << endl << endl;
//*********************************************************************************************//可调用函数包装器作为函数参数A aa(Test::world);aa.notify(12, "涅茧利");Test tc;A bb(tc);bb.notify(7, "狛村左阵");return 0;
}

在这里插入图片描述
Test 类定义了一个 operator funcptr() 转换函数，它的作用是将 Test 类的对象转换为 funcptr 类型的函数指针（即 void(*)(int, string)）。当将 tb 传递给 f7 时，实际上调用了这个转换操作符。

补充：类型转换运算符

operator 目标类型()
{// 转换逻辑
}

案例

#include <iostream>
using namespace std;class Box {
public:Box(double v) : volume(v) {}// 类型转换运算符：将 Box 对象转换为 double 类型operator double() const {return volume;}private:double volume;
};int main() {Box b(100.0);double volume = b; // 隐式调用 operator double()cout << "Volume: " << volume << endl;return 0;
}

在这里插入图片描述

可调用对象绑定器

可调用对象绑定器：
1、将可调用对象与其参数一起绑定成一个仿函数。
2、将多元（参数个数为n，n>1）可调用对象转换为一元或者（n-1）元可调用对象，即只绑定部分参数。

语法格式

// 绑定非类成员函数/变量
auto f = std::bind(可调用对象地址, 绑定的参数/占位符); //>>>>>>>>>>>>>>>>静态函数可以使用这种方式
// 绑定类成员函/变量
auto f = std::bind(类函数/成员地址, 类实例对象地址, 绑定的参数/占位符);// >>>>>>>>>>>>>>>>>>>>绑定的是成员第三个参数可以省略

绑定非类成员函数/变量

案例1

#include <iostream>
#include <functional>
using namespace std;
//通过bind得到第二个参数
void callFunc(int x, const function<void(int)>& f)
{if (x % 2 == 0){f(x);}
}
void output(int x)
{cout << x << " ";
}void output_add(int x)
{cout << x + 10 << " ";
}int main(void)
{// 使用绑定器绑定可调用对象和参数auto f1 = bind(output, placeholders::_1);// >>>>>> f1类型std::function<void(int)>for (int i = 0; i < 10; ++i){callFunc(i, f1);}cout << endl;auto f2 = bind(output_add, placeholders::_1);// >>>>>>> f2类型std::function<void(int)>for (int i = 0; i < 10; ++i){callFunc(i, f2);}cout << endl;return 0;
}

在上面的程序中，使用了std::bind绑定器，在函数外部通过绑定不同的函数，控制了最后执行的结果。std::bind绑定器返回的是一个仿函数类型，得到的返回值可以直接赋值给一个std::function，在使用的时候我们并不需要关心绑定器的返回值类型，使用auto进行自动类型推导就可以了。
placeholders::_1是一个占位符，代表这个位置将在函数调用时被传入的第一个参数所替代。同样还有其他的占位符placeholders::_2、placeholders::_3、placeholders::_4、placeholders::_5等……
在这里插入图片描述

案例2

#include <iostream>
#include <functional>
using namespace std;void output(int x, int y)
{cout << x << " " << y << endl;
}int main(void)
{// 使用绑定器绑定可调用对象和参数, 并调用得到的仿函数bind(output, 1, 2)();bind(output, placeholders::_1, 2)(10);bind(output, 2, placeholders::_1)(10);// error, 调用时没有第二个参数// bind(output, 2, placeholders::_2)(10);// 调用时第一个参数10被吞掉了，没有被使用bind(output, 2, placeholders::_2)(10, 20);bind(output, placeholders::_1, placeholders::_2)(10, 20);bind(output, placeholders::_2, placeholders::_1)(10, 20);return 0;
}

在这里插入图片描述

案例3

#include <iostream>
#include <functional>
using namespace std;void callFunc(int x, int y, const function<void(int, int)>& f)
{if (x % 2 == 0){f(x, y);}
}void output_add(int x, int y)
{cout << "x: " << x << ",y: " << y <<",x+y: " << x + y << endl;
}int main(void)
{for (int i = 0; i < 10; ++i){//bind绑定固定的实参函数调用的时候是不会生效的//如果是占位符是可以生效的//绑定的是output_add函数 i+100 i+200是为这个函数提供的参数auto f1 = bind(output_add, i + 100, i + 200);// >>>>>> f1被推导为function<void<int,int>>类型callFunc(i, i, f1);cout << endl;auto f2 = bind(output_add, placeholders::_1, placeholders::_2);callFunc(i, i, f2);}return 0;
}

在这里插入图片描述

案例4

#include <iostream>
#include <functional>
using namespace std;void callFunc(int x, int y, const function<void(int, int)>& f)
{if (x % 2 == 0){f(x, y);}
}void output_add(int x, int y)
{cout << "x: " << x << ",y: " << y <<",x+y: " << x + y << endl;
}int main(void)
{for (int i = 0; i < 10; ++i){callFunc(i, i, bind(output_add, placeholders::_1, placeholders::_2));}return 0;
}

在这里插入图片描述

绑定类成员函数/变量

#include <iostream>
#include <functional>
using namespace std;class Test
{
public:void output(int x, int y){cout << "x: " << x << ", y: " << y << endl;}int m_number = 100;
};int main(void)
{Test t;// 绑定类成员函数function<void(int, int)> f1 = bind(&Test::output, &t, placeholders::_1, placeholders::_2);auto f2 = bind(&Test::output, &t, 14, placeholders::_1);// 绑定类成员变量(公共)//f3可读可写 >>>>>>>>> &function<int& (void)> f3 = bind(&Test::m_number, &t);auto f4 = bind(&Test::m_number, &t);// >>>>>>>>f3和f4类型不一样// 调用f1(520, 1314);f2(38);cout << "f3():" << f3() << endl;f3() = 2333;cout << "t.m_number: " << t.m_number << endl;f4() = 3332;cout << "t.m_number: " << t.m_number << endl;return 0;
}

在这里插入图片描述

lambda表达式

lambda表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。lambda表达式的语法形式简单归纳如下：

[capture](params) opt -> ret {body;};

其中capture是捕获列表，params是参数列表，opt是函数选项，ret是返回值类型，body是函数体。
捕获列表[]: 捕获一定范围内的变量
参数列表(): 和普通函数的参数列表一样，如果没有参数参数列表可以省略不写。

auto f = [](){return 1;}	// 没有参数, 参数列表为空
auto f = []{return 1;}		// 没有参数, 参数列表省略不写

opt 选项， 不需要可以省略
mutable: 可以修改按值传递进来的拷贝（注意是能修改拷贝，而不是值本身）
exception: 指定函数抛出的异常，如抛出整数类型的异常，可以使用throw();
返回值类型：在C++11中，lambda表达式的返回值是通过返回值后置语法来定义的。
函数体：函数的实现，这部分不能省略，但函数体可以为空。
ambda表达式的捕获列表可以捕获一定范围内的变量，具体使用方式如下：

捕获列表

[] - 不捕捉任何变量
[&] - 捕获外部作用域中所有变量, 并作为引用在函数体内使用 (按引用捕获)
[=] - 捕获外部作用域中所有变量, 并作为副本在函数体内使用 (按值捕获)
拷贝的副本在匿名函数体内部是只读的
[=, &foo] - 按值捕获外部作用域中所有变量, 并按照引用捕获外部变量 foo
[bar] - 按值捕获 bar 变量, 同时不捕获其他变量
[&bar] - 按引用捕获 bar 变量, 同时不捕获其他变量
[this] - 捕获当前类中的this指针
让lambda表达式拥有和当前类成员函数同样的访问权限
如果已经使用了 & 或者 =, 默认添加此选项

案例1

#include <iostream>
#include <functional>
using namespace std;void func(int x, int y)
{int a = 9;int b = 6;//由于是=上面的b和下面的b是存在于不同内存的[=, &x]()mutable{int c = a;int d = x;d = d + 100;b = b + 10;;cout << "c:" << c << endl;cout << "d:" << d << endl;cout << "b:" << b << endl;}();cout << "b:" << b << endl;
}int main()
{func(1000,1000);return 0;
}

在这里插入图片描述

返回值

一般情况下，不指定lambda表达式的返回值，编译器会根据return语句自动推导返回值的类型，但需要注意的是labmda表达式不能通过列表初始化自动推导出返回值类型。

// ok，可以自动推导出返回值类型
auto f = [](int i)
{return i;
}// error，不能推导出返回值类型
auto f1 = []()
{return {1, 2};	// 基于列表初始化推导返回值，错误
}

案例2 --> 包装器绑定器

#include <iostream>
#include <functional>
using namespace std;void func(int x, int y)
{int a;int b;using ptr = void(*)(int);//捕获列表没有任何参数 >>> 可以被看作为函数指针ptr p1 = [](int x){cout << "x: " << x << endl;};p1(11);//err//ptr p2 = [=](int x)//{//	cout << "x: " << x << endl;//};//p2(11);function<void(int)> fff = [=](int x){cout << "x: " << x << endl;};fff(11);//由于绑定器绑定是仿函数//auto推导是仿函数//包装器推导是包装器对象function<void(int)> ffff = bind([=](int x){cout << "x: " << x << endl;}, placeholders::_1);ffff(11);}int main()
{func(10, 20);return 0;
}

左值和右值

左值是指存储在内存中、有明确存储地址（可取地址）的数据
右值是指可以提供数据值的数据（不可取地址）

右值引用

书写规则

#include <iostream>
#include <functional>
using namespace std;int main()
{//1、左值int num = 9;//2、左值引用int& a = num;//右值//3、右值引用int&& b = 8;//4、常量右值引用const int&& d = 6;//const int&& e = b;//err//int&& f = b;//err//5、常量左值引用const int& c = num;//常量的左值引用可以使用常量的右值引用进行初始化const int& f = b;const int& g = d;
}

案例

#include <iostream>
using namespace std;int&& value = 520;
class Test
{
public:Test(){cout << "construct: my name is jerry" << endl;}Test(const Test& a){cout << "copy construct: my name is tom" << endl;}
};Test getObj()
{return Test();
}int main()
{int a1;int &&a2 = a1;        // errorTest& t = getObj();   // errorTest && t = getObj();const Test& tt = getObj();return 0;
}

在这里插入图片描述
在上面的例子中int&& value = 520;里面520是纯右值，value是对字面量520这个右值的引用。
在int &&a2 = a1;中a1虽然写在了=右边，但是它仍然是一个左值，使用左值初始化一个右值引用类型是不合法的。
在Test& t = getObj()这句代码中语法是错误的，右值不能给普通的左值引用赋值。
在Test && t = getObj();中getObj()返回的临时对象被称之为将亡值，t是这个将亡值的右值引用。
const Test& t = getObj()这句代码的语法是正确的，常量左值引用是一个万能引用类型，它可以接受左值、右值、常量左值和常量右值。

右值引用的作用

右值引用延迟内存的生命周期
在C++中在进行对象赋值操作的时候，很多情况下会发生对象之间的深拷贝，如果堆内存很大，这个拷贝的代价也就非常大，在某些情况下，如果想要避免对象的深拷贝，就可以使用右值引用进行性能的优化。

案例分析

vs2019

#include <iostream>
using namespace std;class Test
{
public:Test() : m_num(new int(100)){cout << "construct: my name is jerry" << endl; cout << "m_num: " << m_num << endl;}Test(const Test& a) : m_num(new int(*a.m_num)){cout << "copy construct: my name is tom" << endl;}~Test(){cout << "destruct Test class ..." << endl;delete m_num;}int* m_num;
};Test getObj()
{Test t;return t;
}int main()
{Test t = getObj();
}

在这里插入图片描述
上述是消耗资源的因为getObj调用的时候只是创建了一个t对象然后返回，拷贝构造析构都是需要消耗资源的，因此需要让t对象直接使用getObj，因此用右值引用
优化上面代码(vs2019下)：

#include <iostream>
using namespace std;class Test
{
public:Test() : m_num(new int(100)){cout << "construct: my name is jerry" << endl; cout << "m_num: " << m_num << endl;}Test(const Test& a) : m_num(new int(*a.m_num)){cout << "copy construct: my name is tom" << endl;}//浅拷贝//移动构造函数 -> 复用其它对象中的资源(堆内存)Test(Test&& a) :m_num(a.m_num){a.m_num = nullptr;cout << "move construct..." << endl;}~Test(){cout << "destruct Test class ..." << endl;delete m_num;}int* m_num;
};Test getObj()
{Test t;return t;
}int main()
{Test t = getObj();cout << "t.m_num: " << *t.m_num << endl;return 0;
};

右值引用具有移动语义，移动语义可以将资源（堆、系统对象等）通过浅拷贝从一个对象转移到另一个对象这样就能减少不必要的临时对象的创建、拷贝以及销毁，可以大幅提高C++应用程序的性能。

执行结果：

construct: my name is jerry
move construct: my name is sunny
destruct Test class ...
t.m_num: 100
destruct Test class ...

通过修改，在上面的代码给Test类添加了移动构造函数（参数为右值引用类型），这样在进行Test t = getObj();操作的时候并没有调用拷贝构造函数进行深拷贝，而是调用了移动构造函数，在这个函数中只是进行了浅拷贝，没有对临时对象进行深拷贝，提高了性能。

在测试程序中getObj()的返回值就是一个将亡值，也就是说是一个右值，在进行赋值操作的时候如果=右边是一个右值，那么移动构造函数就会被调用。移动构造中使用了右值引用，会将临时对象中的堆内存地址的所有权转移给对象t，这块内存被成功续命，因此在t对象中还可以继续使用这块内存。

案例分析2

右值引用分为：普通右值和将亡右值

#include <iostream>
using namespace std;class Test
{
public:Test() : m_num(new int(100)){cout << "construct: my name is jerry" << endl; cout << "m_num: " << m_num << endl;}Test(const Test& a) : m_num(new int(*a.m_num)){cout << "copy construct: my name is tom" << endl;}//浅拷贝//移动构造函数 -> 复用其它对象中的资源(堆内存)Test(Test&& a) :m_num(a.m_num){a.m_num = nullptr;cout << "move construct: my name is sunny" << endl;}~Test(){cout << "destruct Test class ..." << endl;delete m_num;}int* m_num;
};Test getObj1()
{Test t;return t;
}//返回的是临时对象是不能够被取地址的
Test getObj2()
{return Test();
}//将临时对象转换为右值引用
Test&& getObj3()
{return Test();
}int main()
{//两种方法 >>>>>> 要求右侧是临时对象 Test t = getObj1();// >>>>>>>>>>>> 返回临时对象调用移动构造函数Test&& t1 = getObj1();cout << "t.m_num: " << *t1.m_num << endl;//复用了即将释放对象的所有资源Test&& t2 = getObj2();// >>>>>>>>>>>>> 没有使用移动构造函数 要求右侧是一个临时不能取地址的对象cout << "t.m_num: " << *t2.m_num << endl;return 0;
};

解释移动构造函数:

    Test(Test&& a) :m_num(a.m_num){a.m_num = nullptr;cout << "move construct: my name is sunny" << endl;}

源对象 a 不再拥有指向原始资源的指针。
在源对象析构时，它不会错误地释放已经转移给目标对象的资源。
目标对象在析构时将正确地释放它所接管的资源

&&注意事项

template<typename T>
void f(T&& param);
void f1(const T&& param);
f(10); 	//右值引用
int x = 10;
f(x); //左值引用
f1(x);	// error, x是左值
f1(10); // ok, 10是右值

第4行中，对于f(10)来说传入的实参10是右值，因此T&&表示右值引用
第6行中，对于f(x)来说传入的实参是x是左值，因此T&&表示左值引用
第7行中，f1(x)的参数是const T&&不是未定引用类型，不需要推导，本身就表示一个右值引用

int main()
{int x = 520, y = 1314;auto&& v1 = x;auto&& v2 = 250;decltype(x)&& v3 = y;   // errorcout << "v1: " << v1 << ", v2: " << v2 << endl;return 0;
};

第4行中 auto&&表示一个整形的左值引用
第5行中 auto&&表示一个整形的右值引用
第6行中decltype(x)&&等价于int&&是一个右值引用不是未定引用类型，y是一个左值，不能使用左值初始化一个右值引用类型。

由于上述代码中存在T&&或者auto&&这种未定引用类型，当它作为参数时，有可能被一个右值引用初始化，也有可能被一个左值引用初始化，在进行类型推导时右值引用类型（&&）会发生变化，这种变化被称为引用折叠。在C++11中引用折叠的规则如下：
通过右值推导 T&& 或者 auto&& 得到的是一个右值引用类型
通过非右值（右值引用、左值、左值引用、常量右值引用、常量左值引用）推导 T&& 或者 auto&& 得到的是一个左值引用类型

int&& a1 = 5;
auto&& bb = a1;
auto&& bb1 = 5;int a2 = 5;
int &a3 = a2;
auto&& cc = a3;
auto&& cc1 = a2;const int& s1 = 100;
const int&& s2 = 100;
auto&& dd = s1;
auto&& ee = s2;const auto&& x = 5;

第2行：a1为右值引用，推导出的bb为左值引用类型
第3行：5为右值，推导出的bb1为右值引用类型
第7行：a3为左值引用，推导出的cc为左值引用类型
第8行：a2为左值，推导出的cc1为左值引用类型
第12行：s1为常量左值引用，推导出的dd为常量左值引用类型
第13行：s2为常量右值引用，推导出的ee为常量左值引用类型
第15行：x为右值引用，不需要推导，只能通过右值初始化

#include <iostream>
using namespace std;void printValue(int &i)
{cout << "l-value: " << i << endl;
}void printValue(int &&i)
{cout << "r-value: " << i << endl;
}void forward(int &&k)
{printValue(k);
}int main()
{int i = 520;printValue(i);printValue(1314);forward(250);return 0;
};

在这里插入图片描述

转移和完美转发

move资源的转移

move:将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存拷贝

#include <iostream>
#include <list>
using namespace std;class Test
{
public:Test() : m_num(new int(100)){cout << "construct: my name is jerry" << endl; cout << "m_num: " << m_num << endl;}Test(const Test& a) : m_num(new int(*a.m_num)){cout << "copy construct: my name is tom" << endl;}//浅拷贝//移动构造函数 -> 复用其它对象中的资源(堆内存)Test(Test&& a) :m_num(a.m_num){a.m_num = nullptr;cout << "move construct: my name is sunny" << endl;}~Test(){cout << "destruct Test class ..." << endl;delete m_num;}int* m_num;
};Test getObj1()
{Test t;return t;
}Test getObj2()
{return Test();
}//将临时对象转换为右值引用
Test&& getObj3()
{return Test();
}int main()
{Test t = getObj1();// >>>>>>>>>>>> 返回临时对象调用移动构造函数Test&& t1 = getObj1();cout << "t.m_num: " << *t1.m_num << endl;//复用了即将释放对象的所有资源Test&& t2 = getObj2();// >>>>>>>>>>>>> 没有使用移动构造函数 要求右侧是一个临时不能取地址的对象cout << "t.m_num: " << *t2.m_num << endl;//Test&& t3 = t2;//errTest&& t3 = move(t2);Test&& t4 = move(t);list<string> ls1{"hello","world","nihao","shijie",};//拷贝list<string> ls2 = ls1;//如果还需要用ls1list<string> ls3 = ls1;return 0;
};

如果不使用std::move，拷贝的代价很大，性能较低。使用move几乎没有任何代价，只是转换了资源的所有权。如果一个对象内部有较大的堆内存或者动态数组时，使用move()就可以非常方便的进行数据所有权的转移。

forward

函数原型

template <class T> T&& forward (typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward (typename remove_reference<T>::type&& t) noexcept;

精简之后的样子

std::forward<T>(t);

当T为左值引用类型时，t将被转换为T类型的左值
当T不是左值引用类型时，t将被转换为T类型的右值

案例

#include <iostream>
using namespace std;template<typename T>
void printValue(T& t)
{cout << "l-value: " << t << endl;
}template<typename T>
void printValue(T&& t)
{cout << "r-value: " << t << endl;
}template<typename T>
void testForward(T&& v)
{printValue(v);printValue(move(v));printValue(forward<T>(v));cout << endl;
}int main()
{testForward(520);int num = 1314;testForward(num);//<int>类型右值 num被转换为inttestForward(forward<int>(num));//<int&>类型左值testForward(forward<int&>(num));//<int&&>类型右值testForward(forward<int&&>(num));return 0;
}

在这里插入图片描述
forward(num) 让编译器将 num 作为右值传递给 testForward，这意味着虽然 num 是一个左值，使用 std::forward(num) 后，它会被转发为右值。
forward<int&>(num) 将 num 转发为 左值引用（int&）。这是因为你显式指定了 int&，即要求将 num 作为左值引用转发。
forward<int&&>(num) 会试图将 num 转发为右值引用。但是 num 是左值，左值不能绑定到右值引用（int&&）。因此，这样的代码会导致编译错误。

共享智能指针

C++11中提供了三种智能指针，使用这些智能指针时需要引用头文件：
std::shared_ptr：共享的智能指针
std::unique_ptr：独占的智能指针
std::weak_ptr：弱引用的智能指针，它不共享指针，不能操作资源，是用来监视shared_ptr的。

shared_ptr的初始化

共享智能指针是指多个智能指针可以同时管理同一块有效的内存，共享智能指针shared_ptr 是一个模板类，如果要进行初始化有三种方式：通过构造函数、std::make_shared辅助函数以及reset方法。

通过构造函数初始化

#include <iostream>
#include <memory>
using namespace std;int main()
{// 使用智能指针管理一块 int 型的堆内存shared_ptr<int> ptr1(new int(520));cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;// 使用智能指针管理一块字符数组对应的堆内存shared_ptr<char> ptr2(new char[12]);cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;// 创建智能指针对象, 不管理任何内存shared_ptr<int> ptr3;cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;// 创建智能指针对象, 初始化为空shared_ptr<int> ptr4(nullptr);cout << "ptr4管理的内存引用计数: " << ptr4.use_count() << endl;return 0;
}

在这里插入图片描述

通过拷贝函数进行初始化

#include <iostream>
#include <memory>
using namespace std;int main()
{// 使用智能指针管理一块 int 型的堆内存shared_ptr<int> ptr1(new int(520));cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;shared_ptr<int> ptr5 = ptr1;cout << "ptr5管理的内存引用计数: " << ptr5.use_count() << endl;cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;// 使用智能指针管理一块字符数组对应的堆内存shared_ptr<char> ptr2(new char[12]);cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;// 创建智能指针对象, 不管理任何内存shared_ptr<int> ptr3;cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;// 创建智能指针对象, 初始化为空shared_ptr<int> ptr4(nullptr);cout << "ptr4管理的内存引用计数: " << ptr4.use_count() << endl;return 0;
}

在这里插入图片描述

移动构造函数初始化

#include <iostream>
#include <memory>
using namespace std;int main()
{// 使用智能指针管理一块 int 型的堆内存, 内部引用计数为 1shared_ptr<int> ptr1(new int(520));cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;//调用拷贝构造函数shared_ptr<int> ptr2(ptr1);cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;shared_ptr<int> ptr3 = ptr1;cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;//调用移动构造函数shared_ptr<int> ptr4(std::move(ptr1));//移动给ptr4管理cout << "ptr4管理的内存引用计数: " << ptr4.use_count() << endl;std::shared_ptr<int> ptr5 = std::move(ptr2);//给ptr5管理cout << "ptr5管理的内存引用计数: " << ptr5.use_count() << endl;return 0;
}

在这里插入图片描述
如果使用拷贝的方式初始化共享智能指针对象，这两个对象会同时管理同一块堆内存，堆内存对应的引用计数也会增加；如果使用移动的方式初始智能指针对象，只是转让了内存的所有权，管理内存的对象并不会增加，因此内存的引用计数不会变化。

使用make_shared

#include <iostream>
#include <string>
#include <memory>
using namespace std;class Test
{
public:Test(){cout << "construct Test..." << endl;}Test(int x){cout << "construct Test, x = " << x << endl;}Test(string str){cout << "construct Test, str = " << str << endl;}~Test(){cout << "destruct Test ..." << endl;}
};int main()
{// 使用智能指针管理一块 int 型的堆内存, 内部引用计数为 1shared_ptr<int> ptr1 = make_shared<int>(520);cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;cout << endl;shared_ptr<Test> ptr2 = make_shared<Test>();cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;shared_ptr<Test> ptr3 = make_shared<Test>(520);cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;shared_ptr<Test> ptr4 = make_shared<Test>("我是要成为海贼王的男人!!!");cout << "ptr4管理的内存引用计数: " << ptr4.use_count() << endl;return 0;
}

在这里插入图片描述

通过reset方法初始化

#include <iostream>
#include <string>
#include <memory>
using namespace std;int main()
{// 使用智能指针管理一块 int 型的堆内存, 内部引用计数为 1shared_ptr<int> ptr1 = make_shared<int>(520);shared_ptr<int> ptr2 = ptr1;shared_ptr<int> ptr3 = ptr1;shared_ptr<int> ptr4 = ptr1;cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;cout << "ptr4管理的内存引用计数: " << ptr4.use_count() << endl;ptr4.reset();cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;cout << "ptr4管理的内存引用计数: " << ptr4.use_count() << endl;shared_ptr<int> ptr5;ptr5.reset(new int(250));// >>>>>>>> 重置的时候地址要一致cout << "ptr5管理的内存引用计数: " << ptr5.use_count() << endl;return 0;
}

在这里插入图片描述对于一个未初始化的共享智能指针，可以通过reset方法来初始化，当智能指针中有值的时候，调用reset会使引用计数减1。

获取原始指针

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <memory>using namespace std;int main()
{int len = 128;shared_ptr<char> ptr(new char[len]);// 得到指针的原始地址char* add = ptr.get();memset(add, 0, len);strcpy(add, "我是要成为海贼王的男人!!!");cout << "string: " << add << endl;shared_ptr<int> p(new int);*p = 100;cout << *p.get() << "  " << *p << endl;return 0;
}

在这里插入图片描述

shared_ptr的使用

方式1：

share_ptr<Test> ptr5=make_shared<Test>(8);
ptr5.reset(new Test("hello"));Test* t=ptr5.get();
t->setValue(10000);
t->print();

方式2：

ptr5->setValue(121212);
ptr5->print();

指定删除器

这里是自己指定删除器不使用share_ptr自带的删除器
当智能指针管理的内存对应的引用计数变为0的时候，这块内存就会被智能指针析构掉了。另外，我们在初始化智能指针的时候也可以自己指定删除动作，这个删除操作对应的函数被称之为删除器，这个删除器函数本质是一个回调函数，我们只需要进行实现，其调用是由智能指针完成的。
删除器可以在外部写也可以在内部写个匿名函数lambda表达式

指定删除器案例

shared_ptr<Test> ppp(new Test(100),[](Test* t)){//释放内存的操作delete t;
};
shared_ptr<Test> p1(new Test[5],[](Test* t)){//释放内存的操作delete []t;
};

#include <iostream>
#include <memory>
using namespace std;// 自定义删除器函数，释放int型内存
void deleteIntPtr(int* p)
{delete p;cout << "int 型内存被释放了...";
}int main()
{shared_ptr<int> ptr(new int(250), deleteIntPtr);return 0;
}

在这里插入图片描述

deleteIntPtr 函数： deleteIntPtr 函数会收到 shared_ptr 所管理的原始指针 p。然后，delete p; 会释放这块内存。并且在释放内存之后，deleteIntPtr 会打印消息 “int 型内存被释放了…”，指示内存已经被成功释放。

c++自带的删除器

在删除数组内存时，除了自己编写删除器，也可以使用C++提供的std::default_delete()函数作为删除器，这个函数内部的删除功能也是通过调用delete来实现的，要释放什么类型的内存就将模板类型T指定为什么类型即可。具体处理代码如下：

//删除数组类型内存 ---> Test[]
shared_ptr<Test> p2(new Test[5], default_delete<Test[]>());

数组让shared_ptr使用数组

#include <iostream>
#include <memory>
using namespace std;template <typename T>
shared_ptr<T> make_share_array(size_t size)
{// 返回匿名对象return shared_ptr<T>(new T[size], default_delete<T[]>());
}int main()
{shared_ptr<int> ptr1 = make_share_array<int>(10);cout << ptr1.use_count() << endl;shared_ptr<char> ptr2 = make_share_array<char>(128);cout << ptr2.use_count() << endl;return 0;
}

独占智能指针

unique_ptr的初始化

#include <iostream>
#include <memory>
using namespace std;class Test
{
public:Test(int i)	{}void print() { cout << "i: " << i << endl; }
private:int i;
};int main()
{//通过构造函数初始化	unique_ptr<int> ptr1(new int(9));//unique_ptr<int> ptr2 = ptr1;//err >>>>> 独占拥有这段内存//通过移动构造函数初始化unique_ptr<int> ptr2 = move(ptr1);//通过reset初始化ptr2.reset(new int(8));//获取原始指针unique_ptr<Test> ptr3(new Test(1));Test* pt = ptr3.get();pt->print();ptr3->print();
}

在这里插入图片描述

unique_ptr删除器

unique_ptr指定删除器和shared_ptr指定删除器是有区别的，unique_ptr指定删除器的时候需要确定删除器的类型，所以不能像shared_ptr那样直接指定删除器，举例说明：

//传入的删除器的类型为ptrFunc >>>>>>>>> []---> 可以看作函数指针
using ptrFunc = void(*)(Test*);
unique_ptr<Test, ptrFunc> ptr4(new Test("hello"), [](Test* t) {delete t;
});//后面的lambda表达是仿函数因此需要进行包装
unique_ptr<Test, function<void(Test*)>> ptr4(new Test("hello"), [=](Test* t) {delete t;
});//独占的智能指针可以管理数组类型的地址，能够自动释放
unique_ptr<Test[]>ptr5(new Test[3]);
//c++11以后，共享的智能指针可以管理数组类型的地址，能够自动释放
shared_ptr<Test[]>ptr6(new Test[3]);

弱引用智能指针

弱引用智能指针std::weak_ptr可以看做是shared_ptr的助手，它不管理shared_ptr内部的指针。std::weak_ptr没有重载操作符*和->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视shared_ptr中管理的资源是否存在。

weak_ptr初始化

#include <iostream>
#include <memory>
using namespace std;int main() 
{shared_ptr<int> sp(new int);weak_ptr<int> wp1;weak_ptr<int> wp2(wp1);weak_ptr<int> wp3(sp);weak_ptr<int> wp4;wp4 = sp;weak_ptr<int> wp5;wp5 = wp3;return 0;
}

use_count()

#include <iostream>
#include <memory>
using namespace std;int main()
{shared_ptr<int> sp(new int);weak_ptr<int> wp1;weak_ptr<int> wp2(wp1);weak_ptr<int> wp3(sp);weak_ptr<int> wp4;wp4 = sp;weak_ptr<int> wp5;wp5 = wp3;cout << "use_count: " << endl;cout << "wp1: " << wp1.use_count() << endl;cout << "wp2: " << wp2.use_count() << endl;cout << "wp3: " << wp3.use_count() << endl;cout << "wp4: " << wp4.use_count() << endl;cout << "wp5: " << wp5.use_count() << endl;return 0;
}

在这里插入图片描述
通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。

expired()

通过调用std::weak_ptr类提供的expired()方法来判断观测的资源是否已经被释放

#include <iostream>
#include <memory>
using namespace std;int main() 
{shared_ptr<int> shared(new int(10));weak_ptr<int> weak(shared);cout << "1. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;shared.reset();cout << "2. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;return 0;
}

在这里插入图片描述

lock()

通过调用std::weak_ptr类提供的lock()方法来获取管理所监测资源的shared_ptr对象

#include <iostream>
#include <memory>
using namespace std;int main()
{shared_ptr<int> sp1, sp2;weak_ptr<int> wp;sp1 = std::make_shared<int>(520);wp = sp1;sp2 = wp.lock();//wp2=wp1cout << "use_count: " << wp.use_count() << endl;sp1.reset();cout << "use_count: " << wp.use_count() << endl;sp1 = wp.lock();cout << "use_count: " << wp.use_count() << endl;cout << "*sp1: " << *sp1 << endl;cout << "*sp2: " << *sp2 << endl;return 0;
}

reset()

#include <iostream>
#include <memory>
using namespace std;int main() 
{shared_ptr<int> sp(new int(10));weak_ptr<int> wp(sp);cout << "1. wp " << (wp.expired() ? "is" : "is not") << " expired" << endl;wp.reset();cout << "2. wp " << (wp.expired() ? "is" : "is not") << " expired" << endl;return 0;
}

在这里插入图片描述

共享智能指针的注意事项

不能使用一个原始地址初始化多个共享智能指针

在这里插入图片描述

#include <iostream>
#include <memory>
using namespace std;struct Test
{shared_ptr<Test> getSharedPtr(){return shared_ptr<Test>(this);}~Test(){cout << "class Test is disstruct ..." << endl;}};int main()
{Test* t = new Test;//shared_ptr<Test> ptr1(t);//shared_ptr<Test> ptr2(t);shared_ptr<Test> ptr1(t);shared_ptr<Test> ptr2(ptr1);return 0;
}

函数不能返回管理this的共享智能指针对象

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

#include <iostream>
#include <memory>
using namespace std;struct Test
{shared_ptr<Test> getSharedPtr(){return shared_ptr<Test>(this);}~Test(){cout << "class Test is disstruct ..." << endl;}};int main()
{shared_ptr<Test> sp1(new Test);cout << "use_count: " << sp1.use_count() << endl;//这里的this指向的是Test对象 相当于此时的sp2和sp1指向同一个内存shared_ptr<Test> sp2=sp1->getSharedPtr();cout << "use_count: " << sp1.use_count() << endl;return 0;
}

解决方案：
这个问题可以通过weak_ptr来解决，通过wek_ptr返回管理this资源的共享智能指针对象shared_ptr。C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象

#include <iostream>
#include <memory>
using namespace std;struct Test : public enable_shared_from_this<Test>
{shared_ptr<Test> getSharedPtr(){return shared_from_this();}~Test(){cout << "class Test is disstruct ..." << endl;}
};int main()
{shared_ptr<Test> sp1(new Test);// >>>>>>>>>> 此时基类的weak_ptr被初始化了cout << "use_count: " << sp1.use_count() << endl;shared_ptr<Test> sp2 = sp1->getSharedPtr();cout << "use_count: " << sp1.use_count() << endl;return 0;
}

在这里插入图片描述
智能指针内部使用了引用计数（std::shared_ptr）或独占所有权（std::unique_ptr）的机制来管理对象的生命周期。std::shared_ptr 通过引用计数来管理资源。当用一个 std::shared_ptr 初始化另一个 std::shared_ptr 时，新的智能指针将增加该资源的引用计数，而不是直接复制资源。这意味着多个 shared_ptr 可以共享同一个资源，直到最后一个 shared_ptr 被销毁时才释放资源。
在调用enable_shared_from_this类的shared_from_this()方法之前，必须要先初始化函数内部weak_ptr对象，否则该函数无法返回一个有效的shared_ptr对象

共享智能指针不能循环引用

#include <iostream>
#include <memory>
using namespace std;struct TA;
struct TB;struct TA
{shared_ptr<TB> bptr;~TA(){cout << "class TA is disstruct ..." << endl;}
};struct TB
{shared_ptr<TA> aptr;~TB(){cout << "class TB is disstruct ..." << endl;}
};void testPtr()
{shared_ptr<TA> ap(new TA);shared_ptr<TB> bp(new TB);cout << "TA object use_count: " << ap.use_count() << endl;cout << "TB object use_count: " << bp.use_count() << endl;ap->bptr = bp;bp->aptr = ap;cout << "TA object use_count: " << ap.use_count() << endl;cout << "TB object use_count: " << bp.use_count() << endl;
}int main()
{testPtr();return 0;
}

从上面的打印结果来看没有调用析构因此是有问题的，因为 TA 和 TB 之间形成了循环引用，当 testPtr() 函数结束时，局部变量 ap 和 bp 会被销毁，这意味着它们会从栈上被移除。但是，ap 和 bp 持有的 shared_ptr 仍然存在对 TA 和 TB 对象的引用，因此它们的引用计数依然是 2。即使 testPtr 函数结束，但是由于引用计数没有降为 0，它们的析构函数不会被调用，导致内存泄漏。
在这里插入图片描述
解决方案：

#include <iostream>
#include <memory>
using namespace std;struct TA;
struct TB;struct TA
{weak_ptr<TB> bptr;~TA(){cout << "class TA is disstruct ..." << endl;}
};struct TB
{shared_ptr<TA> aptr;~TB(){cout << "class TB is disstruct ..." << endl;}
};void testPtr()
{shared_ptr<TA> ap(new TA);shared_ptr<TB> bp(new TB);cout << "TA object use_count: " << ap.use_count() << endl;cout << "TB object use_count: " << bp.use_count() << endl;ap->bptr = bp;bp->aptr = ap;cout << "TA object use_count: " << ap.use_count() << endl;cout << "TB object use_count: " << bp.use_count() << endl;
}int main()
{testPtr();return 0;
}

在这里插入图片描述

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

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

相关文章

应急车道占用检测算法的技术方案与应用

应急车道占用检测算法的技术方案与应用

应急车道是高速公路上的生命通道&#xff0c;专门用于救护车、消防车、警车等紧急车辆通行&#xff0c;帮助应对突发状况。然而&#xff0c;一些驾驶员出于各种原因违规占用应急车道&#xff0c;阻碍救援车辆的正常通行&#xff0c;导致交通救援效率大幅下降&#xff0c;甚至加…
阅读更多...
卡尔曼滤波算法Kalman filter algorithm

卡尔曼滤波算法Kalman filter algorithm

一、假如 状态向量服从高斯分布&#xff1a; 而且状态转移是线性的&#xff1a; 测量是状态的线性关系&#xff08;带噪声&#xff09; 初始状态的置信度也是正态分布 二、卡尔曼滤波的算法流程为 疑问&#xff1a;多测量融合&#xff0c;是不是用不同的传感器测量值去重复5…
阅读更多...
java_继承

java_继承

1.为啥用 继承? Pupil类 package com.hspedu.extend;// 小学生->模拟小学生考试的情况 public class Pupil {public String name;public int age;private double score;public void setScore(double score) {this.score score;}public void testing() {System.out.printl…
阅读更多...
Redis 缓存击穿

Redis 缓存击穿

目录 缓存击穿 什么是缓存击穿&#xff1f; 有哪些解决办法&#xff1f; 缓存穿透和缓存击穿有什么区别&#xff1f; 缓存雪崩 什么是缓存雪崩&#xff1f; 有哪些解决办法&#xff1f; 缓存预热如何实现&#xff1f; 缓存雪崩和缓存击穿有什么区别&#xff1f; 如何保…
阅读更多...
【Redis的安装以及主从复制的搭建】配置Redis的哨兵模式

【Redis的安装以及主从复制的搭建】配置Redis的哨兵模式

文章目录 一、安装Redis1、上传、解压、重命名2、安装GCC环境3、编译源码4、进行安装5、修改配置文件redis.conf 二、Redis主从复制搭建1、创建文件夹用来实现主从复制 三、配置Redis的哨兵模式1、创建文件夹2、修改sentinel.conf配置文件3、启动 一、安装Redis 1、上传、解压…
阅读更多...
WPF中的转换器

WPF中的转换器

单值转换器 1.创建项目后下载两个NuGet程序包 2.先定义一个转换器实现IValueConverter接口 using System; using System.Collections.Generic; using System.Globalization; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows; usin…
阅读更多...
GEE Ui——批量查询Sentinel-2 图像无云区域的可视化应用（提供缩略图）

GEE Ui——批量查询Sentinel-2 图像无云区域的可视化应用（提供缩略图）

目录 简介 功能选项 函数 Map.clear() No arguments. Returns: ui.Map Map.onClick(callback) Arguments: Returns: String reduceRegion(reducer, geometry, scale, crs, crsTransform, bestEffort, maxPixels, tileScale) Arguments: Returns: Dictionary toLis…
阅读更多...
汇编练习-1

汇编练习-1

1、要求 练习要求引自《汇编语言-第4版》实验10.3(P209页) -编程&#xff0c;将data段中的数据&#xff0c;以10进制的形式显示出来 data segment dw 123,12666,1,8,3,38 data ends 2、实现代码(可惜没找到csdn对8086汇编显示方式) assume cs:codedata segmentdw 16 dup(0) ;除…
阅读更多...
xml格式转为txt格式？

xml格式转为txt格式？

数据集的标签格式为xml格式&#xff0c;转为yolo的训练格式&#xff1a; 1.创建一个格式转化的.py文件将下面代码复制&#xff1a; import os import glob import xml.etree.ElementTree as ETdef get_classes(classes_path):with open(classes_path, encodingutf-8) as f:cl…
阅读更多...
M - Weird Ceiling 【CCPC2024哈尔滨站】

M - Weird Ceiling 【CCPC2024哈尔滨站】

M - Weird Ceiling 思路: 注意到 f ( n , i ) f(n,i) f(n,i) 的值为 n y ( i ) \frac{n} {y(i)} y(i)n​ &#xff0c;其中 y ( i ) y(i) y(i) 为 n n n 小于等于 i i i 的最大因数。 那么先找到 n n n的所有因数&#xff0c;包括 1 1 1和它本身&#xff0c;在数组a[]中升…
阅读更多...
机器学习与数学公式

机器学习与数学公式

目录 在机器学习中&#xff0c;将公式应用到算法程序上主要涉及以下几个步骤&#xff1a; 1、数学公式转换成编程逻辑&#xff1a; 2、选择合适的编程语言和工具&#xff1a; 3、使用矩阵运算和优化方法&#xff1a; 4、实现算法逻辑&#xff1a; 5、将公式封装成函数…
阅读更多...
基于微信小程序的校园失物招领系统的研究与实现（V4.0）

基于微信小程序的校园失物招领系统的研究与实现（V4.0）

博主介绍&#xff1a;✌stormjun、8年大厂程序员经历。全网粉丝15w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;&…
阅读更多...
芯突破 | 国产PCIe桥接芯片掀起的连接革命

芯突破 | 国产PCIe桥接芯片掀起的连接革命

PCIe桥接芯片应运而生 随着计算机技术的快速发展&#xff0c;硬件性能不断提升&#xff0c;数据传输速度的需求日益增长&#xff0c;PCIe总线凭借其高带宽和低延迟的优势&#xff0c;已经成为主流。然而&#xff0c;由于不同设备和PCIe总线之间的接口差异&#xff0c;直接连接…
阅读更多...
6款高效网页界面原型设计软件：提升设计效率的利器

6款高效网页界面原型设计软件：提升设计效率的利器

在网页设计领域&#xff0c;原型设计是将创意转化为实际产品的关键环节。一款优秀的网页界面原型设计软件能够帮助设计师快速、准确地呈现设计思路&#xff0c;优化用户体验&#xff0c;并提高团队协作效率。以下是6款在网页界面原型设计方面表现出色的软件。 1. 即时设计 即…
阅读更多...
计算机网络综合题

计算机网络综合题

IP数据报的划分 CRC差错检测 冗余码的计算 因此&#xff0c;余数是1110&#xff0c;传输的数为11010110111110。在传输过程中最后两位变成o&#xff0c;接收端能够发现&#xff0c;因为11010110111110除以10011余数不为0。 子网划分 暴力求解法 &#xff08;定长子网划分大量…
阅读更多...
对比JavaScript、C、Python在声明变量后未初始化处理上的差异与深度解析

对比JavaScript、C、Python在声明变量后未初始化处理上的差异与深度解析

文章目录 &#x1f4af;前言&#x1f4af;三者声明变量后未初始化的不同默认行为JavaScriptC语言Python &#x1f4af;JavaScript中的变量管理作用域与变量声明Hoisting&#xff08;变量提升&#xff09;var的思考与缺陷 &#x1f4af;C语言中的变量管理内存模型概述变量的作用…
阅读更多...
Day105：代码审计-PHP原生开发篇SQL注入数据库监控正则搜索文件定位静态分析

Day105：代码审计-PHP原生开发篇SQL注入数据库监控正则搜索文件定位静态分析

Day105&#xff1a;代码审计-PHP原生开发篇&SQL注入&数据库监控&正则搜索&文件定位&静态分析_php代码审计实战-CSDN博客 知识点&#xff1a; 1、PHP审计-原生态开发-SQL注入&语句监控 2、PHP审计-原生态开发-SQL注入&正则搜索 3、PHP审计-原生态…
阅读更多...
零基础‘自外网到内网’渗透过程详细记录(cc123靶场)——上

零基础‘自外网到内网’渗透过程详细记录(cc123靶场)——上

一、网络环境示意图 二、环境搭建 首先将三个虚拟机使用VMware打开。 接下来对虚拟机进行配置。 首先配置虚拟机“护卫神主机大师(项目四)”。 点击编辑虚拟机设置。 发现存在两个网卡。 打开虚拟网络编辑器。 点击更改设置。 点击添加网络。 选择VM19后点击确定。 根据网络…
阅读更多...
架构师必修之项目篇：基于ASR+GPT4.0+TTS实现全双工智能语音助手

架构师必修之项目篇：基于ASR+GPT4.0+TTS实现全双工智能语音助手

1. 系统架构设计 1.1 ASR模块设计 ASR&#xff08;Automatic Speech Recognition&#xff09;模块是全双工智能语音助手的前端入口&#xff0c;负责将用户的语音输入转换为文本数据。该模块的设计关键在于高准确率的语音识别和快速响应。 语音信号预处理&#xff1a;首先对采集…
阅读更多...
为什么说PPQ对于FPGA的神经网络的量化来说是神？

为什么说PPQ对于FPGA的神经网络的量化来说是神？

这几天踩了无数坑把PPQ走通了&#xff0c;把自己搭的一个网络实现了完美量化&#xff0c;测试结果也可以正常分类。看到结果终于明白为什么说PPQ对于FPGA的神经网络的量化来说是神了 虔诚地放出链接&#xff1a; OpenPPL/ppq PS&#xff1a;这辈子要是能去商汤就好了…… 一、 …
阅读更多...
最新文章

Copyright @ 2022~2023