Question

I have a type that is move-only, copy is forbidden.
I want to pass it in some system, but I’m not sure which kind of signature to use for the functions taking that type in parameter. The objects of this type have to be moved into the system, no copy should be ever done.

Example:

#include <vector>
class Foo
{
public:
    Foo( std::string name ) : m_name( std::move( name ) ){}
    Foo( Foo&& other ) : m_name( std::move( other.m_name ) ){}
    Foo& operator=( Foo&& other ){ m_name = std::move( other.m_name ); }

    const std::string& name() const { return m_name; }
    // ...
private:
    Foo( const Foo& ) ;//= delete;
    Foo& operator=( const Foo& ) ;//= delete;
    // ...

    std::string m_name;
};

class Bar
{
public:

    void add( Foo foo )  // (1)
        // or...
    void add( Foo&& foo ) // (2)
    {
        m_foos.emplace_back( std::move(foo) ); // if add was template I should use std::forward?
    }


private:
    std::vector<Foo> m_foos;
};

void test()
{
    Bar bar;
    bar.add( Foo("hello") );

    Foo foo("world");
    bar.add( std::move(foo) );
}

(Both signatures compile in VS2012, assuming I’m moving the objects)

Which signature between 1 and 2 should be the preferred?

It looks like both works but I think there have to be differences…

Answer 1

Signature #1 will cost 2 move constructions when moving from an xvalue, whereas signature #2 will cost just 1 move construction from xvalues. Therefore #2 sounds better to me. But as long as move construction is cheap, either signature will get the job done. Do you want:

1. Really fast, or
2. Twice as fast as really fast?

🙂