【C++】C++11新特性:列表初始化、声明、新容器、右值引用、万能引用和完美转发

news2025/1/20 17:10:42

目录

一、列表初始化

1.1 { } 初始化

1.2 std::initializer_list

二、声明

2.1 auto

2.2 decltype

2.3 nullptr

三、新容器

四、右值引用和移动语义

4.1 左值和左值引用

4.2 右值和右值引用 

4.3 左值引用与右值引用比较

4.4 右值引用使用场景和意义:移动构造、移动赋值

4.5右值引用引用左值及其一些更深入的使用场景分析

五、万能引用和完美转发

5.1 万能引用

5.2 完美转发


一、列表初始化

1.1 { } 初始化

在C++98中,标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如:

struct Point
{
	int _x;
	int _y;
};

int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };

	return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围,使其可用于所有的内置类型和用户自
定义的类型,使用初始化列表时可以省略赋值符号,即可以添加等号(=),也可以不添加。 

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

 //一切都可以用列表初始化
 //并且可以省略掉=
int main()
{
	int i = 0;
	int j = { 0 };
	int k{ 0 };

	int array1[]{ 1, 2, 3, 4, 5 };
	int array2[5]{ 0 };
	Point p{ 1, 2 };

    //创建对象时也可以使用列表初始化方式调用构造函数初始化
	Date d1(1949, 10, 1);//构造函数

	// 类型转换:  构造+拷贝构造->编译器优化为直接构造
	Date d2 = { 1949, 10, 2 };
	Date d3{ 1949, 10, 3 };

	//单参数的构造函数支持隐式类型转换
	string s1 = "xxxx";

	const Date& d4 = { 1949, 10, 1 };

	Date* p1 = new Date[3]{ d1, d2, d3 };
	Date* p2 = new Date[3]{ {1949, 10, 1}, {1949, 10, 2}, {1949, 10, 3} };

	return 0;
}

1.2 std::initializer_list

在 C++11 中,initializer_list 是一个新的模板类型,它是 std::initializer_list<T> 的缩写,用于表示一组值的集合。std::initializer_list的介绍文档

查看std::initializer_list是什么类型:

int main()
{
    // the type of il is an initializer_list 
    auto il = { 10, 20, 30 };
    cout << typeid(il).name() << endl;
    return 0;
}

使用场景:std::initializer_list一般是作为构造函数的参数,C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数,例如vector、list和map,这样初始化容器对象就更方便了。也可以作为operator=的参数,这样就可以用大括号赋值。

在下面的示例中。

  • Date d2 = { 1949, 10, 1 };的列表不转换成initializer_list,而是通过构造函数构造临时对象,再通过拷贝构造赋给d2。
  • initializer_list支持迭代器和范围for。
  • 在map<string, string> dict = {{"insert", "插入"}, {"get","获取"} };使用 initializer_list 直接在初始化表达式中指定键值对,不需要显式地创建一个临时对象
int main()
{
	//默认识别成initializer_list
	vector<int> v1 = { 1,2,3,4 };
	vector<int> v2 = { 1,2,3,4,5,6};

	v1 = { 10,20,30 };

	list<int> lt = { 10,20,30 };

	// 多参数构造类型转换  构造+拷贝构造->优化直接构造
	// 跟对应构造函数参数个数匹配
	Date d2 = { 1949, 10, 2 };

	initializer_list<int> il2 = { 10, 20, 30};

	initializer_list<int>::iterator it2 = il2.begin();
	while (it2 != il2.end())
	{
		cout << *it2 << " ";
		++it2;
	}
	cout << endl;
	
	//for (int e : il2)
	for (auto e : il2)
	{
		cout << e << " ";
	}
	cout<< endl;

	pair<string, string> kv1("sort", "排序");
	map<string, string> dict = {{"insert", "插入"}, {"get","获取"} };
	for (auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}

	Date dd2 = { 1949, 10, 1 };
	//Date dd3 = { 1949, 10, 1, 20};

	return 0;
}

二、声明

2.1 auto

在C++98中auto是一个存储类型的说明符,表明变量是局部自动存储类型,但是局部域中定义局
部的变量默认就是自动存储类型,所以auto就没什么价值了。C++11中废弃auto原来的用法,将
其用于实现自动类型推断,它允许编译器自动推导变量的类型。使用auto必须进行显示初始化,让编译器将定义对象的类型设置为初始化值的类型。

2.2 decltype

在 C++11 中,decltype 是一个关键字,用于返回表达式的类型。decltype 通常与 auto 一起使用,以提供更加灵活和强大的类型推断能力。

decltype推导出来的类型可以用来当作模板实参,或者定义对象。(typeid获取的类型不能用来定义对象)

int main()
{
	int i = 1;
	double d = 2.2;

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

	// typeid(i).name() j; //typeid获取的类型不能用来定义对象
	auto j = i;

	auto ret = i * d;
	decltype(ret) x;

	// 用ret的类型去实例化vector
	// decltype可以推导对象的类型。这个类型是可以用
	// 用来模板实参,或者再定义对象
	vector<decltype(ret)> v;
	v.push_back(1);
	v.push_back(1.1);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

2.3 nullptr

由于C++中NULL被定义成字面量0,这样就可能回带来一些问题,因为0既能指针常量,又能表示
整形常量。所以出于清晰和安全的角度考虑,C++11中新增了nullptr,用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

三、新容器

用橘色圈起来是C++11中的一些几个新容器,但是实际最有用的是unordered_map和
unordered_set。这两个我前面已经进行了非常详细的讲解,其他的大家了解一下即可。

C语言没有办法进行很好的越界检查(C语言是抽查),[ ]就可以检查出来读/写是否越界。
array很少用,因为已经有了vector。forward_list只有头插头删。

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法,但是其实很多都是用得
比较少的。
比如提供了cbegin和cend方法返回const迭代器等等,但是实际意义不大,因为begin和end也是
可以返回const迭代器的,这些都是属于锦上添花的操作

四、右值引用和移动语义

4.1 左值和左值引用

传统的C++语法中就有引用的语法,而C++11中新增了的右值引用语法特性,所以从现在开始我们
之前学习的引用就叫做左值引用。无论左值引用还是右值引用,都是给对象取别名。

什么是左值?什么是左值引用?

  • 左值是一个表示数据的表达式(如变量名或解引用的指针),我们可以获取它的地址并且可以对它赋值。
  • 左值可以出现赋值符号的左边,也可以出现在右边,右值不能出现在赋值符号左边。
  • 定义时const修饰符后的左值,不能给他赋值,但是可以取它的地址。
  • 左值引用就是给左值的引用,给左值取别名。
  • 区分左值和右值要看能不能取它的地址,能取地址的是左值,不能取地址的是右值。
int main()
{
	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	// 以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}

4.2 右值和右值引用 

什么是右值?什么是右值引用?

  1. 右值也是一个表示数据的表达式,如:字面常量、表达式返回值,函数返回值(这个不能是左值引用返回)等等。
  2. 右值可以出现在赋值符号的右边,但是不能出现出现在赋值符号的左边。
  3. 右值不能取地址。
  4. 右值引用就是对右值的引用,给右值取别名。
int main()
{
	double x = 1.1, y = 2.2;
	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);
	// 以下几个都是对右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	// 这里编译会报错:error C2106: “=”: 左操作数必须为左值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;
	return 0;
}

4.3 左值引用与右值引用比较

右值引用总结:

  1. 左值引用只能引用左值,不能引用右值。
  2. 但是const左值引用既可引用左值,也可引用右值。

右值引用总结:

  1. 左值引用不能给右值取别名,但是const左值引用可以。
  2. 右值引用不能给左值取别名,但是右值引用可以给move(左值)取别名
int main()
{
	int i = 0;
	int j = i;
	
	// 左值引用能否给右值取别名?不能,但是const左值引用可以
	//int& r1 = 10;//出错
	const int& r2 = i + j;

	int&& rr1 = 10;
	int&& rr2 = i+j;

	// 右值引用能否给左值取别名?不能,但是右值引用可以给move(左值)取别名
	//int&& rr3 = i;//出错
	int&& rr4 = move(i);

	return 0;
}

4.4 右值引用使用场景和意义:移动构造、移动赋值

右值引用的主要目的是为了优化性能,特别是在实现移动语义时,可以避免不必要的拷贝操作,提高性能。

移动语义:
在 C++ 中,当一个对象被另一个对象所需要时,通常会发生拷贝操作。例如,当函数需要一个对象作为参数时,通常会创建该对象的一个副本。
使用右值引用,可以避免这种不必要的拷贝操作,而是直接移动(move)对象。这被称为移动语义,它通常比拷贝操作更快,因为它不涉及创建副本,而是直接移动对象的数据。

注:右值引用的移动语义对于深拷贝的类有意义,对于自定义类型浅持贝的类无意义,例如Date

例如swap函数在C++11中进行改变:

 自定义类型使用右值引用的场景:

namespace mystring
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str) -- 构造" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;


			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = strlen(_str);
			_capacity = s._capacity + 1;
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;
			/*string tmp(s);
			swap(tmp);*/
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);

				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0; // 不包含最后做标识的\0
	};

	mystring::string to_string(int x)
	{
		mystring::string ret;
		while (x)
		{
			int val = x % 10;
			x /= 10;
			ret += ('0' + val);
		}

		reverse(ret.begin(), ret.end());

		return ret;
	}
}

int main()
{
	mystring::string s ;
	s = mystring::to_string(1234);

	return 0;
}

Debug版本下:

release版本下:(连续的构造加拷贝构造优化为一次直接构造) 

 

发生许多次构造的原因:

    mystring::string to_string(int x)
    {
        mystring::string ret;
        while (x)
        {
            int val = x % 10;
            x /= 10;
            ret += ('0' + val);
        }

        reverse(ret.begin(), ret.end());

        return ret;
    }

to_string会创建、构造一个ret,ret在栈上有自己空间,在返回时传给返回值临时对象,使用拷贝构造,并且该临时对象也在栈上有自己的空间,返回时使用赋值重载,并将ret和临时对象使用的空间释放。这种拷贝操作就是不必要的拷贝操作。即使release版本优化后也会浪费时间和空间。

这时就要使用移动构造和移动赋值。 

		// 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;

			swap(s);
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s)-- 移动赋值" << endl;

			swap(s);
			return *this;
		}

Debug版本: 

release版本:

可以看到return ret 给临时对象不再是深拷贝,而是直接交换,临时对象给s赋值时也是移动赋值,直接交换数据,这时ret和临时对象出作用域销毁时直接把s原本的不用的数据顺便销毁了。

4.5右值引用引用左值及其一些更深入的使用场景分析

按照语法,右值引用只能引用右值,但右值引用一定不能引用左值吗?

因为有些场景下,可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时,可以通过move函数将左值转化为右值。C++11中,std::move()函数位于头文件中,该函数名字具有迷惑性,它并不搬移任何东西,唯一的功能就是将一个左值强制转化为右值引用,然后实现移动语义。

//move的定义
//template<class _Ty>
//inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
//{
//	// forward _Arg as movable
//	return ((typename remove_reference<_Ty>::type&&)_Arg);
//}

int main()
{
	mystring::string s1("hello world");
	// 这里s1是左值,调用的是拷贝构造
	mystring::string s2(s1);
	// 这里我们把s1 move处理以后, 会被当成右值,调用移动构造
	// 但是这里要注意,一般是不要这样用的,因为我们会发现s1的
	// 资源被转移给了s3,s1被置空了。
	mystring::string s3(std::move(s1));
	return 0;
}

STL容器插入接口函数也增加了右值引用版本:

五、万能引用和完美转发

5.1 万能引用

在 C++11 之前,模板参数默认情况下是左值引用。这意味着模板函数或模板模板参数默认只能接收左值引用类型的参数。为了接收右值引用类型的参数,需要显式地指定模板参数为右值引用。

C++11 引入了万能引用的概念,使得模板参数可以同时接受左值引用和右值引用类型的参数。万能引用通常是通过模板参数上的 && 类型参数来实现的,例如:

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>
void PerfectForward(T&& t)
{
	Fun(t);
}

特点: 

  • 模板中的&&不代表右值引用,而是万能引用,其既能接收左值又能接收右值。
  • 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力,
  • 但是引用类型的唯一副作用就是限制了接收的类型,参数在后续使用中都退化成了左值
  • 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发

右值不能直接修改,但是右值被右值引用后,需要被修改,否则无法实现移动构造和移动赋值(也就无法转移资源)。这就需要右值引用的属性是左值才能修改。

为什么万能引用的参数在后续使用中都退化成了左值,如何确定实参的属性?

具体来说,当一个函数模板接受一个右值引用类型的参数时,这个参数在函数内部被视为右值。但是,一旦该参数被传递给函数,它的引用特性就会退化,因为它在函数内部被绑定到一个具体的对象上,而这个对象在函数内部是可修改的。这种绑定会改变参数的语义,使其在后续的使用中被视为左值。

这样可以确保函数内部对参数的修改不会影响到外部环境中的原始对象。但是,这也意味着函数内部不能直接使用右值引用的语义来执行某些操作,例如移动语义。

为了解决这个问题,C++11 引入了 std::forward 模板,它可以用来转发参数,保持参数的引用特性不变。这种方法也叫做完美转发。

上面说到STL容器插入接口函数也增加了右值引用版本,其实也是增加了万能引用版本,在内部实现时可以使用完美转发确定实参的属性(左值/右值),进而进行相应的操作。

例如右值被万能引用后,这个引用是左值,必要时需要move()转换为右值。 

5.2 完美转发

完美转发是指在函数模板或类模板中转发参数时,保持参数类型的引用特性不变。这意味着如果原始参数是左值引用,转发后的参数也是左值引用;如果原始参数是右值引用,转发后的参数也是右值引用。

C++11 提供了两种方法来实现完美转发:

1. 通过万能引用:

template<typename T>
void PerfectForward(T&& t)
{

    // 这里 t 保持原始参数的引用特性
    Fun(std::forward<T>(t));// 使用 std::forward 进行转发
}

注:如果 T 被推断为右值引用类型(例如 T 被推断为 int&&),那么 std::forward<T>(t) 将返回一个右值引用,这意味着它返回的是一个临时的右值,而不是 t 本身变成右值。

2. 针对Fun传入的参数调用特定的函数模板:

template <typename T>
void Func(const T& t)

{}

template <typename T>

void Func(T&& t)

{}

完美转发中实际的使用场景:

	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		list_node(const T& x = T())
			:_data(x)
			,_next(nullptr)
			,_prev(nullptr)
		{}

		list_node(T&& x)
			:_data(move(x))
			, _next(nullptr)
			, _prev(nullptr)
		{}

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

	// T T& T*
	// T cosnt T& const T*
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}

		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

		//typedef __list_const_iterator<T> const_iterator;

		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end() const
		{
			return const_iterator(_head);
		}

		iterator begin()
		{
			//return iterator(_head->_next);
			return _head->_next;
		}

		iterator end()
		{
			//return iterator(_head->_next);
			return _head;
		}

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			_size = 0;
		}

		list()
		{
			empty_init();
		}

		// lt2(lt1)
		list(const list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		// lt3 = lt1
		list<int>& operator=(list<int> lt)
		{
			swap(lt);

			return *this;
		}

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		void push_back(const T& x)
		{
			insert(end(), x);
		}

		void push_back(T&& x)
		{
			insert(end(), forward<T>(x));
		}

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

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		void pop_front()
		{
			erase(begin());
		}

		void pop_back()
		{
			erase(--end());
		}

		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);

			Node* prev = cur->_prev;

			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;

			return iterator(newnode);
		}

		iterator insert(iterator pos, T&& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(forward<T>(x));

			Node* prev = cur->_prev;

			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			++_size;

			return iterator(newnode);
		}

		iterator erase(iterator pos)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			delete cur;
			prev->_next = next;
			next->_prev = prev;

			--_size;

			return iterator(next);
		}

		size_t size()
		{
			return _size;
		}

	private:
		Node* _head;
		size_t _size;
	};

为了实现万能引用,模拟实现的list中分别实现左值和右值的insert和push_back。如下:
iterator insert(iterator pos, const T& x)
iterator insert(iterator pos, T&& x)
void push_back(const T& x)
​​​​​​​void push_back(T&& x)

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

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

相关文章

chap5 CNN

卷积神经网络&#xff08;CNN&#xff09; 问题描述&#xff1a; 利用卷积神经网络&#xff0c;实现对MNIST数据集的分类问题 数据集&#xff1a; MNIST数据集包括60000张训练图片和10000张测试图片。图片样本的数量已经足够训练一个很复杂的模型&#xff08;例如 CNN的深层…

Visual Studio Code使用(C++项目新建,运行)

VS Code 直接在官网下载安装。 接下来安装插件&#xff0c;下图是C所需的对应插件 1.新建项目 VS Code下载安装完成后&#xff0c;直接进入欢迎页&#xff1a; 在访达/文件夹中新建一个文件夹&#xff0c;欢迎页点击【打开】&#xff0c;选择刚刚新建的文件夹。点击第一个图…

MT8781安卓核心板_MTK联发科Helio G99核心板规格参数

MT8781安卓核心板采用先进的台积电6纳米级芯片生产工艺&#xff0c;配备高性能Arm Cortex-A76处理器和Arm Mali G57 GPU&#xff0c;加上LPDDR4X内存和UFS 2.2存储&#xff0c;在处理速度和数据访问速度上都有着出色的表现。 MT8781还支持120Hz显示器&#xff0c;无需额外的DSC…

vue3学习(六)

前言 接上一篇学习笔记&#xff0c;今天主要是抽空学习了vue的状态管理&#xff0c;这里学习的是vuex&#xff0c;版本4.1。学习还没有学习完&#xff0c;里面有大坑&#xff0c;难怪现在官网出的状态管理用Pinia。 一、vuex状态管理知识点 上面的方式没有写全&#xff0c;还有…

QT软件界面的设计与启动方法

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、Q T界面设计的重要性 二、QT软件的启动与配置 三、QT软件的启动路径设置 四、QT软件启…

Linux--EXT2文件系统

参考资料&#xff1a; linux之EXT2文件系统--理解block/block group/索引结点inode/索引位图_一个块组中索引节点表和数据块区最多占用字节-CSDN博客 linux环境&#xff1a; Linux version 5.15.146.1-microsoft-standard-WSL2 (root65c757a075e2) (gcc (GCC) 11.2.0, GNU ld…

Llama改进之——分组查询注意力

引言 今天介绍LLAMA2模型引入的关于注意力的改进——分组查询注意力(Grouped-query attention,GQA)1。 Transformer中的多头注意力在解码阶段来说是一个性能瓶颈。多查询注意力2通过共享单个key和value头&#xff0c;同时不减少query头来提升性能。多查询注意力可能导致质量下…

C++双层Vector容器详解

双层Vector容器 关于C中二维vector使用 双层vector的运用细节 插入元素 //正确的插入方式 vector<vector<int> > A; //A.push_back里必须是vector vector<int> B; B.push_back(0); B.push_back(1); B.push_back(2); A.push_back(B); B.clear(); B.push_back…

AI边缘计算盒子在智慧交通的应用

方案背景 随着经济增长&#xff0c;交通出行需求大幅增长&#xff0c;但道路建设增长缓慢&#xff0c;交通供需矛盾日益显著&#xff0c;中心城区主要道路高峰时段交通拥堵严重&#xff0c;道路交通拥堵逐渐常态化&#xff0c;成为制约城市可持续发展的重要因素之一。 痛点问题…

python移位操作符(左移位操作符<<、右移位操作符>>)(允许开发者对整数进行位操作,乘2或除2)(左移操作、右移操作)(位掩码操作|=)

文章目录 Python 中的移位操作符详解移位操作符简介左移位操作符 (<<)语法和使用示例代码输出 右移位操作符 (>>)语法和使用示例代码输出 移位操作符的应用场景快速乘除运算&#xff1a;使用移位操作符代替传统的乘法和除法运算&#xff0c;可以提高计算速度。位掩…

3位新加坡华人交易员分享:交易策略、风险管理与心态

交易与投资似乎是一对“双胞胎”,它们都是金融市场中获得收益的重要途径。 区别在于投资者购买自以为长期将有出色业绩的资产组合&#xff0c;并且长期持有这些资产组合&#xff0c;交易者依靠交易技巧借助资产工具价格瞬息波动在短期内产生利润。交易资产的手段有&#xff0c…

MySQL统计字符长度:CHAR_LENGTH(str)

对于SQL表&#xff0c;用于计算字符串中字符数的最佳函数是 CHAR_LENGTH(str)&#xff0c;它返回字符串 str 的长度。 另一个常用的函数 LENGTH(str) 在这个问题中也适用&#xff0c;因为列 content 只包含英文字符&#xff0c;没有特殊字符。否则&#xff0c;LENGTH() 可能会返…

unicloud 云对象

背景和优势 20年前&#xff0c;restful接口开发开始流行&#xff0c;服务器编写接口&#xff0c;客户端调用接口&#xff0c;传输json。 现在&#xff0c;替代restful的新模式来了。 云对象&#xff0c;服务器编写API&#xff0c;客户端调用API&#xff0c;不再开发传输json…

AI图书推荐:使用GitHub Copilot和ChatGPT辅助的Python编程

使用Python编写计算机程序变得更加简单了&#xff01;使用像GitHub Copilot和ChatGPT这样的AI辅助编码工具&#xff0c;将你的想法快速转化为应用程序。人工智能已经改变了我们编写计算机程序的方式。有了像Copilot和ChatGPT这样的工具&#xff0c;你可以用简单的英语描述你想要…

QT5:调用qt键盘组件实现文本框输入

目录 一、环境与目标 二、Qt VirtualKeyboard 1.勾选Qt VirtualKeyboard 2.ui设计流程 3.注意事项及问题点 三、参考代码 参考博客 一、环境与目标 qt版本&#xff1a;5.12.7 windows 11 下的 Qt Designer &#xff08;已搭建&#xff09; 目标&#xff1a;创建一个窗…

【Nacos源码分析01-服务注册与集群间数据是同步】

文章目录 了解CAPBASE理论Nacos支持CP还是AP集群数据同步实现集群数据一致性源码 了解CAP CAP理论的核心观点是&#xff0c;一个分布式系统无法同时完全满足一致性、可用性和分区容错性这三个特性。具体而言&#xff0c;当发生网络分区时&#xff0c;系统必须在一致性和可用性之…

【Vue】v-for中的key

文章目录 一、引入问题二、分析问题 一、引入问题 语法&#xff1a; key属性 "唯一值" 作用&#xff1a;给列表项添加的唯一标识。便于Vue进行列表项的正确排序复用。 为什么加key&#xff1a;Vue 的默认行为会尝试原地修改元素&#xff08;就地复用&#xff09;…

华媒舍:10种欧洲地区媒体发稿推广技巧

1.了解欧洲地区媒体自然环境必须掌握欧洲地区媒体的发稿推广方法&#xff0c;首先要对欧洲地区媒体自然环境有一定的了解。包含不一样国家的主力媒体&#xff0c;他的阅读者人群、销售市场遮盖及其报导风格等。仅有熟悉媒体自然环境&#xff0c;才能更好的制订营销推广策略。 …

【Unity Shader入门精要 第11章】让画面动起来(一)

1. Unity Shader中的时间变量 Shader控制这物体的显示&#xff0c;当向Shader中引入时间变量后&#xff0c;就可以让物体的显示效果随时间发生变化&#xff0c;以实现动画效果。 Unity中常见的时间变量如下表&#xff1a; 变量类型描述_Timefloat4(t/20, t, 2t, 3t)&#xf…

Visual Studio 2022创建dll并调用

需求&#xff1a; 创建A项目&#xff0c;有函数和类&#xff0c;将A项目生成DLL动态链接库 创建B项目&#xff0c;使用A项目生成的dll和lib相关文件 正常项目开发.h用于函数声明&#xff0c;.cpp用于函数实现&#xff0c;但是项目开发往往不喜欢将.cpp函数实现的代码发给别人&…