窥视C++细节-为资源管理类提供swap函数的原因

最新推荐文章于 2024-08-05 14:31:08 发布
最新推荐文章于 2024-08-05 14:31:08 发布
阅读量304 收藏 1
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiuguolu1108/article/details/114800052
版权

文章目录


在有资源的类中，使用swap函数交换两个对象时，如果没有正确的使用swap函数，则会造成资源的拷贝和释放，导致性能降低。

环境

在运行测试代码时，使用了如下环境：

linux使用的是ubuntu 18，在ubuntu上使用的g++版本如下：

root@learner:~# g++ --version
g++ (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0

定义一个用于测试的类

class A
{
public:
    A(const char *s = nullptr){
        cout << "constuctor :" << this << endl;
        if (s == nullptr){
            str_ = new char[1];
            *str_ = '\0';
        }else{
            int len = strlen(s);
            str_ = new char[len + 1];
            strcpy(str_, s);
        }
    }

    A(const A &another){
        cout << this << " cpy constructor from " << &another << endl;

        int len = strlen(another.str_);
        str_ = new char[len + 1];
        strcpy(str_, another.str_);
    }

    A &operator=(const A &another){
        cout << this << " operator= from " << &another << endl;

        if (this != &another){
            delete[] this->str_;

            int len = strlen(another.str_);
            this->str_ = new char[len + 1];
            strcpy(this->str_, another.str_);
        }

        return *this;
    }

    A(A &&another){
        cout << this << " move constructor from " << &another << endl;

        this->str_ = another.str_;

        another.str_ = nullptr;
    }

    A &operator=(A &&another){
        cout << this << " move operator= from" << &another << endl;
        if (this != &another){
            delete[] this->str_;

            this->str_ = another.str_;

            another.str_ = nullptr;
        }

        return *this;
    }

    ~A(){
        cout << "deconstrutor :" << this << endl;
        if (str_){
            delete[] str_;
        }
    }

    char * c_str(){
        return str_;
    }

private:
    char *str_;
};

使用std::swap函数

使用标准库中的std::swap函数交换两个对象时，需要分为两种情况：一种是类内有移动构造和移动赋值运算符；另一类是没有移动构造和移动赋值运算符。

类内有移动构造和移动赋值运算符
int main()
{
    A a("hello");
    A b("world");

    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;

    cout << "===========" << endl;
    std::swap(a, b);
    cout << "===========" << endl;

    cout<<"a = "<<a.c_str()<<endl;
    cout<<"b = "<<b.c_str()<<endl;

    return 0;
}

constuctor :0x7ffd1dfe3758
constuctor :0x7ffd1dfe3760
&a = 0x7ffd1dfe3758
&b = 0x7ffd1dfe3760
===========
0x7ffd1dfe3720 move constructor from 0x7ffd1dfe3758
0x7ffd1dfe3758 move operator= from0x7ffd1dfe3760
0x7ffd1dfe3760 move operator= from0x7ffd1dfe3720
deconstrutor :0x7ffd1dfe3720
===========
a = world
b = hello
deconstrutor :0x7ffd1dfe3760
deconstrutor :0x7ffd1dfe3758

类提供了移动构造和移动赋值运算符时，交换两个对象发生了一次移动构造、两次移动赋值运算和一次析构。

在这里插入图片描述

调用std::swap函数之前的状态。
在这里插入图片描述

首先使用a对象，通过移动构造，构造出tmp对象。tmp对象构造结束后，a对象变成了将亡值，此时a对象内部的资源已被掏空。
在这里插入图片描述

通过移动赋值运算，将b对象内部的资源转移至对象a中，此时b对象变成了将亡值。
在这里插入图片描述

再次通过移动赋值运算，将tmp对象内部的资源转移值对象b中，tmp对象变成了将亡值。
在这里插入图片描述

当std::swap()函数接收时，tmp对象离开其作用域，调用析构器将其析构掉。

可以看出，在类提供了移动构造和移动赋值时，此时使用std::swap()交换对象时，仅仅是对象内部资源的搬移，并没有产生资源的拷贝，所以性能很高。

int main()
{
    A a("hello");
    A b("world");

    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;

    cout << "===========" << endl;
    //std::swap(a, b);
    {
        A tmp = std::move(a);
        a = std::move(b);
        b = std::move(tmp);
    }
    
    cout << "===========" << endl;

    cout<<"a = "<<a.c_str()<<endl;
    cout<<"b = "<<b.c_str()<<endl;

    return 0;
}

constuctor :0x7ffc0df0daf0
constuctor :0x7ffc0df0daf8
&a = 0x7ffc0df0daf0
&b = 0x7ffc0df0daf8
===========
0x7ffc0df0db00 move constructor from 0x7ffc0df0daf0
0x7ffc0df0daf0 move operator= from0x7ffc0df0daf8
0x7ffc0df0daf8 move operator= from0x7ffc0df0db00
deconstrutor :0x7ffc0df0db00
===========
a = world
b = hello
deconstrutor :0x7ffc0df0daf8
deconstrutor :0x7ffc0df0daf0

通过这段代码测试可以看出，std::swap(a,b);和如下代码的效果是一致的。

A tmp = std::move(a);
a = std::move(b);
b = std::move(tmp);
类内没有移动构造和移动赋值运算符
int main()
{
    A a("hello");
    A b("world");

    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;

    cout << "===========" << endl;
    std::swap(a, b);
    cout << "===========" << endl;

    cout<<"a = "<<a.c_str()<<endl;
    cout<<"b = "<<b.c_str()<<endl;

    return 0;
}

constuctor :0x7ffef856f578
constuctor :0x7ffef856f580
&a = 0x7ffef856f578
&b = 0x7ffef856f580
===========
0x7ffef856f540 cpy constructor from 0x7ffef856f578
0x7ffef856f578 operator= from 0x7ffef856f580
0x7ffef856f580 operator= from 0x7ffef856f540
deconstrutor :0x7ffef856f540
===========
a = world
b = hello
deconstrutor :0x7ffef856f580
deconstrutor :0x7ffef856f578

类没有提供了移动构造和移动赋值运算符时，交换两个对象发生了一次拷贝构造、两次拷贝赋值和一次析构。
在这里插入图片描述

调用std::swap函数之前的状态。

在这里插入图片描述

通过a对象拷贝构造出tmp对象，此时a对象内部的资源发生了一次拷贝。

在这里插入图片描述

将b对象赋值给a对象，先是将a对象内部的资源释放掉，之后拷贝一份b对象内部的资源。

在这里插入图片描述

将tmp对象赋值给b对象，此时也会发生资源的释放和拷贝。
在这里插入图片描述

std::swap函数调用结束后，tmp调用析构器将资源销毁。

此时std::swap(a,b)等同于如下代码：

A tmp = a;
a = b;
b = tmp;

通过上面的分析可知，当类没有提供移动构造和移动赋值时，使用std::swap函数交换两个对象时，会导致多次资源的拷贝和释放。如果资源很大，会消耗大量性能。

提供自己的swap函数

在没有移动构造和移动赋值时，可以提供自己的swap函数，同样也可以避免资源的拷贝和释放。

class A
{
public:
    ...
    void swap(A & another)
    {
        std::swap(str_,another.str_);
    }
    ...
};

int main()
{
    A a("hello");
    A b("world");

    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;

    cout << "===========" << endl;
    a.swap(b);
    cout << "===========" << endl;

    cout<<"a = "<<a.c_str()<<endl;
    cout<<"b = "<<b.c_str()<<endl;

    return 0;
}

constuctor :0x7ffcf371c3c8
constuctor :0x7ffcf371c3d0
&a = 0x7ffcf371c3c8
&b = 0x7ffcf371c3d0
===========
===========
a = world
b = hello
deconstrutor :0x7ffcf371c3d0
deconstrutor :0x7ffcf371c3c8

在调用类内部成员函数的时候，直接将a对象和b对象内部资源的指针交换。在交换两个对象时，交换的仅仅是两个指针，效率很高。

class A
{
public:
    ...
    void swap(A & another)
    {
        std::swap(str_,another.str_);
    }
    ...
};

inline void swap(A & x, A &y)
{
    x.swap(y);
}

提供一个全局的swap函数，和std::swap函数实现重载。当在调用swap的参数是A类对象时，会使用我们提供的全局函数，效率更高。

int main()
{
    A a("hello");
    A b("world");

    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;

    cout << "===========" << endl;
    swap(a,b);
    cout << "===========" << endl;

    cout<<"a = "<<a.c_str()<<endl;
    cout<<"b = "<<b.c_str()<<endl;

    return 0;
}

constuctor :0x7ffffd5c6c28
constuctor :0x7ffffd5c6c30
&a = 0x7ffffd5c6c28
&b = 0x7ffffd5c6c30
===========
===========
a = world
b = hello
deconstrutor :0x7ffffd5c6c30
deconstrutor :0x7ffffd5c6c28

在SGI版本的STL中，也是使用上面这种方式为容器提供交换函数。例如vector的交换函数源码如下：

//vector内部函数成员
void swap(vector<T, Alloc>& x) {
    std::swap(start, x.start);                       
    std::swap(finish, x.finish);
    std::swap(end_of_storage, x.end_of_storage);
}

//全局函数
template <class T, class Alloc>
inline void swap(vector<T, Alloc>& x, vector<T, Alloc>& y) {
  x.swap(y);
}

vector内部的swap函数，在交换两个vector容器时，仅仅交换了vector内部的三个指针。

总结

在有资源的类中，如果没有移动构造和移动赋值，此时调用标准库中的swap函数，会发生资源的拷贝和释放，降低程序的性能。我们可以为其提供一个全局重载的swap函数，在这个函数中，交换指向资源的指针就可以实现对象的交换，交换两个指针的效率比交换资源的效率高太多了。

玩转流媒体
关注
专栏目录
c语言中swap函数的参数,std :: swap()函数以及C ++ STL中的示例
weixin_39714565的博客
05-18 2154
std :: swap()swap()是一个标准的库函数，它可以将任意两个对象交换b / w值。在C11中，它已移至标头下。以下是swap()的语法详细信息。语法：voidswap(T&a,T&b);参数： T＆a，T＆b，它们是要交换的对象返回类型： void-不返回任何内容。用法：交换两个对象的黑白值例子：1)交换两种内置数据类型在下面的示例中，我们看到如何使用std...
从C到C++ 命名空间---函数重载---内联函数---混合编程
ershiyidian的博客
07-20 1739
这是因为 C++ 取消了原来的限制，变量只要在使用之前定义好即可，不强制必须在函数开头定义所有变量。//在for循环的条件语句内部定义变量ii>n;return 0;运行结果：Total: 55在C语言中，动态分配内存用 malloc() 函数，释放内存用 free() 函数。//分配10个int型的内存空间free(p);//释放内存在C++
谈谈C++中的swap函数
leonwlwei的博客
07-24 513
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
c++ std::swap() 函数
qq_30694087的博客
08-22 2万+
c++ std::swap() 函数 最近刚开始学习c++容器，发现容器中提供的swap()函数并不是交换了两个容器的内容，而是交换了两个容器的地址。比如如下代码： #include <vector> #include <iostream> using namespace std; template<class Os, class Co> Os& operator<<(Os& os, const Co& co) { os &l
C++---库函数swap的用法
最新发布
Frank---7的博客
08-05 1103
std::swap函数：用于交换任意类型的两个变量。容器的swap成员函数：用于交换两个同类型容器的内容。
c++——std::swap的实现
www_dong的博客
11-04 3057
std::swap的源码实现如下： template<typename T> void swap(T &a,T &b) noexcept { T temp = std::move(a); a = std::move(b); b = std::move(temp); } std::swap是基于std::move语义实现的，关于std::move的介绍可以参考：c++11总结03——右值引用_www_dong的博客-CSDN博客 ...
swap函数的用法
u014114223的博客
05-16 1403
对于复杂类型，特别是那些包含资源管理的类，建议在类的实现中提供一个swap成员函数或非成员友元函数来定制交换逻辑，以确保资源正确处理且交换操作高效执行。// ... 成员变量和方法public:// 实现具体的交换逻辑。
交换函数2_swap_c++交换函数_
10-03
为了解决这个问题，我们可以为我们的类提供一个成员函数`swap`，或者重载全局`swap`函数。这里我们关注成员函数`swap`的实现，即`2_swap_c++交换函数`所涉及的内容。 在C++中，一个类的`swap`成员函数通常如下所示...
C++ Swap函数有几种写法？
01-20
在C++编程中，交换两个变量的值是一个常见的操作，`swap`函数就是用来完成这一任务的。在C++中，`swap`函数有多种不同的实现方式，每种都有其特定的适用场景和优缺点。这里我们将探讨几种常见的`swap`函数实现方法。...
C++ 中的Swap函数写法汇总
12-20
在C++编程中，`swap`函数是一种用于交换两个变量值的常见操作，它具有广泛的应用，例如在排序算法、容器操作以及数据结构的变换中。这篇文章主要探讨了`swap`函数的不同实现方法，从基本的C语言实现到C++中的模板化...
浅谈c/c++中的swap( )函数
Stack_OVER_flow的博客
01-30 1128
swap( )函数指用来交换两个变量的值的函数。 int swap(a, b) { // switch the value of a and b. return 0; } 使用 C/C++ 编程时，经常需要自己实现一下swap( )函数，在实现的时候可能会遇到的问题在这个blog里归纳总结一下。 1. 直接交换（典型错误） 例子如下 int swap(int a, int b) { int tmp; tmp = a; a = b; b = tmp; return 0; } 调
笔记82：关于 C++ 中的 swap 函数
weixin_44063383的博客
03-28 1575
背景：在刷题时发现参考代码使用了swap函数，但是是用来交换一个vector容器中的两个元素的；但是我依稀记得标准模板库中vector函数自带的swap函数是用来交换两个容器内所有的元素的；
C++11标准模板（STL）- 算法（std::swap）
qq_40788199的博客
11-04 1690
交换给定值 1) 交换 a 与 b 。此重载仅若 std::is_move_constructible_v && std::is_move_assignable_v 为 true 才参与重载决议。 (C++17 起)
【C++】std::swap() 如果类中有动态内存分配，该如何处理
njust_cse_17_wc的博客
01-03 675
使用std::swap高效的交换自定义类型对象
std::swap
IT江湖的刀光剑影
02-28 6637
std::swap             function template     template void swap ( T& a, T& b ); Exchange values of two objects(交换两个对象的值) Assigns the content of a to b and the content of b to a. （将a的内容给b，将b的内容给a。
Modern C++ std::swap的实现原理
老宅的虚拟空间
01-28 304
std::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...
【C++】string的模拟实现
学了就忘是正常现象
11-16 2767
C++中string类的模拟实现。
C++设计模式由浅入深（四）——swap抽丝剥茧
wbvalid的博客
06-12 2138
四、深入浅出剖析swap 1 STL与swap swap操作被广泛应用与C++标准库中。所有的标准模板库（STL）容器都提供了swap函数，并且同时支持非成员版本的函数模板std::swap。swap在STL的算法中也有广泛应用。标准库也是常常被用来实现与之类似自定义功能的模板库。因此，我们将会开始学习swap操作并且仔细研究标准库提供的函数细节。 1.1 swap与STL容器 从概念上讲，swap所做的行为就如同下面所示的操作： template <typename T> void swap(
c++ swap函数
06-02
C++ STL中的swap函数用于交换两个变量的值，其定义如下： ```c++ template<class T> void swap(T& a, T& b); ``` 其中，T是要交换的变量的类型，a和b是要交换的变量，可以是任何数据类型，包括内置类型（如int、double等）和自定义类型。 使用时，只需要传入两个变量的引用即可，如下所示： ```c++ int a = 1, b = 2; swap(a, b); cout << "a = " << a << ", b = " << b << endl; // 输出a = 2, b = 1 ``` 需要注意的是，swap函数是通过引用进行传递的，因此它不会创建任何副本，可以有效地避免数据的拷贝和内存占用。同时，它也能够适用于任何类型的变量，包括数组、结构体等复杂类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值