《Effective C++》item25：考虑写出一个不抛异常的swap函数

最新推荐文章于 2024-01-28 08:15:00 发布
最新推荐文章于 2024-01-28 08:15:00 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： C/C++ 文章标签： swap 模板类 全特化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/onejune2013/article/details/16885047
版权

 std::swap（）是个很有用的函数，它可以用来交换两个变量的值，包括用户自定义的类型，只要类型支持copying操作，尤其是在STL中使用的很多，例如：

[cpp]  view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. int main(int argc, _TCHAR* argv[])  
  2. {  
  3.     int a[10] = {1,2,3,4,5,6,7,8,9,10};  
  4.     vector<int> vec1(a, a + 4);  
  5.     vector<int> vec2(a + 5, a + 10);  
  6.   
  7.     swap(vec1, vec2);  
  8.   
  9.     for (int i = 0; i < vec1.size(); i++)  
  10.     {  
  11.         cout<<vec1[i]<<" ";  
  12.     }  
  13.     return 0;  
  14. }  

        上面这个例子实现的是两个vector的内容的交换，有了swap函数，省去了很多的麻烦！What a fucking convenient!


一、swap的原理


        缺省的swap的原理其实很简单，就是将两对象的值彼此赋予对方，其实现过程大致如下：

[cpp]  view plain copy print ?
  1. namespace std{  
  2.     template<typename T>  
  3.     void swap(T&a, T& b){  
  4.         T temp(a);  
  5.         a=b;  
  6.         b=temp;  
  7.     }  
  8. }  
        swap的实现是通过被交换类型的copy构造函数和赋值操作符重载实现的，会涉及到三个对象的复制。所以说，要对自定义的类型调用swap实现交换，必须首先保证自定义类型的copy构造函数和赋值操作符重载函数。


二、swap的缺陷


        缺省的swap最主要的问题就是：当对象内部包含指针成员时，它不仅要复制3三次被交换的对象，还要复制3次对象成员，而且复制的是指针对象所指向的内容！例如：

        

[cpp]  view plain copy print ?
  1. // SwapTest.cpp : 定义控制台应用程序的入口点。  
  2.   
  3. #include "stdafx.h"  
  4. #include <iostream>  
  5. #include <vector>  
  6.   
  7. using namespace std;  
  8.   
  9. class Point{  
  10. private:  
  11.     int x,y;  
  12. public:  
  13.     Point():x(0),y(0){};  
  14.     Point(int a, int b):x(a),y(b){};  
  15.     void Print(){  
  16.         cout<< x << " "<< y <<endl;  
  17.     }  
  18.     int GetX(){  
  19.         return x;  
  20.     }  
  21.     int GetY(){  
  22.         return y;  
  23.     }  
  24. };  
  25.   
  26. class Line{  
  27. private:  
  28.     Point *px, *py;  
  29. public:  
  30.     Line():px(),py(){};  
  31.     Line(int a,int b,int c,int d):px(new Point(a,b)), py(new Point(c, d)){};  
  32.     Line(const Line& li){  
  33.         px = new Point(*li.px);  
  34.         py = new Point(*li.py);  
  35.     }  
  36.     Line& operator=(const Line& li){  
  37.         Point *p = px;  
  38.         px = new Point(*li.px);  
  39.         delete p;  
  40.         p = py;  
  41.         py = new Point(*li.py);  
  42.         delete p;  
  43.         return *this;  
  44.     }  
  45.     void Print(){  
  46.         cout<<"( "<<px->GetX()<<" "<<px->GetY()<<" "<<py->GetX()<<" "<<py->GetY()<<" )"<<endl;  
  47.     }  
  48. };  
  49.   
  50. int main(int argc, _TCHAR* argv[])  
  51. {  
  52.     Line l1(1,1,2,2), l2(3,3,4,4);  
  53.     swap(l1, l2);  
  54.     l1.Print();  
  55.     return 0;  
  56. }  
        一旦要置换两个Line对象值，swap需要复制三个Line，还要复制六个Point对象，详细可以看赋值运算符重载函数，这样是非常低效的，尤其是当Line的数据成员非常庞大的时候，实际上我们只需要交换各自成员的指针就可以了！


三、swap的改进方案


        我们希望告诉std::swap：当Line被置换时，真正该做的是置换骑内部的px和py指针。实现这个过程有几个方案，我们先看最简单的方案：


方案一：将std::swap针对Line特化


        C++规定：通常不允许改变std命名空间内的任何东西，但是可以为标准template（如swap）制造特化版本，使他专属于我们自己的class（例如Line）。

        根据这个性质，我们可以对std:swap针对Line进行特化。我们可以这样特化swap：

[cpp]  view plain copy print ?
  1. namespace std{  
  2.     template<>  
  3.     void swap<Line>(Line& l1, Line& l2){      // std::swap()的特化版本，std::swap()只可以特化，不可以重载  
  4.         cout<<"swap of std is called......"<<endl;  
  5.         l1.swap(l2);  
  6.     }  
  7. }  
        在这个代码中，“template<>”表示它是std::swap的一个全特化版本，函数名之后的“<Line>"表示这一特化版本针对”T是Line”而设计。

        完整的方案如下：

// SwapTest.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"
#include <iostream>
#include <vector>

using namespace std;

class Point{
private:
	int x,y;
public:
	Point():x(0),y(0){};
	Point(int a, int b):x(a),y(b){};
	void Print(){
		cout<< x << " "<< y <<endl;
	}
	int GetX(){
		return x;
	}
	int GetY(){
		return y;
	}
};

class Line{
private:
	Point *px, *py;
public:
	Line():px(),py(){};
	Line(int a,int b,int c,int d):px(new Point(a,b)), py(new Point(c, d)){};
	void swap(Line& l){  //Line成员函数，用以实现指针成员交换
		cout<<"swap of Line is called......"<<endl;
		using std::swap;
		swap(px, l.px);  // 交换指针
		swap(py, l.py);
	}

	void Print(){
		cout<<"( "<<px->GetX()<<" "<<px->GetY()<<" "<<py->GetX()<<" "<<py->GetY()<<" )"<<endl;
	}
};

namespace std{
	template<>
	void swap<Line>(Line& l1, Line& l2){      // std::swap()的特化版本，std::swap()只可以特化，不可以重载
		cout<<"swap of std is called......"<<endl;
		l1.swap(l2);
	}
}

int main(int argc, _TCHAR* argv[])
{
	Line l1(1,1,2,2), l2(3,3,4,4);
	swap(l1, l2);
	l1.Print();
	return 0;
}
        在这个例子中，一共出现了5次swap这个函数：

        第一次是main中调用的swap，这个调用的是我们自定义的std::swap()的特化版本

        第二次是我们自己定义的std::swap()对Line类型的特化，在函数名前面有“template<>”

        第三次是对Line特化的swap中调用的swap，也就是l1.swap(l2)，这个很明显是调用Line类型的swap()成员函数

        第四次是Line类型中的成员函数，void swap(Line& l)，这个public函数的目的是供给非Line成员函数调用的，也就是特化版本的swap，因为只有类的成员函数才可以调用类的private成员变量

        第五次是Line成员函数swap调用的swap，这个swap调用前面有个using std::swap的声明，表示后面调用的是std中的原始swap，当然不是特化版本的swap
        其中可以被调用的swap有3个，std中原始的swap、std::swap的特化版本、Line中的成员函数swap，这3个函数中，真正给用户调用的只有第一个swap，也就是std::swap的Line特化版。通过这一系列函数就可以实现Line对象中指针成员的指针的交换，而不是Line对象整个的交换。

        这种方式和STL容器有一致性，因为所有的STL容器也都提供有public swap成员函数和std::swap特化版本（用以调用前者）

        

方案二、重载特化的std::swap


        上面这种方式是针对Line和Point都是非template class，现在假设Line和Point都是template class，那么这种方式还可不可以了？

        假设Line类和Point类都是template class，如下定义：

#include <iostream>
#include <string.h>

template<typename T>
class Point{
private:
     T x,y;
public:
     Point():x(0),y(0){};
     Point(T a, T b):x(a),y(b){};
     void Print(){
          std::cout<< x << " "<< y <<endl;
     }
     T GetX(){
          return x;
     }
     T GetY(){
          return y;
     }
};

template<typename T1, typename T2>
class Line{
private:
     T1 px,py;
public:
     Line():px(),py(){};
     Line(T2 a,T2 b,T2 c,T2 d):px(T1(a, b)), py(T1(c, d)){};
     void Print(){
          std::cout<<"( "<<px.GetX()<<" "<<px.GetY()<<" "<<py.GetX()<<" "<<py.GetY()<<" )"<<std::endl;
     }
     void swap(Line<T1, T2>& l){
          std::cout<<"swap of Line is called......"<<std::endl;
          using std::swap;
          swap(px, l.px);
          swap(py, l.py);
     }
};

namespace std {
	template<typename t1="" typename="" t2="">
	void swap(Line<t1 t2="">& l1, Line<t1 t2="">& l2){
		cout<<"swap of std is called......"<<std::endl;
		l1.swap(l2);
	}
}

int main()
{
	Line<Point<double>, double> l1(1, 1, 2, 2), l2(3, 3, 4, 4);
	std::swap(l1, l2);
	l1.Print();

	return 0;

}
        其中std里面的swap函数就是对std::swap的一个重载版本，然而，这个方式并不是特别的推荐，按照《effective c++》中的说法，这是一种非法的方式，是被C++标准禁止的，虽然能够编译和运行通过。


方案三、非特化非重载的non-member swap


        我们可以声明一个非Line类成员函数swap，让其调用Line的成员函数swap，这个非成员swap也非特化的std::swap，如下所示：

#include "stdafx.h"
#include <iostream>
#include <string.h>

template<typename T>
class Point{
private:
	T x,y;
public:
	Point():x(0),y(0){};
	Point(T a, T b):x(a),y(b){};
	void Print(){
		std::cout<< x << " "<< y <<endl;
	}
	T GetX(){
		return x;
	}
	T GetY(){
		return y;
	}
};

template<typename T1, typename T2>
class Line{
private:
	T1 px,py;
public:
	Line():px(),py(){};
	Line(T2 a,T2 b,T2 c,T2 d):px(T1(a, b)), py(T1(c, d)){};
	void Print(){
		std::cout<<"( "<<px.GetX()<<" "<<px.GetY()<<" "<<py.GetX()<<" "<<py.GetY()<<" )"<<std::endl;
	}
	void swap(Line<T1, T2>& l){
		std::cout<<"swap of Line is called......"<<std::endl;
		using std::swap;
		swap(px, l.px);
		swap(py, l.py);
	}
};

template<typename T1, typename T2>
void swap(Line<T1, T2>& a, Line<T1, T2>& b){
	std::cout<<"swap of non-member is called......"<<std::endl;
	a.swap(b);
}

int main()
{
	Line<Point<double>, double> l1(1, 1, 2, 2), l2(3, 3, 4, 4);
	std::swap(l1, l2);
	l1.Print();

	return 0;

}
        其实就是将方案二的std::swap重载改成了自定义的非成员函数，原理依然一样！


remember：


        1.当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。
        2.如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于class（而非template），也请特化std::swap。
        3.调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰符”。
        4.为“用户定义类型”进行std template全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。











然鸟
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Effective C++】考虑写出一个不抛出异常的swap函数
ZLP_CSDN的博客
05-17 288
首先抛出结论： 下面再来讲讲原因： swap含义及缺省实现 swap 函数是用来将两个对象的指彼此赋予对方。在缺省情况下，swap的动作可以由STL中提供的 swap 算法来完成，它的实现也很简单： namespace std { template<typename T> void swap(T& a, T& b) { T temp(a); a = b; b = temp; } } 只要 T 支持拷贝构造和拷贝赋值， 缺省的 swap 就会为你完成置换 T
Effective Modern C++.7z
05-23
11. **异常安全保证（Exception Safety）**：C++11鼓励编写异常安全的代码，比如提供noexcept关键字声明函数不抛异常，以及确保在异常发生时，资源能得到正确释放。 12. **统一初始化（Uniform Initialization）**...
2021-1-30：c++中swap函数理解
ratsquealer的博客
01-30 1572
C++中的swap函数：交换函数 好处：不用担心交换变量精度的缺失，无需构造临时变量，不会增加空间复杂度 swap 包含在命名空间std 里面 swap(a,b);（交换两个数） swap(a[i] = b[j]);（交换两个位置上的变量） ...
Modern C++ std::swap的实现原理
最新发布
老宅的虚拟空间
01-28 253
std::swap的实现原理
C++设计模式由浅入深（四）——swap抽丝剥茧
wbvalid的博客
06-12 2050
四、深入浅出剖析swap 1 STL与swap swap操作被广泛应用与C++标准库中。所有的标准模板库（STL）容器都提供了swap函数，并且同时支持非成员版本的函数模板std::swap。swap在STL的算法中也有广泛应用。标准库也是常常被用来实现与之类似自定义功能的模板库。因此，我们将会开始学习swap操作并且仔细研究标准库提供的函数细节。 1.1 swap与STL容器 从概念上讲，swap所做的行为就如同下面所示的操作： template <typename T> void swap(
std::swap学习笔记
weixin_42108533的博客
09-12 1181
std::swap函数的学习笔记
C++ std::swap的设计方法与规则简析
我爱加菲猫
11-26 2122
swap1 很高兴分享，上一节遗留下swap问题2 缺省的内置std::swap的问题？3 pimpl手法下的类(模板)提高swap的速率4 分析weak_ptr中swap4.1 开始的时候为什么不调用std::swap？4.2 STEP3和STEP4调用的swap该如何理解呢？4.3 STEP3为什么要明确指定std::swap？4.4 再谈第一步STEP1？5 结论 1 很高兴分享，上一节遗留下swap问题 下面就简单分享下自己的想法，更详细的可以参考更专业的书籍。 2 缺省的内置std::swap的问
Effective Modern C++
07-29
《Effective Modern C++》是C++编程领域的一本经典书籍，由Scott Meyers撰写，旨在帮助程序员充分利用C++11及以后版本的新特性，提升代码的效率和可维护性。这本书通过一系列实践性的建议和技巧，揭示了如何在现代...
More Effective C++pdf版
09-02
书中的每个条目（Item）都是一个独立的知识点，旨在帮助程序员写出更高效、更安全、更易于维护的代码。 1. 译序（侯捷）和导读部分，作者和译者向读者介绍了书籍的背景和阅读指南，包括C++语言的特点、编程习惯和书...
C/C++编程笔记：C++中的 swap 内置函数，用法详解
致力于C语言C++知识分享！
03-12 3万+
函数std :: swap（）是C ++标准模板库（STL）中的内置函数，该函数交换两个变量的值。 句法： swap（a，b） 参数：该函数接受两个必须交换的必需参数a和b。参数可以是任何数据类型。 返回值：该函数不返回任何内容，它交换两个变量的值。 下面的程序说明了swap（）函数： 示例一： #include <bits/stdc++.h> using namespace std; int main() { int a = 10; int b = 2
C++STL中swap函数操作与内存地址改变的简析
digitalkee的博客
07-18 1165
写在前面 这篇文章主要讨论了STL中swap函数在交换2个容器的内容的时候是交换内存还是交换元素的问题。由于博主对C++的学习并不好，如果有什么错误恳请大家提出。下面会有一些代码展示一下swap函数在对容器进行交换的时候对内存地址的影响，感兴趣的同学也可以自己写一下代码，会更加直观理解swap函数。 先放结论 swap函数会交换2个数据类型相同的容器内容。本身交换的速度非常快，因为swap在交换的时候并不是完全将2个容器的元素互换，而是交换了2个容器内的内存地址。除了数组，其他容器在交换后本质上是将内存地
谈谈C++中的swap函数
热门推荐
dizuo的专栏
05-21 14万+
1，最通用的模板交换函数模式：创建临时对象，调用对象的赋值操作符。 template void swap ( T& a, T& b ) { T c(a); a=b; b=c; }  需要构建临时对象，一个拷贝构造，两次赋值操作。 2，针对int型优化： void swap(int & __restrict a, int & __restrict b) { a ^= b; b ^= a
boost::swap 的实现原理
我的E家
03-12 1512
在 STL 已提供std::swap 时为什么还有必要使用 boost::swap？ std::swap 的行为等效于： template void swap ( T& a, T& b ) { T c(a); a=b; b=c; } 现在，对于存储大量数据的类，此方法可能不是交换数据的最有效方法，因为 swap 涉及到一个 
c++中std::swap使用方法
四叶草姚的博客
07-30 3万+
c++中std::swap使用方法 1.std::swap的源码： template&lt;typename _Tp&gt; inline void swap(_Tp&amp; __a, _Tp&amp; __b) #if __cplusplus &gt;= 201103L noexcept(__and_&lt;is_nothrow_move_constructible...
关于std::swap 中实现的移动语义
znHD的博客
07-25 2929
在swap中，会默认使用对象的右值引用进行移动，如果 没有右值引用，则调用默认拷贝构造函数。 在linux环境下进行验证。 1.类中只定义了左值引用拷贝构造函数和重载运算符=。 结果如下： 先生成a，b对象，在swap中构建了一个局部变量，然后进行拷贝构造。 2.类中定义了左值引用的拷贝构造函数、重载=和右值引用的构造函数、移动构造函数。 结果如下：   在生成a,b对...
Effective c++之Item 25: 考虑支持不抛异常的 swap
janeqi1987的专栏
07-19 296
swap 是一个有趣的函数。最早作为 STL 的一部分被引入，后来它成为异常安全编程（exception-safe programming）的支柱（参见 Item 29）和压制自赋值可能性的通用机制（参见 Item 11）。因为 swap 太有用了，所以正确地实现它非常重要，但是伴随它的不同寻常的重要性而来的，是一系列不同寻常的复杂性。在本 Item 中，我们就来研究一下这些复杂性究竟是什
EffectiveC++ Item25测试
weixin_33795806的博客
09-30 85
test case1: #include &lt;iostream&gt; #include&lt;vector&gt; #include &lt;string&gt; #include &lt;boost/foreach.hpp&gt; #include &lt;boost/shared_ptr.hpp&gt; using namespace std; class Wi...
C++快速排序之sort()
onejune的博客
04-30 6427
sort()函数是C++中的排序函数其头文件为：#include头文件； sort()相对于qsort()更加灵活，对基本的类型排序不需要定义排序函数 1、sort() sort 对给定区间所有元素进行排序 stable_sort 对给定区间所有元素进行稳定排序 partial_sort 对给定区间所有元素部分排序 partial_sort_copy 对给定区间复制并排序 n
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值