标签: operator-keyword

在IsVB.NET关键字一样Object.ReferenceEquals？

我搜索了如何在互联网上正确实现+运算符,我找到的所有结果都执行以下步骤:

const MyClass MyClass::operator+(const MyClass &other) const
{
    MyClass result = *this;  // Make a copy of myself. Same as MyClass result(*this);
    result += other;         // Use += to add other to the copy.
    return result;           // All done!
}

关于这个"过程"我几乎没有问题:

1. 以这种方式实现+运算符不是那么愚蠢,它在第一行调用赋值运算符(复制类),然后在返回中调用复制构造函数(由于返回的事实,它也复制了类)按价值,所以它破坏了第一个副本并创建了一个新的......坦白说,这并不是很聪明......)

2. 当我写a = b + c时,b + c部分创建该类的新副本,然后'a ='部分将副本复制给自己.谁删除了b + c创建的副本？

3. 有没有更好的方法来实现+运算符而不需要两次处理类,也没有任何内存问题？

提前致谢

我不知道这个问题是否已在stackoverflow上得到解答.但我找不到正确的搜索关键字.

我在下面插入了一些我的代码的精简版本.

基本上我在main()中尝试做的是从t2中减去122.我想我的编译器会自动将整数转换为Timestamp对象,然后按照'Timestamp.cpp'中的显示减去它.

但是当它到达t4时它没有转换它并给我以下错误:

'722 - t1'中'operator-'不匹配

我百分百肯定它是可能的.但是怎么样？

也许我对转换完全错了......所以请不要犹豫,纠正我,我正在努力学习一些东西.

剥掉的代码:

main.cpp中:

#include <iostream>
#include <iomanip>

#include "Timestamp.h"

using namespace std;

int main() {
    Timestamp t3(t2 - 122);
    cout << "T3 = " << t3 << endl;
    Timestamp t4(722 - t1);
    cout << "T4 = " << t4 << endl;

    return 0;
}

Timestamp.h

#ifndef TIJDSDUUR_H
#define TIJDSDUUR_H

using namespace std;

class Timestamp {
    public:
        Timestamp(int);
        Timestamp operator- (const Timestamp &t);
    private:
        int hour;
        int min;
};

Timestamp.cpp

Timestamp::Timestamp(int m) : …

类似于是否可以在c#中创建一个新的运算符？,是否可以为Java创建自己的运算符？我最初会说不,因为你不能重载,但是再一次,String支持+和+ =(在执行时隐式地通过StringBuilder等).

我需要在C中计算数字的日志基数2,但我不能使用数学库.答案不需要精确,只需要最接近的int.我已经考虑过了,我知道我可以使用while循环并继续将数字除以2,直到它<2,并保持迭代次数,但这是否可以使用按位运算符？

我遇到了一个我无法自己回答的问题.此外,我没有在谷歌和这里找到答案.比如,我想在if子句中"检查对象的有效性",如下所示:

MyClass myObject;

// [some code, if any]

if (!myObject)
{
    // [do something]
}

我们MyClass这样定义:

class MyClass
{
public:
    MyClass() { };
    virtual ~MyClass() { };
    bool operator!()
    {
        return !myBool;
    };
    operator bool()
    {
        return myBool;
    };
private:
    bool myBool = 0;
};

我现在的问题是:在这个if子句中实际使用了哪一个重载运算符？无论哪种方式,结果显然都是一样的.

编辑:此问题已过期,因为Polyfill示例已更新.我在这里留下这个问题仅供参考.阅读关于按位移位运算符的有用信息的正确答案.

题:

在Mozilla Array.prototype.indexOf页面的Polyfill示例中的第7行,他们对此进行评论:

var length = this.length >>> 0; // Hack to convert object.length to a UInt32

但Mozilla上的按位移位规范明确指出运算符返回与左操作数相同类型的值:

移位运算符将其操作数转换为32位整数,并返回与左操作数相同类型的结果.

所以不应该长度接收标准的64位浮点值？或者有人能指出黑客入手的地方？

我目前正在设计和实现一种小型编程语言作为我正在上课的额外学分项目.我的问题是该语言有三种数字类型:Long,Double和Fraction.分数可以用适当或不正确的分数(例如"2 1/3"或"1/2")用语言书写.这个事实导致诸如"2/3.5"(长/双)和"2/3"(长/长)等问题无法被词法分析器正确处理.我看到的最佳解决方案是更改除法运算符.到目前为止,我认为"\"是最好的解决方案,因为"//"开始评论.

如果你正在设计语言,你会选择"\"吗？

你会选择其他东西吗？如果是这样,什么？

注意:无法更改分数的分配方式.

在此先感谢您的帮助,

-编辑-

目前的运营商是:

** (功率)

* (乘)

% (模数)

+ (加)

- (减去和否定)

~ (倒数)

! (不)

> (更大)的

< (减)

>= (大于相等)

<= (较少-相等)

== (平等)

<> (不等式)

& (和)

| (要么)

^ (XOR)

?? (空coalesing)

= (分配)

注意:我的老师没有严格的约束要求; 但是,我基本上让他相信我可以将一个简单的分数计算器变成一种语言.更改分数的语法将违反分数计算器的分数语法,最好避免使用.

我决定在我的类中重载new,new [],...运算符,这样我就可以记录它们被调用的文件和行,这样我就可以更轻松地跟踪内存分配/泄漏.

现在问题出在我的堆栈和数组类(以及其他分配内存的模板容器类)中:

如果我将它们与我的一个具有new,new [],...运算符的类一起使用它可以正常工作.

但是如果我将它与标准的c ++数据类型(int,float,...)一起使用,我就无法分配它们,因为没有重载的new运算符匹配new(__ LINE __,__ FILE __)运算符的参数(或者其他人喜欢安置新的).

堆栈代码示例:

// placement new
T* t=new(__ LINE __ , __ FILE__)(&m_data[i])T;

所以我对如何使这项工作有好主意.如果我用新的松散内存记录功能替换new(__ LINE __,__ FILE __).一种解决方案是为标准数据类型创建一个分离的堆栈,其中使用默认的new.

有没有办法在编译时检测模板参数是结构,类还是内置的c ++类型？

你怎么处理这样的东西？你有什么建议？任何关于这种设计的评论(好的,坏的)显然都是受欢迎的(只是不要张贴诸如"不要用自己的容器重新发明轮子"之类的东西).

我正在尝试实现自己的布尔类,但不能复制&&的本机语义.以下设计的代码演示了这个问题:

    #include <iostream>>

    class MyBool {
    public:
        bool theValue;
        MyBool() {}
        MyBool(bool aBool) {theValue = aBool;}
        MyBool operator&& (MyBool aBool) {return theValue && aBool.theValue;}
    };

    bool f1() {std::cout << "   First\n"; return false;}
    bool f2() {std::cout << "   Second\n"; return false;}

    int main(int argc, char** argv) {
        std::cout << "Native &&\n";
        f1() && f2();
        std::cout << "Overloaded &&\n";
        MyBool(f1()) && MyBool(f2());
        return 0;
}

编译和运行时,结果是:

    Native &&
       First
    Overloaded &&
       Second
       First

换句话说,&& on bools是懒惰的(正如任何C++程序员所期望的那样)但是重载的&&不是(正如这个C++程序员至少没想到的那样).

有没有办法让重载&&懒惰？我可以找到各种全面的延迟评估方案来提供类似Haskell的功能,但它们看起来像我的用例完全矫枉过正.