标签: binary-operators

根据TryBinaryOperation的文档,当二进制操作的左侧是动态对象时,将调用此方法.

我有一个派生自动态对象的类,我发现并不总是如此.对于这个例子,我希望3次调用我的覆盖TryBinaryOperation但只得到2.

public class MyDynamic : DynamicObject
{
    public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
    {
        Console.WriteLine("operation = " + binder.Operation.ToString());
        result = arg;
        return true;
    }
}

class Program
{
    static void Main(string[] args)
    {           
        dynamic d = new MyDynamic();

        dynamic d1 = d + "add it";
        dynamic d2 = d + 1;
        dynamic d3 = d >> "shift it";

        Console.WriteLine("");

        Console.WriteLine(d1);
        Console.WriteLine(d2);
        Console.WriteLine(d3);
    }
}

然而,第一次调用返回字符串" DynamicRestProxy.UnitTests.MyDynamicadd it"; ie d.ToString() …

我试图使用二元运算符来比较两个值:

character = (xxx as NSString).characterAtIndex(2)
if character == "1" {
    //do this thingy   
}

现在我收到失败消息Binary Operator'=='不能应用于unichar或String类型的操作数.我也试图转换角色:

if String(character) == "1" 

不起作用......

class MyClass 
{
    enum MyEnum {
        case FirstCase
        case SecondCase(Int)
        case ThirdCase
    }

    var state:MyEnum!

    func myMethod ()
    {
        if state! == MyEnum.FirstCase {
            // Do something
        }
    }
}

我得到编译器错误指向if语句::

二进制运算符'=='不能应用于两个'MyClass.MyEnum'操作数

如果相反,我使用一个switch声明,没有问题:

switch state! {
    // Also, why do I need `!` if state is already an 
    // implicitly unwrapped optional? Is it because optionals also 
    // are internally enums, and the compiler gets confused?

case .FirstCase:
    // do something...

default:
    // (do nothing)
    break …

在我编辑的代码中,我以前的程序员使用移位运算符将一个中等大的数字添加到size_t整数.当我使用这个特定的整数进行调试时,我发现更改数字并没有产生可预测的结果.

输入:

std::size_t
    foo1 = 100000 << 20,
    foo2 = 200000 << 20,
    foo3 = 300000 << 20,
    foo4 = 400000 << 20;
std::cout << "foos1-4:";
std::cout << foo1;
std::cout << foo2;
std::cout << foo3;
std::cout << foo4;

收益率:

foos1-4:
1778384896
18446744072971354112
1040187392
18446744072233156608

我知道这是一种溢出错误,但(据我所知,有限的知识)size_t不应该有那些.据我所知,size_t是一个无符号整数类型,它能够保存几乎无限数量的整数.

根据我对位移运算符的理解,此代码应该将数字乘以2 ^ 20(1048576).链接到此站点上的其他页面: 什么是按位移位(位移)运算符以及它们如何工作？

注意 - 我手工制作foo1似乎是一个溢出错误,32位二进制数字截断,但所有其他看起来对我来说完全随机.

来自http://en.cppreference.com/w/cpp/types/size_t:std :: size_t可以存储任何类型(包括数组)理论上可能的对象的最大大小.从那里我假设问题必须在于如何声明整数或如何操作位移.

这是怎么回事？

我有这个var json : [[String : Any]] = [[:]]包含 JSON 响应如下：

{
"id": "1",
"name": "Apple",
"category_name": "Fruits"
},
{
"id": "2",
"name": "Black shirt",
"category_name": "Fashion"
},
{
"id": "3",
"name": "iPad",
"category_name": "Gadgets"
}

我写了一个枚举：

enum : Int {
        case fruits = 0, fashion, gadgets
    }

var data = [Categories: [[String: Any]]]()

然后我有这个方法来对类别进行排序：

func sortData() {
        data[.fruits] = self.json.filter({ $0["category_name"] == "Fruits" })
        data[.fashion] = self.json.filter({ $0["category_name"] == "Fashion" })
        data[.gadgets] = self.json.filter({ $0["category_name"] == "Gadgets" }) …

后缀运算符采用int参数.关于为什么会有一个问题,似乎答案是:" 因为Bjarne Stroustrup这么说 "

我对这个答案感到不舒服.如果Bjarne Stroustrup需要一些东西来解决编译器的行为方式不同,为什么他不能只关闭运算符是否返回引用？它让我质疑:

1. 为什么我不能这样做: foo++ 13;
2. 为什么int参数默认为1
3. 为什么这被认为是一元运算符,需要一个论证

我想创建一个BinaryOperator<BigInteger> biOp以将BigInteger值相加。例如，我将有一个巨大的列表或不同BigInteger值的数组，我想使用循环和biOp.

例如，两个值的结果应该是这样的：

System.out.println(biOp.apply(BigInteger.ONE, BigInteger.ONE));
// outputs 2

如何biOp正确创建或初始化？

我使用三元运算符,但经常想要检查没有else子句的东西.我想知道是否有任何简短的方法可以省略这一点.

我发现了

a ? b : {}

作为替代if (a) {b},可以保存2个字符,但不能

a ? b :

我认为这是有道理的,它是一个三元运算符.

我唯一的想法是那些空的花括号有点难看,有没有其他方法来指定一个空白的:语句？

或者,是否有二元?运算符？我在规范中翻找过,但看不出我是如何使用二进制逻辑运算符的,我猜这if就是为了什么.

有没有办法使用二进制逻辑运算符来表达{}的条件或简写？我知道这可能是3个角色的懒惰高度,但我只是好奇,如果有人有任何技巧可以分享.

我在竞争性编程编辑中找到了 CPP 数组的定义

long long s1[1<<10][1<<10],s2[1<<10][1<<10]

为什么这样写我们可以简单地写成

 s1[1024][1024]

这背后有什么原因吗？