What does `std::swap` do when applied to these objects?

Question

The code

using namespace std;

class A 
{
private:
  vector<int> a;
public:
  A(vector<int> x):a(x){}
  string toString()
  {
      string s;
      for (auto& element : a)
      {
          s += to_string(element) + " ";
      }
      return s;
  }
};

int main()
{
    A a1({1,2,3});
    A a2({11,12,13});

    cout << "a1 = " << a1.toString() << "\n";
    cout << "a2 = " << a2.toString() << "\n";
    
    swap(a1,a2);
    
    cout << "a1 = " << a1.toString() << "\n";
    cout << "a2 = " << a2.toString() << "\n";
    
    return 0;
}

outputs as expected

a1 = 1 2 3                                                                                                            
a2 = 11 12 13                                                                                                         
a1 = 11 12 13                                                                                                         
a2 = 1 2 3

From cplusplus.com > std::swap under complexity

Non-array: Constant: Performs exactly one construction and two assignments (although notice that each of these operations works on its own complexity).

Array: Linear in N: performs a swap operation per element.

Does it mean that std::swap when applied to a1 and a2 only swaps the pointers to the arrays [1,2,3] and [11,12,13] but does not copy any int or anything else?

What exactly does std::swap does when applied to two objects of the class A?

Assuming the std::swap copies all elements of the array, should I write a static A::swap function, using vector::swap whose time complexity is constant (from cplusplus.com > vector::swap) meaning that it only swaps the pointers?

[..] want to add a note that the semantics of std::swap is changed in C++17. So it might be a good idea to mention compiler, version of it and what standard you target.

I was hoping that a simple looking question would not have brought about complexities about C++ standards and compiler versions. I typically compile my code in C++11. For the sake of completeness here is the gcc version on my laptop.

$ gcc --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/c++/4.2.1
Apple LLVM version 9.0.0 (clang-900.0.39.2)
Target: x86_64-apple-darwin17.3.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

I'll admit defeat regarding the overload issue. But then want to add a note that the semantics of [`std::swap`](http://en.cppreference.com/w/cpp/algorithm/swap) is changed in C++17. So it might be a good idea to mention compiler, version of it and what standard you target. And what you ask about is directly influenced by that semantic change in C++17. — Some programmer dude, Feb 19 '18 at 07:42
Related: [Move semantics == custom swap function obsolete?](https://stackoverflow.com/questions/6416385/move-semantics-custom-swap-function-obsolete); [How to overload std::swap()](https://stackoverflow.com/questions/11562/how-to-overload-stdswap) — xskxzr, Feb 19 '18 at 08:19

chill · Answer 1 · 2018-02-19T08:24:18.930

5

There is a requirement that the type parameter to the std::swap template is MoveConstructible and MoveAssignable. This suggests that the swap can be written roughly as (a few bits omitted)

void swap(T &a, T &b) {
   T tmp{std::move(a)};
   a = std::move(b);
   b = std::move(tmp);
}

For your example class, it'll invoke the default move ctor/move assignment operators (edit: of A) a few times and they in turn will invoke those of std::vector. IOW, you can expect your program to be reasonably efficient as is.

Alternatively, you can define a non-member swap function in the same namespace as A and call explicitly std::swap with vector parameters. Or call directly std::vector::swap.

edited Feb 19 '18 at 08:24

answered Feb 19 '18 at 08:13

chill

16,470
2
40
44

It should be noted that the move constructible and assignable parts only came in the C++17 standard. – Some programmer dude Feb 19 '18 at 08:32
@Someprogrammerdude These requirements exist before C++17. C++17 excludes this function from overload resolution if these requirements are not met. – xskxzr Feb 19 '18 at 08:43

score 1 · Answer 2 · answered Feb 19 '18 at 08:06

Depending on your compiler and the classes/types you are using the swap function will either copy one of the classes, or use the move constructor/assignment (C++11 and upwards) (http://en.cppreference.com/w/cpp/utility/move).

Your class only consists of a vector and for vector classes this move constructor does what you refer to as simply "swapping pointers", so it will be very quick. Just be aware that implementing e.g. a copy constructor will delete the implicitly-declared move constructor which makes this 'magic' happen!! (http://en.cppreference.com/w/cpp/language/move_constructor#Implicitly-declared_move_constructor)

While looking at the swap function independently, I'm giving you an avalanche of followup-insights: One of the most famous uses of the swap-function happens in the copy-and-swap idiom (https://progdoo.wordpress.com/2012/06/03/c11-copy-and-swap-idiom/). This works most efficiently with implemented move-constructors/assignments.

What does `std::swap` do when applied to these objects?

2 Answers2