【C++11】:统一的列表初始化|声明|STL变化

这篇具有很好参考价值的文章主要介绍了【C++11】:统一的列表初始化|声明|STL变化。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

                                               🎬慕斯主页修仙—别有洞天

                                              ♈️今日夜电波:マイノリティ脈絡—ずっと真夜中でいいのに。

                                                                0:24━━━━━━️💟──────── 4:02
                                                                    🔄   ◀️   ⏸   ▶️    ☰  

                                      💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍


目录

统一的列表初始化

使用初始化列表时,可添加等号(=),也可不添加

创建对象时也可以使用列表初始化方式调用构造函数初始化

std::initializer_list

基本概念

使用场景

底层原理

注意事项

声明

auto

decltype

nullptr

STL中的变化

array

1. 包含头文件

2. 定义array

3. 初始化array

4. 访问array元素

5. array成员函数

6. array与内置数组的区别

forward_list

1. 包含头文件

2. 定义和初始化 forward_list

3. 访问 forward_list

4. 插入和删除元素

5. 其他操作

注意事项


统一的列表初始化

        在C++98中,标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定,而C++11扩大了用大括号括起的列表(初始化列表)的使用范围,使其可用于所有的内置类型和用户自定义的类型,使用初始化列表时,可添加等号(=),也可不添加

使用初始化列表时,可添加等号(=),也可不添加

  struct test
  {
  	int _x;
  	char _str;
  };
  
  int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	test aa = { 2,'r' };
	int x1 = 1;
  
	//C++11后以下也支持:
	int x2{ 2 };
	int array3[]{ 1, 2, 3, 4, 5 };
	int array4[5]{ 0 };
	test bb{ 2,'s' };

创建对象时也可以使用列表初始化方式调用构造函数初始化

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()
{
	Date d1(2022, 1, 1); // old style
  
	// C++11后支持的列表初始化,这里会调用构造函数初始化
	Date d2{ 2022, 1, 2 };
	Date d3 = { 2022, 1, 3 };
	return 0;

  const Date& d4 = { 2023, 11, 25 };
  
  Date* p1 = new Date[3]{ d1, d2, d3 };
 	Date* p2 = new Date[3]{ {2022, 11, 25}, {2022, 11, 26}, {2022, 11, 27} };
}

        需要注意的是:上述使用列表初始化方式Date d3 = { 2022, 1, 3 }的本质也是类型转换 构造+拷贝构造-》优化直接构造

std::initializer_list

    std::initializer_list 是C++11标准引入的一个模板类,用于表示对象的初始化列表。它提供了一种方便的方式来初始化对象,尤其是在构造函数和函数中处理可变数量的参数时。下面是对 std::initializer_list 的详细解释:

基本概念

    std::initializer_list 是一个轻量级的只读容器,它内部维护了一个指向堆上的数组以及该数组的长度。它不支持添加、删除元素等操作,但可以使用迭代器访问元素,以及使用 size() 函数获得容器长度

        当使用花括号 {} 进行列表初始化时,编译器会尝试构造一个 std::initializer_list 对象。例如:

std::initializer_list<int> ilist = {1, 2, 3, 4, 5};

        在这个例子中,ilist 是一个 std::initializer_list<int> 类型的对象,它包含5个整数。

 

使用场景

        构造函数和赋值运算符:如果类的构造函数或赋值运算符接受一个 std::initializer_list 参数,那么可以使用花括号初始化列表来初始化或赋值对象。

class MyClass {
public:
    MyClass(std::initializer_list<int> list) {
        // 处理 list 中的元素
    }
};

MyClass obj({1, 2, 3}); // 使用 std::initializer_list 构造函数

         函数参数:函数也可以接受 std::initializer_list 参数,从而能够接收任意数量的元素。

void printNumbers(std::initializer_list<int> numbers) {
    for (int num : numbers) {
        std::cout << num << ' ';
    }
    std::cout << std::endl;
}

printNumbers({1, 2, 3, 4, 5}); // 输出: 1 2 3 4 5

        范围循环std::initializer_list 可以与范围循环(range-based for loop)一起使用,以迭代其元素。 

std::initializer_list<int> ilist = {1, 2, 3, 4, 5};
for (int i : ilist) {
    std::cout << i << ' '; // 输出: 1 2 3 4 5
}

        使用{ }初始化容器 

        可以发现C++11后所有的容器都适配了std::initializer_list(这里只举几个例子)。这也使得所有的容器都可使用花括号进行初始化:【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

        我们像如下对容器使用{ }:

vector<int> v = { 1,2,3,4 };
list<int> lt = { 1,2 };
// 这里{"sort", "排序"}会先初始化构造一个pair对象
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
// 使用大括号对容器赋值
v = {10, 20, 30};

 

底层原理

        从编译器底层中使用std::initializer_list用{ }来初始化的话,他会找一个常量区将{ }内的数组内的内容储存起来,然后在std::initializer_list这个类下会有两个指针分别指向这段空间的开始和结束的下一个位置,他支持迭代器,而这个迭代器是原生指针。因此我们可以利用该特性合理的使用std::initializer_list,让我们的类也支持用{ }来初始化。如下例子让模拟实现的vector也支持{}初始化和赋值

template<class T>
class vector {
public:
	typedef T* iterator;
	vector(initializer_list<T> l)
	{
		_start = new T[l.size()];
		_finish = _start + l.size();
		_endofstorage = _start + l.size();
		iterator vit = _start;
		typename initializer_list<T>::iterator lit = l.begin();
		while (lit != l.end())
		{
			*vit++ = *lit++;
		}
		//for (auto e : l)
		// *vit++ = e;
	}
	vector<T>& operator=(initializer_list<T> l) {
		vector<T> tmp(l);
		std::swap(_start, tmp._start);
		std::swap(_finish, tmp._finish);
		std::swap(_endofstorage, tmp._endofstorage);
		return *this;
	}
private:
	iterator _start;
	iterator _finish;
	iterator _endofstorage;
};

 

注意事项
  • std::initializer_list 中的元素是常量,不能修改。
  • 不要将 std::initializer_list 用于期望长期存储值的场景,因为它通常只包含对临时数组的引用。
  • 在类的构造函数中,如果参数为 std::initializer_list 类型,则需要在参数类型前加上花括号 {}

声明

auto

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

 

decltype

        关键字decltype将变量的类型声明为表达式指定的类型。 decltype可以推导对象的类型。这个类型是可以用的,他可以用来作为模板实参,或者再定义对象如下:

	int i = 1;
	double d = 2.2;
	auto j = i;

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

	vector<decltype(ret)> v;
	v.push_back(1);
	v.push_back(1.1);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
nullptr

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

 

STL中的变化

        对于之前的容器做出了新增cbegin()、cend()、带initializer_list的构造赋值等等较为轻微的变化 ,较为大的变化为如下为新增的容器:

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

        对于unordered_map和unordered_set我们还是比较熟悉的了,相比map和set而言:

  • map 和 set 是基于红黑树实现的,这意味着它们的元素在内部是有序的。
  • unordered_map 和 unordered_set 是基于哈希表实现的,因此它们的元素在内部是无序的。

        对此不多叙述。下面详细介绍一下array和forward_list这两个容器:

array

        在C++中,array是一个固定大小的序列容器,它包含相同类型的元素,并且其大小在编译时确定。array是C++标准库<array>头文件中的一个模板类,它提供了对数组元素的随机访问迭代器,并支持一系列成员函数来操作这些元素。

 

1. 包含头文件

        使用array之前,你需要包含<array>头文件:

#include <array>
2. 定义array

        你可以使用以下语法定义一个array

std::array<类型, 大小> 变量名;

        其中,类型array中元素的类型,大小array中元素的数量,它是一个常量表达式,必须在编译时确定。

        例如,定义一个包含5个整数的array

std::array<int, 5> myArray;
3. 初始化array

        可以使用列表初始化来初始化array

std::array<int, 5> myArray = {1, 2, 3, 4, 5};

        也可以使用fill构造函数来初始化所有元素为同一值:

std::array<int, 5> myArray(10); // 所有元素初始化为10
4. 访问array元素

        你可以使用下标操作符[]来访问array中的元素:

int firstElement = myArray[0]; // 访问第一个元素  
myArray[2] = 15; // 修改第三个元素
5. array成员函数

        如下可见分别为,是否常量正向,是否常量反向使用的迭代器:    

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

        如下为返回大小、最大的大小、判空、使用[]、at来修改数组内的值、返回最前面的值和最后面的值。我们可能没见过data这个函数,这里的作用为:返回指向数组对象中第一个元素的指针。下面fill则是的将 val 设置为数组对象中所有元素的值。swap用的较多,即为交换两个数组。

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

    array提供了许多有用的成员函数,例如size()来获取数组大小,begin()end()来获取指向数组第一个和最后一个元素的迭代器,以及at()来访问元素(如果索引越界,会抛出std::out_of_range异常)。

	std::array<int, 6> myarray;
	std::array<int, 6> myarray2 = { 0 };//myarray2{};全部初始化为0  myarray2{1,2,3};部分初始化,其他为0
	myarray.fill(5);
	myarray.swap(myarray2);
	cout << myarray[2] << endl;
	myarray.at(2) = 3;
	cout << myarray.size() << endl;
	cout << myarray.max_size() << endl;
	cout << myarray.empty()<< endl;
	cout << myarray2.front() << endl;
	cout << myarray2.back() << endl;
	cout << myarray2.data() << endl;

【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

6. array与内置数组的区别

        与内置数组相比,std::array有以下优点:

  • 固定大小std::array的大小在编译时确定,这有助于捕获潜在的错误,并可能优化性能。
  • 支持STL算法std::array可以与STL算法无缝集成,而内置数组则不可以。
  • 安全性std::arrayat()成员函数在索引越界时会抛出异常,而内置数组则可能导致未定义行为。
  • 更好的接口std::array提供了更丰富的接口和成员函数,使得操作更加便捷。

forward_list

    forward_list 是 C++ 标准库中的一个容器,它表示一个单向链表。与 list 容器不同,forward_list 只允许从前往后遍历元素,不支持从后往前遍历。因此,forward_list 通常比 list 更节省空间,但在某些操作上可能稍慢一些。

        以下是 forward_list 的一些基本特性和用法:

1. 包含头文件

        使用 forward_list 需要包含 <forward_list> 头文件:

#include <forward_list>
2. 定义和初始化 forward_list

        你可以使用花括号初始化列表或 insertemplace 等成员函数来创建和填充 forward_list

	std::forward_list<int> myList = { 1, 2, 3, 4, 5 };
	std::forward_list<int> mylist2;
	std::forward_list<int> mylist3(10);//创建包涵10个元素的容器
	std::forward_list<int> mylist4(10,5);//创建包涵10个元素的容器并且全初始化为5
	std::array<int, 6> myarray2 = { 1,2,3,4,5 };
	std::forward_list<int> mylist5(myarray2.begin(), myarray2.end());//使用其他容器的迭代器初始化
3. 访问 forward_list

        由于 forward_list 是单向的,你只能使用迭代器从前往后遍历它。

for (auto it = myList.begin(); it != myList.end(); ++it) {
    std::cout << *it << " ";
}

        或者,使用基于范围的 for循环:

for (const auto& elem : myList) {
    std::cout << elem << " ";
}
4. 插入和删除元素

        使用assign()用新元素替换容器中原有内容。emplace_front()和push_front()在容器头部插入一个元素。但emplace_front()效率更高。insert_after()和emplace_after(),在指定位置之后插入一个新元素,并返回一个指向新元素的迭代器。但emplace_after()效率更高。pop_front(),删除容器头部的一个元素。erase_after(),删除容器中某个指定位置之后或区域内的所有元素。

  std::forward_list<int> first;
  std::forward_list<int> second;

  first.assign (4,15);                           // 15 15 15 15

  second.assign (first.begin(),first.end());     // 15 15 15 15

  first.assign ( {77, 2, 16} );                  // 77 2 16
///
  std::forward_list< std::pair<int,char> > mylist;

  mylist.emplace_front(10,'a');//push_front()
  mylist.emplace_front(20,'b');
  mylist.emplace_front(30,'c');

///
  std::forward_list< std::pair<int,char> > mylist;
  auto it = mylist.before_begin();

  it = mylist.emplace_after ( it, 100, 'x' );
  it = mylist.emplace_after ( it, 200, 'y' );
  it = mylist.emplace_after ( it, 300, 'z' );

///
  std::forward_list<int> mylist = {10, 20, 30, 40, 50};
                                            // 10 20 30 40 50
  auto it = mylist.begin();                 // ^

  it = mylist.erase_after(it);              // 10 30 40 50
                                            //    ^
  it = mylist.erase_after(it,mylist.end()); // 10 30

        下面主要介绍其中比较特殊的两个迭代器before_begin和cbefore_begin。这两个迭代器指向容器中第一个元素之前的位置。只是后面的是常量迭代器而已

  std::forward_list<int> mylist = {20, 30, 40, 50};

  mylist.insert_after ( mylist.before_begin(), 11 );//11 20 30 40 50
  mylist.insert_after ( mylist.cbefore_begin(), 19 ); //19 11 20 30 40 50
5. 其他操作

    forward_list 还提供了许多其他成员函数,empty(检查列表是否为空)、size(返回列表中元素的数量)、swap()(交换两个容器中的元素)、resize()(调整容器的大小)、clear()(删除容器存储的所有元素),sort()(排序)。reverse()(翻转顺序)。主要介绍如下:splice_after(),将某个 forward_list 容器中指定位置或区域内的元素插入到另一个容器的指定位置之后。remove(val),删除容器中所有等于 val 的元素。remove_if(),删除容器中满足条件的元素。unique(),删除容器中相邻的重复元素,只保留一个。merge(),合并两个事先已排好序的 forward_list 容器,并且合并之后的 forward_list 容器依然是有序的。

  std::forward_list<int> first = { 1, 2, 3 };
  std::forward_list<int> second = { 10, 20, 30 };

  auto it = first.begin();  // points to the 1

  first.splice_after ( first.before_begin(), second );
                          // first: 10 20 30 1 2 3
                          // second: (empty)
                          // "it" still points to the 1 (now first's 4th element)
  second.splice_after ( second.before_begin(), first, first.begin(), it);
                          // first: 10 1 2 3
                          // second: 20 30

  first.splice_after ( first.before_begin(), second, second.begin() );
                          // first: 30 10 1 2 3
                          // second: 20
                          // * notice that what is moved is AFTER the iterator

///
bool single_digit (const int& value) { return (value<10); }

// a predicate implemented as a class:
class is_odd_class
{
public:
  bool operator() (const int& value) {return (value%2)==1; }
} is_odd_object;

  std::forward_list<int> mylist = {7, 80, 7, 15, 85, 52, 6};

  mylist.remove_if (single_digit);      // 80 15 85 52

  mylist.remove_if (is_odd_object);     // 80 52

///
  std::forward_list<double> first = {4.2, 2.9, 3.1};
  std::forward_list<double> second = {1.4, 7.7, 3.1};
  first.sort();
  second.sort();
  first.merge(second); //first: 1.4 2.9 3.1 3.1 4.2 7.7

注意事项
  • 由于 forward_list 是单向的,它不支持 reverse_iterator,因此不能使用 rbegin()rend() 函数。
  • 在某些情况下,forward_list 可能比 listvector 等其他容器更适合,特别是在你需要一个简单的单向链表并且空间效率很重要的时候。但是,由于它只支持单向遍历,因此在某些算法上可能不如双向链表或数组高效。

 


                         感谢你耐心的看到这里ღ( ´・ᴗ・` )比心,如有哪里有错误请踢一脚作者o(╥﹏╥)o! 

                                       【C++11】:统一的列表初始化|声明|STL变化,C++修仙 筑基中,c++,后端,开发语言,容器

                                                                        给个三连再走嘛~  文章来源地址https://www.toymoban.com/news/detail-843563.html

到了这里,关于【C++11】:统一的列表初始化|声明|STL变化的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

原文地址:https://blog.csdn.net/weixin_64038246/article/details/136980423

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • c# 初始化列表,并给列表里面所有的元素进行初始化

    Enumerable.Repeat 方法是用于生成一个包含指定元素重复若干次的序列。它接受两个参数,第一个参数是要重复的元素,第二个参数是重复次数。 下面是 Enumerable.Repeat 方法的用法和示例:

    2024年02月13日
    浏览(4)
  • 结构体声明、定义和初始化的几种方式

    五种结构体声明方式: 直接声明结构体类型 声明结构体类型的同时定义结构体变量 不指定结构体名而直接定义结构体变量 使用结构体标记和类型别名 直接声明结构体别名 在C语言中,标记(tag)是在定义struct, union或enum之后使用的标识符。 之所以称其为结构体的“

    2023年04月11日
    浏览(10)
  • Java创建数组、赋值的四种方式,声明+创建+初始化 详解

    以int数据类型为例 注意: new 数据类型[]{},其中花括号可以省去,但要在[ ]中填写数组的个数; 创建多维数组时 new后面第一个方括号中的元素数量不能省略 1、一维数组的声明方式: type[] arrayName; 或 type arrayName[]; 推荐使用第一种格式,因为第一种格式具有更好的可读性,表

    2024年04月11日
    浏览(7)
  • 初始化列表的使用

    问题 类中是否可以定义 const 成员? 可以的 下面的类定义是否合法? 如果合法,ci 的值是什么,存储在哪里? 上面的 Test 类定义是合法的,但是要定义 Test 类对象的时候,编译器会报错,提示 const 成员变量 ci 没初始化 类中的 const 成员 我们对上面的代码进行编译,编译直

    2024年02月09日
    浏览(13)
  • 初始化列表

     在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象成员变量的初始化,构造函数体中的语句只能将其称为赋初值,而不能成作初始化。因为 初始化只能进

    2024年02月04日
    浏览(13)
  • 掌握 C# 变量:在代码中声明、初始化和使用不同类型的综合指南

    变量是用于存储数据值的容器。 在 C# 中,有不同类型的变量(用不同的定义),例如: int - 存储整数(没有小数点的整数),如 123 或 -123 double - 存储浮点数,有小数点,如 19.99 或 -19.99 char - 存储单个字符,如 \\\'a\\\' 或 \\\'B\\\'。 Char 值用单引号括起来 string - 存储文本,如

    2024年01月17日
    浏览(19)
  • 【已解决】错误:只允许在 C99 模式下使用‘for’循环初始化声明

    运行3DFFA_v2_master项目 运行sh build.sh脚本文件 环境:centos python3.7 render.c: 在函数‘_render’中: render.c:43:5: 错误:只允许在 C99 模式下使用‘for’循环初始化声明 for (int i = 0; i ntri; i++) render.c:43:5: 附注:使用 -std=c99 或 -std=gnu99 来编译您的代码 render.c:75:14: 错误:‘i’重定义 for

    2024年02月08日
    浏览(23)
  • C++之初始化列表详细剖析

    初始化列表:以一个 冒号开始 ,接着是一个以 逗号分隔的数据成员列表 ,每个 \\\"成员变量\\\" 后面跟一个 放在括号中的初始值或表达式。 不知道大家有没有想过这样一个问题,成员函数明明可以在函数内部对成员变量进行赋值,那为什么还要搞出初始化列表这个东西呢?这个

    2024年02月06日
    浏览(11)
  • 【C++奇遇记】构造函数 | 初始化列表

    🎬 博客主页:博主链接 🎥 本文由 M malloc 原创,首发于 CSDN🙉 🎄 学习专栏推荐:LeetCode刷题集 数据库专栏 初阶数据结构 🏅 欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正! 📆 未来很长,值得我们全力奔赴更美好的生活✨ 🐤本篇文章将讲授C++的初始化列表相关的知识

    2024年02月12日
    浏览(7)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包