STL按客户']对向量进行排序>

Question

我已经定义了一个类“ HasPtr”：

#include <iostream>
#include <string>

class HasPtr {
public:
    HasPtr()
        : ps(new std::string()), i() {
            std::cout << "Default constructor execute" << std::endl;
    }
    HasPtr(const std::string &s, int a)
        : ps(new std::string(s)), i(a) {
            std::cout << "Sting with int constructor execute" << std::endl;
    }
    HasPtr(const std::string &s = std::string())
        : ps(new std::string()), i(0) {
            std::cout << "String constructor execute" << std::endl;
    }
    HasPtr(const HasPtr &obj)
        : ps(new std::string(*obj.ps)), i(obj.i) {
            std::cout << "Copy constructor execute" << std::endl;
    }
    HasPtr & operator=(const HasPtr &rhs) {
        std::cout << "Assign execute" << std::endl;
        ps = new std::string(*rhs.ps);
        i = rhs.i;
        return *this;
    }
    ~HasPtr() {
        delete ps;
    }

    std::string get_str() const {
        return *ps;
    }

    int get_i() const {
        return i;
    }
    bool operator<(const HasPtr obj) const {
        std::cout << "Operator < execute" << std::endl;
        return i < obj.i;
    }

    friend void swap(HasPtr &lhs, HasPtr &rhs) {
        std::cout << "HasPtr::swap function execute" << std::endl;
        std::swap(lhs.ps, rhs.ps);
        std::swap(lhs.i, rhs.i);
    }

private:
    std::string *ps;
    int i;
};
这是我的main.cpp：

#include <iostream>
#include <vector>
#include <algorithm>
#include "HasPtr.h"


int main() {
    size_t n = 3;
    std::vector<HasPtr> v;
    for (size_t i = 0; i < n; ++i) {
        v.push_back(std::to_string(i));
    }

    sort(v.begin(), v.end());
}
我想知道为什么将bool operator<(const HasPtr obj) const定义为const？我认为向量中的所有元素都不是const。对吧？

我不了解执行情况：

字符串构造函数执行

复制构造函数执行

字符串构造函数执行

复制构造函数执行

复制构造函数执行

字符串构造函数执行

复制构造函数执行

复制构造函数执行

复制构造函数执行

复制构造函数执行

运算符

复制构造函数执行

复制构造函数执行

运算符

分配执行

复制构造函数执行

运算符

复制构造函数执行

复制构造函数执行

运算符

分配执行

为什么会有这么多的“副本结构”和两个“任务”？

3. 为什么未调用交换功能？排序如何重新排列元素？

谢谢

我已经定义了一个类“ HasPtr”：#include #include class HasPtr {public：HasPtr（）：ps（new std :: string（）），i（）{std :: cout <

比较运算符应该只进行比较，比较和修改是没有意义的，而且是有害的。定义const可以保证不会发生任何不良情况。

vector需要复制构造函数的复制赋值运算符可用。如果前者不可用，它将检查move构造函数和move赋值运算符。

想象您具有此功能

int
my_fnct(const HasPtr &a,
        const HasPtr &b)
{
  int result=12;
  // ... do something ...
  if(a<b) // <--- the comparison is important
  {
    result+=100; // or whatever ...
  }
  // ... do something ...
  return result;
}
如果您的HasPtr::operator<()被声明为

bool operator<(const HasPtr &obj) // <-- without const here
{ /* ... */ }
然后，上一个a<b中的呼叫my_fnct()将编译器不允许，因为参数a为声明为const。

另一方面，如果您的HasPtr::operator<()被声明为

bool operator<(const HasPtr &obj) const // <-- const at the end here
{ /* ... */ }
然后，前一个a<b中的呼叫my_fnct()将被允许从原型末尾的const关键字开始编译确保比较的左操作数（在我之前的示例中为a）将不会被修改。

Answer 1

比较运算符应该只进行比较，比较和修改是没有意义的，而且是有害的。定义const可以保证不会发生任何不良情况。

Answer 2

想象您具有此功能