C++ 无法使用带有常量引用的lambda对std:：vector进行排序

我想根据自定义数据类型对向量进行排序。我听从了他的回答。我使用lambda函数来比较对象。但是，在排序时，我遇到如下编译器错误：

/usr/include/c++/7/bits/stl_algo.h:1852:错误：无法将类型为“MyData&”的非常量左值引用绑定到类型为“std:：remove_reference:：type{aka MyData}”的右值 *__第一个=_GLIBCXX_MOVE（__val）； ^

main.cpp

#include "mydata.h"
#include <vector>

int main()
{
    std::vector<MyData> tv {MyData(2,21), MyData(3,20), MyData(10,100), MyData(9,20)};

    std::sort(tv.begin(), tv.end(), []( MyData const& lhs, MyData const& rhs ){
         return lhs.get_size() < rhs.get_size();
    });

    return 0;
}

#包括“mydata.h”
#包括
int main（）
{
向量电视{MyData（2,21），MyData（3,20），MyData（10100），MyData（9,20）}；
std:：sort（tv.begin（）、tv.end（）、[]（MyData常量和lhs、MyData常量和rhs）{
返回lhs.get_size（）

mydata.cpp

#ifndef MYDATA_H
#define MYDATA_H
#include <iostream>
#include <algorithm>

class MyData
{
private:

    int *m_data;
    int m_x;
    size_t m_size;

public:
    MyData(const size_t &size,int const &x):
        m_data(new int[size]),
        m_x(x),
        m_size(size)
    {

        std::fill_n(m_data,m_size, m_x);
        std::cout << *m_data << " ctor" << m_size << std::endl;
    }

    MyData(const MyData& other):
        m_data(new int[other.m_size]),
        m_x(other.m_x),
        m_size(other.m_size)
    {
        std::fill_n(m_data,m_size, m_x);
        std::cout << *m_data << " cctor" << m_size << std::endl;
    }

    MyData& operator=(MyData& other)
    {
        std::cout << *m_data << " cbctor" << m_size << std::endl;
        swap(*this,other);
        std::cout << *m_data << " cactor" << m_size << std::endl;
        return *this;
    }

    ~MyData(){
        std::cout << *m_data << " dtor" << m_size << std::endl;
        delete[] m_data;
    }

    size_t get_size() const{
        return m_size;
    }

    friend void swap(MyData& first, MyData& second){    // (1)
        std::swap(first.m_size, second.m_size);
        std::swap(first.m_x, second.m_x);
        std::swap(first.m_data, second.m_data);
    }

    friend std::ostream& operator<< (std::ostream& stream, const MyData& mydata) {
        stream << *(mydata.m_data) << " " << mydata.m_size << " "<< mydata.m_x;
        return stream;

    }

};

#endif // MYDATA_H

\ifndef MYDATA\u H
#定义我的数据
#包括
#包括但不理解为什么会发生在这里。
谢谢。
您应该这样修改代码：

#include <iostream>
#include <fstream>
#include <thread>
#include <atomic>
#include <algorithm>
#include <vector>

using namespace std;
class MyData
{
private:

    int *m_data;
    int m_x;
    size_t m_size;

public:
    MyData(const size_t &size, int const &x) :
        m_data(new int[size]),
        m_x(x),
        m_size(size)
    {

        std::fill_n(m_data, m_size, m_x);
        std::cout << *m_data << " ctor" << m_size << std::endl;
    }

    MyData(const MyData& other) :
        m_data(new int[other.m_size]),
        m_x(other.m_x),
        m_size(other.m_size)
    {
        std::fill_n(m_data, m_size, m_x);
        std::cout << *m_data << " cctor" << m_size << std::endl;
    }

    MyData& operator=(const MyData& other)
    {
        std::cout << *m_data << " cbctor" << m_size << std::endl;
        //swap(*this, other);

        if (this != &other)
        {
            this->m_data = new int[other.m_size];
            for (size_t i = 0; i < other.m_size; ++i)
            {
                this->m_data[i] = other.m_data[i];
            }
            this->m_x = other.m_x;
            this->m_size = other.m_size;
        }
        std::cout << *m_data << " cactor" << m_size << std::endl;
        return *this;
    }

    ~MyData() {
        std::cout << *m_data << " dtor" << m_size << std::endl;
        delete[] m_data;
    }

    size_t get_size() const {
        return m_size;
    }

    friend void swap(MyData& first, MyData& second) {    // (1)
        std::swap(first.m_size, second.m_size);
        std::swap(first.m_x, second.m_x);
        std::swap(first.m_data, second.m_data);
    }

    friend std::ostream& operator<< (std::ostream& stream, const MyData& mydata) {
        stream << *(mydata.m_data) << " " << mydata.m_size << " " << mydata.m_x;
        return stream;

    }

};

int main()
{
    std::vector<MyData> tv{ MyData(2,21), MyData(3,20), MyData(10,100), MyData(9,20) };

    std::sort(tv.begin(), tv.end(), [](MyData const& lhs, MyData const& rhs) {
        return lhs.get_size() < rhs.get_size();
    });
    std::system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
类MyData
{
私人：
int*m_数据；
int m_x；
大小；
公众：
MyData（常量大小、整数常量和x）：
m_数据（新整数[大小]），
m_x（x），
m_尺寸（尺寸）
{
std:：fill_n（m_数据、m_大小、m_x）；
std:：cout您应该这样修改代码：

#include <iostream>
#include <fstream>
#include <thread>
#include <atomic>
#include <algorithm>
#include <vector>

using namespace std;
class MyData
{
private:

    int *m_data;
    int m_x;
    size_t m_size;

public:
    MyData(const size_t &size, int const &x) :
        m_data(new int[size]),
        m_x(x),
        m_size(size)
    {

        std::fill_n(m_data, m_size, m_x);
        std::cout << *m_data << " ctor" << m_size << std::endl;
    }

    MyData(const MyData& other) :
        m_data(new int[other.m_size]),
        m_x(other.m_x),
        m_size(other.m_size)
    {
        std::fill_n(m_data, m_size, m_x);
        std::cout << *m_data << " cctor" << m_size << std::endl;
    }

    MyData& operator=(const MyData& other)
    {
        std::cout << *m_data << " cbctor" << m_size << std::endl;
        //swap(*this, other);

        if (this != &other)
        {
            this->m_data = new int[other.m_size];
            for (size_t i = 0; i < other.m_size; ++i)
            {
                this->m_data[i] = other.m_data[i];
            }
            this->m_x = other.m_x;
            this->m_size = other.m_size;
        }
        std::cout << *m_data << " cactor" << m_size << std::endl;
        return *this;
    }

    ~MyData() {
        std::cout << *m_data << " dtor" << m_size << std::endl;
        delete[] m_data;
    }

    size_t get_size() const {
        return m_size;
    }

    friend void swap(MyData& first, MyData& second) {    // (1)
        std::swap(first.m_size, second.m_size);
        std::swap(first.m_x, second.m_x);
        std::swap(first.m_data, second.m_data);
    }

    friend std::ostream& operator<< (std::ostream& stream, const MyData& mydata) {
        stream << *(mydata.m_data) << " " << mydata.m_size << " " << mydata.m_x;
        return stream;

    }

};

int main()
{
    std::vector<MyData> tv{ MyData(2,21), MyData(3,20), MyData(10,100), MyData(9,20) };

    std::sort(tv.begin(), tv.end(), [](MyData const& lhs, MyData const& rhs) {
        return lhs.get_size() < rhs.get_size();
    });
    std::system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
类MyData
{
私人：
int*m_数据；
int m_x；
大小；
公众：
MyData（常量大小、整数常量和x）：
m_数据（新整数[大小]），
m_x（x），
m_尺寸（尺寸）
{
std:：fill_n（m_数据、m_大小、m_x）；
std:：cout可能存在某种类型的声明复制赋值运算符

当可以使用复制和交换习惯用法时，这是复制赋值运算符的典型声明：

MyData& operator=(MyData other);


这是复制赋值运算符在以下情况下的典型声明：
无法使用复制和交换习惯用法（不可交换类型或降级
性能）：


因此，要在实现中使用swap，可以将copy赋值操作符声明为
MyData&operator=（MyData-other）；
可以有一些类型的声明copy赋值操作符

当可以使用复制和交换习惯用法时，这是复制赋值运算符的典型声明：

MyData& operator=(MyData other);


这是复制赋值运算符在以下情况下的典型声明：
无法使用复制和交换习惯用法（不可交换类型或降级
性能）：


因此，要在您的实现中使用swap，您可以将copy赋值运算符声明为
MyData&operator=（MyData-other）；
您的赋值运算符是非常错误的
然后
a=b
将交换
a
和
b
，但是
b
预计不会更改。如果您想在赋值运算符中使用
swap
，请按值传递参数。顺便说一句，这也会解决您的问题。为什么赋值运算符试图用
其他
交换
？它绝对不应修改RHSTNKS@Someprogrammerdude将赋值更改为
MyData&operator=（MyData other）
解决了这个问题。但是我不知道在这种情况下使用swap是否是最好的。我关注了一些博客，他们说使用swap将使赋值运算符不出现异常。你应该使
m_data
a
vector
。赋值运算符应该包括一个测试
this==&other
在sel的情况下不做任何事情f赋值。您的赋值运算符非常错误。如果您有例如
MyData a（…），b（…）
然后
a=b
将交换
a
和
b
，但是
b
预计不会更改。如果您想在赋值运算符中使用
swap
，请按值传递参数。顺便说一句，这也会解决您的问题。为什么赋值运算符试图用
其他
交换
？它绝对不应修改RHSTNKS@Someprogrammerdude将赋值更改为
MyData&operator=（MyData other）
解决了这个问题。但是我不知道在这种情况下使用swap是否是最好的。我关注了一些博客，他们说使用swap将使赋值运算符不出现异常。你应该使
m_data
a
vector
。赋值运算符应该包括一个测试
this==&other
在sel的情况下不做任何事情f赋值。不要像这样修改代码。此代码中的赋值运算符是内存泄漏的原因。语句
this->m_data=new int[other.m_size]；
孤儿（从而泄漏）无论函数项中指向哪个原始数据
this->m_data
。这不是异常安全的。我不是故意让它异常安全的。我只是修复了编译问题一个空白源文件也会修复编译问题，但它没有用。不要像这样修改代码。这段代码中的赋值运算符是一个配方对于内存泄漏。语句
this->m_data=newint[other.m_size]；
孤立（因此泄漏）无论函数项中指向哪个原始数据
this->m_data
。这不是异常安全的。我不是故意让它异常安全的。我只是修复了编译问题一个空白源文件也会修复编译问题，但它没有用。