重载运算符的范围是什么？它会影响作为 class 成员的集合的插入函数吗？

Question

我为数据结构定义了一个 class，我在其中为 class 定义了一个重载的 operator<。但是，对于 _positions，即 std::set<size_t>，insert() 函数似乎不再执行任何操作。

我想知道 class 的重载运算符是否意味着它无法查看某个位置是否在 set 中，因此不会添加它？

我可以 add/remove 到 map，但不能 set。 kFlags 是 map 并且所有这些测试都通过了。

#include <set>
#include <iostream>
#include <map>
#include <math.h>
#include "kmerClass.h"

namespace ft {

KmerClass::KmerClass(std::string kmer)
    : _kmer(kmer),
    _kFlags(),
    _positions(),
    _readIDs()
{
}

std::set<size_t> KmerClass::getKPositions() const {return this->_positions;}
void KmerClass::setKPositions( std::set<size_t> kPositions, uint offset)
{
    for (auto kPosition : kPositions){addKPosition(kPosition, offset);}
}

void KmerClass::addKPosition(const size_t& kPosition, const uint& offset)
{
    size_t kPos = kPosition + offset;
    std::set<size_t> positions = this->_positions;
    positions.insert(kPos);
}

void KmerClass::removeKPosition(size_t kPosition, uint offset)
{
    size_t kPos = kPosition + offset;
    std::set<size_t> positions = this->_positions;
    positions.erase(kPos);
}

bool KmerClass::hasKPosition(size_t kPosition) const{
    std::set<size_t> kPositions = this->_positions;
    const bool is_in = kPositions.find(kPosition) != kPositions.end();
    return is_in;
}

bool KmerClass::operator< (const ft::KmerClass &k) const {return _kmer < k._kmer;}

KmerClass::~KmerClass()
{
}
}

头文件是：

#ifndef KMERCLASS_H
#define KMERCLASS_H

#include <set>
#include <iostream>
#include <map>
#include "ftPropsClass.h"

namespace ft {

class KmerClass
{
public:
    KmerClass(std::string kmer);

    virtual ~KmerClass();

    std::string _kmer;
    std::map<ft::FlagType, bool> _kFlags;
    std::set<size_t> _positions;
    std::set<int> _readIDs;

    std::set<size_t> getKPositions()const;

    void setKPositions(std::set<size_t> kPositions, uint offset = 0);

    void addKPosition(const size_t& kPosition, const uint& offset = 0);
    
    void removeKPosition(size_t kPosition, uint offset = 0);

    bool hasKPosition(size_t position) const;

    bool operator< (const ft::KmerClass &k) const;
};
}

#endif // KMERCLASS_H

我正在尝试运行的测试是

//======================================================================
TEST_F(TestKmerClass, KPosition)
{
    TEST_DESCRIPTION("Add single position to kmer class");
    ft::KmerClass* testKmerClass = new ft::KmerClass("AAAA");

    testKmerClass->setKPositions({1000, 2340});
    EXPECT_TRUE(testKmerClass->hasKPosition(1000));
    EXPECT_FALSE(testKmerClass->hasKPosition(666));

    testKmerClass->addKPosition(666);
    EXPECT_TRUE(testKmerClass->hasKPosition(666));
    EXPECT_FALSE(testKmerClass->hasKPosition(924357));

    testKmerClass->removeKPosition(2340);
    EXPECT_FALSE(testKmerClass->hasKPosition(2340));
    EXPECT_TRUE(testKmerClass->hasKPosition(1000));
    EXPECT_TRUE(testKmerClass->hasKPosition(666));
}

Answer 1

这与运算符重载或 insert.

无关

你插入了错误的集合。

下面的每一个函数复制成员变量然后作用于副本，然后丢弃它。

void KmerClass::addKPosition(const size_t& kPosition, const uint& offset)
{
    size_t kPos = kPosition + offset;
    std::set<size_t> positions = this->_positions;
    positions.insert(kPos);
}

void KmerClass::removeKPosition(size_t kPosition, uint offset)
{
    size_t kPos = kPosition + offset;
    std::set<size_t> positions = this->_positions;
    positions.erase(kPos);
}

bool KmerClass::hasKPosition(size_t kPosition) const{
    std::set<size_t> kPositions = this->_positions;
    const bool is_in = kPositions.find(kPosition) != kPositions.end();
    return is_in;
}

添加 & 以创建 positions/kPositions 引用，或者理想情况下，直接使用 _positions。没必要这么复杂。

void KmerClass::addKPosition(const size_t kPosition, const uint offset)
{
    _positions.insert(kPosition + offset);
}

void KmerClass::removeKPosition(const size_t kPosition, const uint offset)
{
    _positions.erase(kPosition + offset);
}

bool KmerClass::hasKPosition(const size_t kPosition) const
{
    return _positions.find(kPosition) != _positions.end();
}

（我还修复了函数参数中的一些怪异之处；对 const 的使用保持一致，并且对于小型原始类型更喜欢按值，除非您需要引用语义.)

重载运算符的范围是什么？它会影响作为 class 成员的集合的插入函数吗？

what is the scope of the overloaded operator? Does it affect the insert function for a set that is a class member?

c++

operator-overloading