【C++】C++11语法 ~ 可变参数模板

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

🌈欢迎来到C++专栏~可变参数模板


  • (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort
  • 目前状态:大三非科班啃C++中
  • 🌍博客主页:张小姐的猫~江湖背景
  • 快上车🚘,握好方向盘跟我有一起打天下嘞!
  • 送给自己的一句鸡汤🤔:
  • 🔥真正的大师永远怀着一颗学徒的心
  • 作者水平很有限,如果发现错误,可在评论区指正,感谢🙏
  • 🎉🎉欢迎持续关注!
    【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

一. 类的新功能

🥑默认成员函数

C++11之后,有八个默认成员函数

在C++11之前,一个类中有如下六个默认成员函数:

  • 构造函数
  • 析构函数
  • 拷贝构造函数
  • 拷贝赋值函数
  • 取地址重载函数
  • const取地址重载函数

其中前四个成员函数最重要,后面两个成员函数一般不会用到,这里“默认”的意思就是你不写编译器会自动生成。在C++11标准中又增加了两个默认成员函数,分别是移动构造函数和移动赋值重载函数

✨默认移动构造和移动赋值的生成条件

  • 默认移动构造生成条件:没有自己实现移动构造函数,并且没有自己实现析构函数、拷贝构造函数和拷贝赋值函数的任意一个
  • 移动赋值重载函数的生成条件:没有自己实现移动赋值重载函数,并且没有自己实现析构函数、拷贝构造函数和拷贝赋值函数

😎特别注意: 如果我们自己实现了移动构造或者移动赋值,就算没有实现拷贝构造和拷贝赋值,编译器也不会生成默认的拷贝构造和拷贝赋值

默认生成的移动构造和移动赋值会做什么?

  • 对于内置类型的成员会完成值拷贝(浅拷贝),对于自定义类型的成员,如果该成员实现了移动构造/移动赋值就调用它的移动构造/移动赋值,否则就调用它的拷贝构造

对此我们展开验证,这里需要模拟实现一个简化版的string类,类当中只编写了几个我们需要用到的成员函数。

代码如下:

namespace ljj
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str; //返回字符串中第一个字符的地址
		}
		iterator end()
		{
			return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
		}
		//构造函数
		string(const char* str = "")
		{
			_size = strlen(str); //初始时,字符串大小设置为字符串长度
			_capacity = _size; //初始时,字符串容量设置为字符串长度
			_str = new char[_capacity + 1]; //为存储字符串开辟空间(多开一个用于存放'\0')
			strcpy(_str, str); //将C字符串拷贝到已开好的空间
		}
		//交换两个对象的数据
		void swap(string& s)
		{
			//调用库里的swap
			::swap(_str, s._str); //交换两个对象的C字符串
			::swap(_size, s._size); //交换两个对象的大小
			::swap(_capacity, s._capacity); //交换两个对象的容量
		}
		//拷贝构造函数(现代写法)
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str); //调用构造函数,构造出一个C字符串为s._str的对象
			swap(tmp); //交换这两个对象
		}

		//移动构造
		string(string&& s)//右值引用
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 资源转移" << endl;

			swap(s); //资源互换
		}

		//赋值运算符重载(现代写法)
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;

			string tmp(s); //用s拷贝构造出对象tmp
			swap(tmp); //交换这两个对象
			return *this; //返回左值(支持连续赋值)
		}

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

			return *this; //返回左值(支持连续赋值)
		}

		//析构函数
		~string()
		{
			delete[] _str;  //释放_str指向的空间
			_str = nullptr; //及时置空,防止非法访问
			_size = 0;      //大小置0
			_capacity = 0;  //容量置0
		}
		//[]运算符重载
		char& operator[](size_t i)
		{
			assert(i < _size); //检测下标的合法性
			return _str[i]; //返回对应字符
		}
		//改变容量,大小不变
		void reserve(size_t n)
		{
			if (n > _capacity) //当n大于对象当前容量时才需执行操作
			{
				char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
				strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来(包括'\0')
				delete[] _str; //释放对象原本的空间
				_str = tmp; //将新开辟的空间交给_str
				_capacity = n; //容量跟着改变
			}
		}
		//尾插字符
		void push_back(char ch)
		{
			if (_size == _capacity) //判断是否需要增容
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
			}
			_str[_size] = ch; //将字符尾插到字符串
			_str[_size + 1] = '\0'; //字符串后面放上'\0'
			_size++; //字符串的大小加一
		}
		//+=运算符重载
		string& operator+=(char ch)
		{
			push_back(ch); //尾插字符串
			return *this; //返回左值(支持连续+=)
		}
		//返回C类型的字符串
		const char* c_str()const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

再编写一个简单的Person类,Person类中的成员name的类型就是我们模拟实现的string类

class Person
{
public:
	//构造函数
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	//拷贝构造函数
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
	//拷贝赋值函数
	Person& operator=(const Person& p)
	{
		if (this != &p)
		{
			_name = p._name;
			_age = p._age;
		}
		return *this;
	}
	//析构函数
	~Person()
	{}
private:
	cl::string _name; //姓名
	int _age;         //年龄
};

因为Person类中实现了拷贝构造、拷贝赋值和析构函数等,所以不会默认生成移动构造和移动赋值

int main()
{
	Person s1("张三", 7);
	Person s2 = s1;//拷贝构造
	Person s3 = std::move(s1);//移动构造(没有移动构造,就会调用拷贝构造)
	return 0;
}

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

ps:由于VS2013没有完全支持C++11,因此上述代码无法在VS2013当中验证,需要使用更新一点的编译器进行验证,比如VS2019

🥑类成员变量初始化

默认生成的构造函数,对于自定义类型的成员会调用其构造函数进行初始化,但并不会对内置类型的成员进行处理。于是C++11支持非静态成员变量在声明时进行初始化赋值,默认生成的构造函数会使用这些缺省值对成员进行初始化

class Person
{
public:
	//...
private:
	//非静态成员变量,可以在成员声明时给缺省值
	ljj::string _name = "张三"; //姓名
	int _age = 20;             //年龄
	static int _n; //静态成员变量不能给缺省值
};

🥑强制生成默认函数的关键字default

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

下面函数实现了拷贝构造

class Person
{
public:
	//拷贝构造函数
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
private:
	cl::string _name; //姓名
	int _age;         //年龄
};

这样编译器就无法生成默认的构造函数了,因为默认构造函数生成的条件是没有编写任意类型的构造函数包括拷贝构造函数

这时我们就可以使用default关键字强制生成默认的构造函数

class Person
{
public:
	Person() = default; //强制生成默认构造函数

	//拷贝构造函数
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
private:
	cl::string _name; //姓名
	int _age;         //年龄
};

主要使用场景:用于构造函数,因为如果我们实现了拷贝构造(也算构造),就不会默认生成构造函数了,需要强制生成

🥑禁止生成默认函数的关键字delete

当我们想要限制某些默认函数生成

  • C++98中,可以将该函数设置成私有,并且只用声明不用定义,这样当外部调用该函数时就会报错。
  • C++11中,可以在该函数声明后面加上=delete,表示让编译器不生成该函数的默认版本,我们将=delete修饰的函数称为删除函数
class Person
{
public:
	//构造函数
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	//不想要Person对象拷贝
	Person(const Person& p) = delete;
private:
	ljj::string _name; //姓名
	int _age;         //年龄
};

int main()
{
	Person s1("张三", 7);
	Person s2 = s1;//拷贝构造
	return 0;
}

来道题目:要求delete关键字实现,一个类只能在堆上创建对象

class HeapOnly
{
public:
	HeapOnly()
	{
		_str = new char[10];
	}

	~HeapOnly() = delete;

	void Destroy()
	{
		delete[] _str;//删除开创的空间
		free(this);//删除ptr指针
	}

private:
	char* _str;
};

int main()
{
	HeapOnly* ptr = new HeapOnly;
	ptr->Destroy();
	return 0;
}

如果是构造时,对象有数据,则要我们手动实现一个类似析构函数的函数,析构要注意两块空间哦:ptr指针和new的空间都要释放了

二. 可变模板参数

C++11 新增一员大将就是可变参数模板,他可以允许可变参数的函数模板和类模板来作为参数,使得参数高度泛化

💦模板定义

函数的可变参数模板定义方式如下:

template<class …Args>
void ShowList(Args… args)
{
  //函数体
}
  • Args是一个模板参数包,args是一个函数形参参数包
    声明一个参数包Args…args,这个参数包中可以包含0到任意个模板参数

模板参数包 Args 和函数形参参数包 args 的名字可以任意指定,并不是说必须叫做 Args 和 args

int main()
{
	//函数传参就可以传多个不同类型参数了
	string str("hello");
	ShowList();
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', str);
	return 0;
}

也可以通过sizeof算出参数包中参数的个数:...是在外面的

template<class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl; //获取参数包中参数的个数
}

此时最大的难点来了,就是怎么样直接获取参数包中的每个参数?

  • 语法并不支持使用 args[i] 的方式来获取参数包中的参数,只能通过展开参数包的方式来获取,这是使用可变参数模板的一个主要特点

下面是错误示范:(语法不支持!)

template<class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;

	//错误示例:
	for (int i = 0; i < sizeof...(args); i++)
	{
		cout << args[i] << " "; //打印参数包中的每个参数
	}
	cout << endl;
}

💦参数包的展开

😎递归函数方式展开

该方法大概分为三步:

  • 给函数模板增加一个模板参数,从接收的参数包中把第一个参数分离出来
  • 在函数模板中递归调用该函数模板,调用时传入剩下的参数包
  • 直到递归到参数包为空,退出递归
//可变参数的函数模板 
template<class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << val << " ";//打印分离出的第一个参数
	ShowList(args...);//继续递归调用
}

//递归至空,终止函数
void ShowList()
{
	cout << endl;
}

int main()
{
	string str("hello");
	ShowList(1, 'A', str);
	return 0;
}

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

那如果我们不使用递归调用,该怎么样写呢?

😎逗号表达式展开

逗号表达式规则是会从左到右依次计算各个表达式,并将最后一个表达式的值作为返回值返回,我们将最后一个表达式设为整型值,确保最后返回的是一个整型

将处理参数个数的动作封装成一个函数,将该函数作为逗号表达式的第一个表达式

template <class T>
void PrintArg(const T& x)
{
	cout << x << " ";
}

template <class ...Args>
void ShowList(Args... args)
{
	int a[] = { (PrintArg(args), 0)... };//开创输入参数个整数类型的数组
}

我们要的是打印出参数包中的各个参数,因此处理函数当中要做的就是将传入的参数进行打印即可

ps:可变参数的省略号...需要加在逗号表达式外面,表示需要先将逗号表达式展开,如果直接加在 args 后面,那么参数包将会被展开后全部传入 PrintArg,会展开成 {(PrintArg(arg1), 0), (PrintArg(arg2), 0), (PrintArg(arg3), 0), etc…}

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

当然我们不使用逗号表达式也是可以的,这里的问题是初始化整型数组时必须用整数,那我们可以将处理函数的返回值设为整型,然后用这个返回值去初始化整型数组也是可以的:

void ShowList()
{
	cout << endl;
}
//处理函数
template<class T>
int PrintArg(const T& t)//返回值为int类型
{
	cout << t << " ";
	return 0;
}
//展开函数
template<class ...Args>
void ShowList(Args... args)
{
	int arr[] = { PrintArg(args)... }; //列表初始化
	cout << endl;
}

三. emplace

C++11 给 STL 容器增加 emplace 的插入接口,比如 list 容器的 push_front、push_back 和insert 函数,都有了对应的 emplace_front、emplace_back 和 emplace 函数:

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

这些emplace版本的插入接口支持模板的可变参数,比如vector容器的emplac函数的声明如下:

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

✨使用方法

调用 push_back 插入元素时,可以传入左值对象或右值对象,也可以使用列表进行初始化;调用emplace_back 插入元素时,也可以传入左值对象或右值对象,但不可以使用列表进行初始化

emplace系列接口最大的特点就是,插入元素可传入用于构造元素的参数包

int main()
{
	//对于整形:没有区别
	vector<int> v;
	v.push_back(1);
	v.emplace_back(2);

	//对于pair类型数据
	vector<pair<std::string, int>> v1;
	v1.push_back(make_pair("sort", 1));
	v1.emplace_back("sort", 1);

	return 0;
}

那么emplace会比push_back更加高效吗?不一定!

✨工作原理

emplace 接口先通过空间配置器为新结点获取一块内存空间,注意这里只会开辟空间,不会自动调用构造函数对这块空间进行初始化

  • 调用 allocator_traits::construct 函数对这块空间进行初始化,调用该函数会传入这块空间的地址和用户传入的参数,注意要完美转发
  • 在 allocator_traits::construct 中会使用定位 new 表达式,显示调用构造函数对这块空间进行初始化,调用构造函数时会传入用户传入的参数,这里同样需要完美转发

✨意义

emplace 接口的可变参数模板类型都是万能引用,因此既可以接收左值,也可以接收右值,还可以接收参数包

  • 调用 emplace 接口时传入的是参数包,就可以直接调用函数进行插入,并最终使用定位 new 表达式调用构造函数对空间进行初始化时,匹配到构造函数
  • 调用 emplace 接口时传入的是左值or右值,首先需要先在此之前调用构造函数实例化出一个对象,最后使用定位 new 表达式调用构造函数对空间进行初始化时,会匹配到拷贝构造函数or拷贝构造

总的来说:如果传入参数包,只需要调用构造函数

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

emplace 最大特点就是支持传入参数包,用这些参数包直接构造出对象,这样就能减少一次拷贝,这就是为什么有人说 emplace 系列接口更高效的原因

emplace 真正高效的情况是传入参数包的时候, 直接通过参数包构造出对象,避免了中途的一次拷贝 直接通过参数包构造出对象,避免了中途的一次拷贝

举例演示:

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "构造函数" << endl;
	}

	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "拷贝构造" << endl;
	}

	Date& operator=(const Date& d)
	{
		cout << "赋值重载" << endl;
		return *this;
	}

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

int main()
{
	list<Date> lt1;

	lt1.push_back(Date(2023, 2, 3));
	cout << endl;
	lt1.emplace_back(2023, 2, 3);
}

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言

所以验证了emplace_back是比push_back要少一次拷贝构造

📢写在最后

【C++】C++11语法 ~ 可变参数模板,C++ ~ 登峰造极,c++,java,开发语言文章来源地址https://www.toymoban.com/news/detail-827384.html

到了这里,关于【C++】C++11语法 ~ 可变参数模板的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • 【C++进阶】C++11(下)可变参数模板&lambda表达式&包装器

    我们紧接着上一节的讲解来进行 C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板,相比C++98/03,类模版和函数模版中只能含固定数量的模版参数,可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象,使用起来需要一定的技巧

    2024年04月11日
    浏览(86)
  • 【C++11】移动赋值 | 新的类功能 | 可变参数模板

    C++11中,string中的operator= 包含 参数为右值的版本 C++98中 没有移动赋值和移动构造 , 只有参数为左值 的赋值重载(operator=)和拷贝构造 本来只有两次深拷贝,但是由于调用拷贝赋值时,内部又进行一次拷贝构造,所以导致最终进行三次深拷贝 这里编译器是不能优化的, 因为优

    2024年02月08日
    浏览(41)
  • C++11『右值引用 ‖ 完美转发 ‖ 新增类功能 ‖ 可变参数模板』

    ✨个人主页: 北 海 🎉所属专栏: C++修行之路 🎃操作环境: Visual Studio 2022 版本 17.6.5 自从C++98以来,C++11无疑是一个相当成功的版本更新。它引入了许多重要的语言特性和标准库增强,为C++编程带来了重大的改进和便利。C++11的发布标志着C++语言的现代化和进步,为程序员

    2024年02月05日
    浏览(46)
  • C++11可变参数模板(typename... Args模板参数包或class... Args)(Args... args函数参数包)(递归展开与参数包展开(只支持C++17))

    C++可变参数是指函数的参数个数是可变的,可以在函数定义时不确定参数的个数,需要在函数体内通过特定的语法来处理这些参数。C++11标准引入了新的可变参数模板,使得可变参数的处理更加方便和灵活。在函数定义时,可以使用省略号(…)来表示可变参数,然后通过va_li

    2024年02月08日
    浏览(41)
  • 【C++】C++11新特性重点:可变参数+lambda

    C++11新特性第二篇重点 文章目录 上一篇的补充 一、可变参数模板 二、lambda函数 总结 上一篇我们重点讲解了右值引用+移动语义,关于移动构造和移动赋值还有一些需要补充的知识: 如果你没有自己实现移动构造函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任

    2024年02月09日
    浏览(48)
  • 【C++】C++11右值引用|新增默认成员函数|可变参数模版|lambda表达式

    在C++11之前,我们只有引用的概念,没有接触到所谓的左值引用或者是右值引用这种概念,从C++11开始,增加了右值引用的概念,那么现在我们将对引用进行一个概念上的区分。在此之前我们所说的引用都是左值引用,对于左值引用相关的内容,可以去看一看博主之前写的文章

    2024年02月15日
    浏览(57)
  • 【JavaSE】Java基础语法(三十一):可变参数

    可变参数介绍 可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式 可变参数的注意事项 这里的变量其实是一个数组 如果一个方法有多个参数,包含可变参数,可

    2024年02月08日
    浏览(54)
  • 【C】【C++】可变参数、不定参函数的使用

    C 语言中的可变参数写法: ... 1.1 可变宏函数 以日志举例,我们写入日志时只需要输入关键信息,行号文件等由宏函数补全 这其中,我们需要输入的信息是格式不定的,需要用到可变参数 输出结果: C语言库中的宏 __FILE__ :字符串,记录当前文件名 __LINE__ :整型,记录当前

    2024年02月09日
    浏览(37)
  • 【C++】泛型编程 ① ( 函数模板 | 函数模板概念 | 函数模板意义 | 函数模板定义语法 | 函数模板调用语法 | 显式类型调用 | 自动类型推导 )

    在 C++ 语言中 , 泛型编程 的 核心就是 函数模板 和 类模板 ; 函数模板 Function Template 是 C++ 语言 中的 重要特性 ; 函数模板概念 : 建立一个 \\\" 通用函数 \\\" , 不指定该函数的 函数返回值类型 和 函数参数类型 , 仅使用 \\\" 虚拟类型 \\\" 代表 上述 两种类型 , 该 \\\" 通用函数 \\\" 就是 \\\" 函数模

    2024年02月19日
    浏览(37)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包