С++ 03 перемещение вектора в член класса через конструктор (семантика перемещения)

Вы можете определить тип, обертывающий ссылку, и функцию для ее обертывания, чтобы дать что-то похожее на семантику перемещения в месте вызова. Что-то в духе

template <typename T> struct move_ref {
    explicit move_ref(T & ref) : ref(ref) {}
    T & ref;
};

template <typename T> move_ref<T> move(T & t) {return move_ref<T>(t);}

Foo(move_ref< std::vector<int> > vec)
{
    using std::swap;
    swap(vec.ref, m_vec);   // "move" vec into member vector
}

Foo foo(move(v));

Кроме того, в Boost есть библиотека, позволяющая перемещать семантику без С++11.

Вы можете использовать некоторую оболочку с явным именем:

template <typename T>
class MyMove
{
public:
    explicit MyMove(T& t) : t(t) {}

    T& get() {return t;}
private:
    T& t;
};

template <typename T>
MyMove<T> myMove(T& t) { return MyMove<T>(t); }

А потом

class Foo
{
public:
    Foo(MyMove<std::vector<int>> vec)
    {
        using std::swap;
        swap(vec.get(), m_vec);   // "move" vec into member vector
    }

private:
    std::vector<int> m_vec;
};

использование:

std::vector<int> v(100, 1337);
Foo foo(myMove(v));

Конечно, в C++03 можно использовать семантику перемещения.

Используя Boost.Move:

#include <vector>
#include <utility>
#include <boost/move/move.hpp>

class Foo
{
public:
    Foo(BOOST_RV_REF(std::vector<int>) vec)
    {
        std::swap(vec, m_vec);   // "move" vec into member vector
    }

private:
    std::vector<int> m_vec;
};

int main()
{
    std::vector<int> v(100, 1337);
    Foo foo(boost::move(v));
}

Или вы можете написать его самостоятельно, который работает с l-значениями, временными объектами и где r_value_ref<T> оболочка может использоваться как T& или const T& благодаря operator T&():

#include <vector>
#include <utility>

template <typename T>
class r_value_ref
{
public:
    explicit r_value_ref(const T& t) : t(t) {}

    T& get() const
    {
        return const_cast<T&>(t);
    }

    operator T&() const
    {
        return const_cast<T&>(t);
    }

private:    
    const T& t;
};

template <typename T>
r_value_ref<T> my_move(const T& t)
{
    return r_value_ref<T>(t);
}

class Foo
{
public:
    Foo(r_value_ref<std::vector<int> > vec)
    {
        m_vec.swap(vec); // no .get() required !
        // or std::swap(vec.get(), m_vec);
    }

private:
    std::vector<int> m_vec;
};

int main()
{
    Foo foo_from_r_value(my_move(std::vector<int>(100, 1337)));

    std::vector<int> v2(100, 1337);
    Foo foo_from_l_value(my_move(v2));
}

Ссылка на демонстрацию

Однако это небезопасно, т.е. r_value_ref<int> i(123); i.get() = 456; успешно компилируется, но приводит к неопределенному поведению. Написанные вручную обертки r-value-reference требуют немного больше усилий, чтобы сделать их абсолютно безопасными.

Если я правильно понял, вы хотите «переместить» вектор в члене класса с помощью вызова конструктора.

В С++ 11 вам нужно было бы предоставить конструктор с аргументом std::vector<T>&& и вызвать

Foo my_foo(std::move(my_vector));

В C++03 вы можете добавить "именованный конструктор" или друга, который сделает эту работу за вас.

template <class T>
class Foo
{
public:

  static Foo<T> move_from_vector(std::vector<T> & vector)
  {
    Foo<T> new_foo;
    new_foo.m_vec.swap(vector);
    return new_foo;
  }
private:
  std::vector<T> m_vec;
};

Где вы могли бы использовать это так:

int main()
{
    std::vector<int> h(5);
    Foo<int> g(Foo<int>::move_from_vector(h));
}

Таким образом, становится ясно, что вектор перемещается, и синтаксис перемещения не сильно отличается от C++11 (хотя, конечно, он не является общим).

Обратите внимание, что это скопирует Foo, если оптимизация отключена.

Способ С++ 03 заключается в использовании std::auto_ptr для выражения передачи права собственности на данные.

class Foo
{
public:
    explicit Foo(std::auto_ptr<std::vector<int> > vec)
       : m_vec(vec)
    {
    }

private:
    Foo(const Foo&);
    Foo& operator=(const Foo&);

    std::auto_ptr<std::vector<int> > m_vec;
};

// usage:
std::auto_ptr<std::vector<int> > v(new std::vector<int>(100, 1337));
Foo foo(v);

// v.get() == 0

std::auto_ptr в сигнатуре четко указывает, что данные передаются внутри функции, оставляя сайт вызова с пустым указателем из-за характера копирования auto_ptr.

Обратите внимание на необходимость либо запретить, либо явно определить правильное создание копирования и назначение такого класса, поскольку конструктор копирования по умолчанию и назначение auto_ptr обычно не являются правильными.