标签: rvalue

原始上下文：\n我试图将 (object,expected_value_of_some_property) 的元组传递给测试函数

我创建了一个简单的类来重现我面临的错误：

template <typename T>\nclass Vector\n{\nprivate:\n    size_t m_size;\n    std::unique_ptr<std::vector<int>> m_vector;\n\npublic:\n    Vector();\n    Vector(const Vector<int>&);\n    ~Vector() = default;\n\n    void push_back(T);\n    T get(int) const;\n    size_t size() const;\n};\n\ntemplate <typename T>\nVector<T>::Vector()\n:m_size(0), \nm_vector(new std::vector<T>)\n{}\n\ntemplate <typename T>\nVector<T>::Vector(const Vector<int>& v)\n:m_size(v.size()), \nm_vector(new std::vector<T>)\n{\n    for (size_t i = 0; i < v.size(); i++)\n    {\n        this->push_back(v.get(i));\n    }\n}\n\ntemplate <typename T>\nvoid Vector<T>::push_back(T value)\n{\n    m_vector->push_back(value);\n    m_size ++;\n}\n\ntemplate <typename T> \nT Vector<T>::get(int index) const\n{\n    return m_vector->operator[](index);\n}\n\ntemplate <typename T> \nsize_t Vector<T>::size() const\n{\n    return m_size;\n}\n

当尝试在测试代码中生成 Vector 对象的元组和 int 时，会触发该错误：

int …

我是 C++ 11/17 的新手，试图了解右值引用移动的工作原理。在下面的代码中，“修改的复制构造函数”和“移动构造函数”之间有什么区别？我让他们做同样的事情，但只有不同的原型。如果我在注释中添加“移动构造函数”，那么“修改的复制构造函数”也会执行相同的操作。

我的观点是为什么我们需要“移动构造函数”，现在的 C++17 与旧版本的 C++98 有什么不同？我之前只能通过不同地实现“复制构造函数”来完成同样的事情，并避免它过去所做的所有深度复制。我缺少什么？我不明白的是？

#include <iostream>

class A {
public:
    int* arr, size;
    bool flag;

    // parameterized constructor
    A(int len) {
        size = len;
        arr = new int[size];
        flag = false;
    }

    // modified copy constructor
    A(A& temp) {
        arr = temp.arr;
        size = temp.size;
        flag = temp.flag;
        temp.arr = NULL;
    }

    // move constructor
    A(A&& temp) {
        arr = temp.arr;
        size = temp.size;
        flag = temp.flag;
        temp.arr = NULL;

        std::cout << " A(A&& temp)" …

如果我运行代码

class Myc {
  private:
    int m{0};

  public:
    Myc(int ii) : m{ii} {};
    ~Myc() { std::cout << "Myc Destructed\n"; }
    int getM() const { return m; }
};

void foo(std::unique_ptr<Myc> other) { std::cout << "End foo\n"; }

int main() {
  std::unique_ptr<Myc> pm = std::make_unique<Myc>(1);

  foo(std::move(pm));

  std::cout << "End main \n";
}

pm 的所有权转移给 foo 并且输出是

End foo
Myc Destructed
End main

但如果将 foo 更改为

void foo(std::unique_ptr<Myc> &&other) { std::cout << "End foo\n"; }

pm 的所有权没有转移到 foo 因为输出是

End foo
End …

我正在编写一个类 ( )，它封装了一个恰巧具有右值函数的Interface类 ( )（请参阅 参考资料）。ImplImpl::Close

class Impl\n{\npublic:\n    /// Called from Dtor.\n    /// You can't reuse this after it has been closed\n    /// Therefore && added so need temporary / rvalue ref.\n    void Close(int why) && noexcept { /*...*/ }\n};\n\n\n\nclass Interface\n{\npublic:\n    void Close(int why) && noexcept { _i.Close(why); }\nprivate:\n    Impl _i;\n};\n

林天给我：

\n

错误：成员函数“Close”的“this”参数是左值，但函数具有右值引用限定符

\n

g++ 给了我：

main.cpp: In member function \xe2\x80\x98void Interface::Close(int) &&\xe2\x80\x99:\nmain.cpp:15:51: error: passing \xe2\x80\x98Impl\xe2\x80\x99 as \xe2\x80\x98this\xe2\x80\x99 argument discards …

我能明白是什么is_constructible_v<std::string, std::string&&>。但什么is_constructible_v<std::string&&, std::string&&>意思呢？

is_constructible_v<std::string, std::string&&>和 和有什么区别is_constructible_v<std::string&&, std::string&&>？

我认为这is_constructible_v<std::string&&, std::string&&>意味着从右值构造右值。但我不清楚是什么constructing rvalue意思。如果 T 是可构造的，那么它的构造函数总是可以用作右值。这就是构建右值的意义吗？

我们什么时候得到"需要l值"错误...编译C++程序时???(我正在使用VC++)

有什么区别:

const double& pi = 3.14;

和(没有&符号):

const double pi = 3.14;

他们似乎都有相同的L和R值,所以有什么区别？

假设我有一个名为Foo的类,带有复制赋值运算符,我认为这样:

Foo() = Foo();

是不被允许的,因为我认为(对不起,再次)Foo()是一个右值(所以我不能分配给它),是一个临时对象.显然,我试图使这个代码工作,它正常工作,显示一些字符串,以验证我的程序正确使用复制赋值运算符.

我错了吗？或者这是一种错误？有什么用处？

指针很简单.有一些存储器保存一个地址.要获取(有意义的)取消引用值,将返回地址指向的内存所包含的值.

引用在某种程度上类似于它们:它们保持与临时对象的"链接".但是当我分配或使用引用时会发生什么？

#include <iostream>
using namespace std;
int one(){
    return 1;
}
int main()
{
    const int &rone = one();
    cout << &rone << endl;
    return 0;
}

为什么这样做？这个地址是临时对象的地址吗？

sh-4.2# g++ -std=c++11 -o main *.cpp
sh-4.2# main
0x7fff9d2a4e74

这个地址指向哪里？如果它指向神奇的临时对象,为什么我不能做以下事情.(我很清楚它是一个右值,&只接受左值,但为什么？)

int main()
{
    cout << &one() << endl;
    return 0;
}

我的问题超出了c ++的编程方面.它更多地是在技术方面,C++如何在内部工作.主要是我试图理解移动语义的上下文中的右值引用,这需要理解那些传统的引用(我几乎没用过).

在这段代码中:

const int & fun(const int &i)
{
    return 2*i;
}

int main()
{
    const int k=3;
    cout<<fun(k)<<endl;
    return 0;
}

在这种情况下,参数fun不是本地的(没有临时对象存储引用返回类型)那么为什么会出现此警告？ +如果我删除常量从返回类型函数fun,它说

错误:从'int'类型的右值开始,无效初始化'int&'类型的非const引用

但是在删除2*(只剩下我返回的值时)它没有显示任何错误 - >我能想到的是这个2*的东西是将返回转换为Rvalue但是后来不是Rvalue本身的返回值？我哪里错了？