使用移动从矢量构造对象

Question

我有这样的代码：

class MyClass {
public:
    MyClass(std::vector &vec):
        v(vec)
    {}
    MyClass(??);

private:
    std::vector v;
};

我想像这样构造我的 class MyClass(std::move(some_vector))
我怎样才能做到这一点？

我可以将 4 行更改为 v(std::move(vec)) 但这是隐藏的动作，因为很危险。

编辑：例子

int main {
    std::vector<int> v = {1, 2}
    MyClass myobj(v); // this should be disallowed
    //MyClass myobj(std::move(v)) //this should be the only way
    //here v is empty
}

Answer 1

仅启用移动构造函数

class MyClass {
public:
    MyClass(std::vector &&vec):
        v(std::move(vec))
    {}
    MyClass() = delete; //prevent default constructor if you wish
private:
    std::vector v;
};

Answer 2

我会按值接受 std::vector 然后 std::move 它在内部

class MyClass {
public:
    MyClass(std::vector vec):
        v(std::move(vec))
    {}

private:
    std::vector v;
};

Answer 3

你可以这样做：

struct MyClass {
    // rvalue only
    MyClass(std::vector&& vec):
        v(std::move(vec))
    {}

    // lvalue
    MyClass(const std::vector&) = delete;

private:
    std::vector v;
};

任何调用左值版本的尝试都会失败，调用已删除的重载。

Answer 4

这将向您展示如何创建一个 class 您可以选择使用或不使用 class 存在其他参数的向量 and/or 不存在。

#include <vector>
#include <iostream>
#include <string>
#include <typeinfo>

using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::to_string;

class Parse
{
private:
    string         m_str;
    vector<string> m_vec;
public:
    // Constructor 1/4 with all defaults
    Parse(){ 
        cout << "\ncreating class with all default values\n";
        m_str = "";
        m_vec.push_back("");    
    }

    // Constructor 2/4 with all cases used
    Parse  (string         &tmp_str,
            vector<string> tmp_vec):

            m_str          (tmp_str),
            m_vec          (tmp_vec)
    {
        cout << "Your vector contains " + to_string(m_str.size()) + " arguments\n";
    }

    // Constructor 3/4 with other contents given but not vector
    Parse  (string         &tmp_str): 
            m_str          (tmp_str)
    {
        m_vec.push_back("");
    }
    // Constructor 4/4 with only Vector given but not other contents
    Parse  (vector<string>   tmp_vec):
            m_vec           (tmp_vec)
    {
        m_str = "";
    }

    string get_str_var(){return m_str;}

    void classed_print_vector_strings()
    {
        for (string i : m_vec){ cout << i << " \n";}
    }

};



// rm ./class_vector; g++ class_vector.cpp -o class_vector -std=c++17; ./class_vector arg1 arg2 arg3

int main(int argc, char *argv[])
{
    // turn **argv to a vector
    vector<string> args(argv, argv + argc);
    // iterate from argv through argv+argc

    // initialize with default arguments.
    Parse tracker1;
    // initalize with all used arguments
    Parse tracker2(args[0], args);
    // initalize with only the vector
    Parse tracker3(args);
    // initalzie without the vector, but with another arg
    Parse tracker4(args[0]);

    cout << "\nTracker 1 ---------------------\n";
    tracker1.classed_print_vector_strings();
    cout << "\nTracker 2 ---------------------\n";
    tracker2.classed_print_vector_strings();
    cout << "\nTracker 3 ---------------------\n";
    tracker3.classed_print_vector_strings();
    cout << "\nTracker 4 ---------------------\n";
    tracker4.classed_print_vector_strings();


    return 0;
}

rm ./class_vector; g++ class_vector.cpp -o class_vector -std=c++17; ./class_vector arg1 arg2 arg3

使用移动从矢量构造对象

Construct object from vector using move

c++

move

std

stdvector

c++11