相关疑难解决方法(0)

给出以下代码片段,

class Num
{
public:
    Num(int iNumber = 0) : m_iNumber(iNumber) {}

    Num operator+=(const Num& rhs)
    {
        this->m_iNumber = (this->m_iNumber + rhs.m_iNumber);
        return *this;
    }
private:
    int m_iNumber;
};

//===========================================================
int _tmain(int argc, _TCHAR* argv[])
{
    Num a(10);

    Num b(100);

    b += a;

    return 0;
}

我想知道如何正确超载operator+=.

问题:

1. 如何定义此运算符的签名？特别是,什么应该用于返回值？

2. 如何实现功能体？

3. 如何使用这个重载运算符？

我已经提供了上述解决方案,但我担心这是不正确的.

考虑这个有效的 C++17 示例：

struct A {
   bool operator==(const A&);
};


int main() {
   return A{} == A{};
}

当使用 -std=c++20 在 clang 中编译时，它给出：

struct A {
   bool operator==(const A&);
};


int main() {
   return A{} == A{};
}

这个警告是否意味着 C++20 不允许使用典型的比较运算符来比较两个相同类型的对象？什么是正确的选择？这种情况在未来的选秀中会发生变化吗？

我有一个类型为std :: string的类.我想通过比较属性为类提供一些比较运算符函数,如<,>,==,<=和> =.

我的问题是:任何简单的方法或工具

(1)只写一个或两个函数,例如一个用于运算符<(和==),其他函数可以自动生成.

(2)甚至更简单,因为类比较取决于std::string其比较函数已经提供的类型属性.

脚本

我有一个课我希望能够比较平等.这个类很大(它包含一个位图图像),我会多次比较它,所以为了提高效率,我要对数据进行哈希处理,只检查哈希是否匹配.此外,我将只比较我的对象的一小部分,所以我只是在第一次完成相等性检查时计算哈希值,然后使用存储的值进行后续调用.

例

class Foo
{
public:

   Foo(int data) : fooData(data), notHashed(true) {}

private:

   void calculateHash()
   {
      hash = 0; // Replace with hashing algorithm
      notHashed = false;
   }

   int getHash()
   {
      if (notHashed) calculateHash();
      return hash;
   }

   inline friend bool operator==(Foo& lhs, Foo& rhs)
   {
      if (lhs.getHash() == rhs.getHash())
      {
         return (lhs.fooData == rhs.fooData);
      }
      else return false;
   }

   int fooData;
   int hash;
   bool notHashed;
};

背景

根据这个答案的指导,平等运算符的规范形式是:

inline bool operator==(const X& lhs, const X& rhs);

此外,操作符重载以下一般建议 …

在SQL中有一个类似的功能

SELECT TOP 20 distance FROM dbFile ORDER BY distance ASC

如果我的SQL是正确的,比如10,000条记录,这应该返回我的数据库中的20个最小距离.

我没有数据库.我有一个100,000元素的简单数组.

是否有C++容器,Boost,MFC或STL为结构提供简单的代码

struct closest{
    int    ID;
    double distance;
    closest():ID(-1), distance(std::numeric_limits<double>::max( )){}
};

我可以在哪里建立一个按距离排序的容器

boost::container::XXXX<closest> top(20);

然后有一个简单的

top.replace_if(closest(ID,Distance));

如果容器将使用我的新条目替换当前最高距离的条目,如果它小于我容器中的当前最高距离.

我并不担心速度.我喜欢优雅干净的解决方案,其中容器和代码做所有的繁重.

编辑.收到所有重要答案后的附录.

由于它的优雅,我真的很想找到它.是一个可以使用容器大小限制创建的已排序容器.在我的情况下20.然后我可以推送或插入我心中的内容10万件或更多.但.总有一个但是.如果容器的比较器值不在最低的20个值内,则通过替换或不插入项目,容器将保持最大20的大小.

是.我现在从所有这些答案中知道,通过编程和调整现有容器,可以实现相同的效果.也许当C&C++标准委员会的下一轮建议出现时.我们可以建议.自我分类(我们已经有了)和自我限制容器.

为什么不能使三元运算符超载？:'？

我经常使用三元运算符来合并if语句,并且很好奇为什么语言设计者选择禁止此运算符过载.我找到了解释为什么在C++运算符重载但未找到描述为什么这是不可能的解释.脚注提供的唯一信息是它不能超载.

我最初的猜测是,重载运算符几乎总是违反上面链接中给出的第一或第二原则.重载的含义很少是明显的或明显的,或者它将偏离其原始的已知语义.

所以我的问题更多的是为什么这不可能而不是如何,因为我知道它无法完成.

我有一个枚举类型StackID,我使用枚举来引用特定向量的索引,它使我的代码更容易阅读.

但是,我现在需要创建一个名为nextAvailtype 的变量StackID.(它实际上指的是特定的stackID).我尝试增加它,但在C++中,以下是非法的:

nextAvail++;

哪种对我有意义...因为没有界限检查.

我可能忽略了一些明显的东西,但什么是一个很好的替代品呢？

我也想链接到这个问题.

是否应该在类之外明确定义朋友函数？
如果是这样,为什么我可以像任何成员函数一样在类定义中声明友元函数？
这是什么 ？
是否仅<适用于某些运营商(如运营商)或是否适用于所有运营商？
如果它适用于所有这些,那么这样做是否有任何不利之处？
应该避免吗？如果是这样的话？

class person 
{
public:
    bool operator<(int num)
    {
        return  x < num ? true : false ;
    }
    bool operator<(person& p)
    {
        return  x < p.x ? true : false ;
    }

    friend bool operator<(int num, person &p)
    {
        return  p.x < num ? true : false ;
    }

    void setX(int num)
    {
        x = num;
    }

private:
    int x;


};

更新:
我不是要求选择非成员运算符重载或成员运算符重载.
我想知道的是:
为什么我们被允许在我们的类定义中移动friend方法的定义？.
它不违反任何事情吗？如果不是,为什么我们会在第一时间有朋友？ …

我是编程新手，并且有关于在一行上使用多个运算符的问题。

说，我有

int x = 0;
int y = 1;
int z = 2;

在此示例中，我可以使用分配操作符链： x = y = z;

然而，我怎么就不能使用：x < y < z;？

我不明白为什么在下面的代码中表达式C c3 = 5 + c; 不会被编译,尽管5可以转换为类型C,就像在前面的语句中一样.

#include <iostream>

class C 
{
    int m_value;
public:
    C(int value): m_value(value) {} ;

    int get_value() { return m_value; } ; 

    C operator+(C rhs) { return C(rhs.m_value+m_value); }
};

int main()
{
    C c = 10;
    C c2 = c + 5; // Works fine. 5 is converted to type C and the operator + is called
    C c3 = 5 + c; // Not working: compiler error. Question: Why is 5 not …