是否有任何语言具有一元布尔切换运算符？

因此，这更多是一个理论问题。C ++和直接基于它的语言（Java，C＃，PHP）具有快捷方式运算符，用于将大多数二进制运算符的结果分配给第一个操作数，例如

a += 3;   // for a = a + 3
a *= 3;   // for a = a * 3;
a <<= 3;  // for a = a << 3;

但是当我想切换一个布尔表达式时，我总是发现自己在写类似

a = !a;

当a一个长表达式像时，这会很烦人。

this.dataSource.trackedObject.currentValue.booleanFlag =
    !this.dataSource.trackedObject.currentValue.booleanFlag;

（是的，我知道得墨meter耳定律）。

所以我想知道，有没有用一元布尔切换操作员的语言，让我来简化a = !a而不需要重复表达的a，例如

!=a;  
// or
a!!;

假设我们的语言具有适当的布尔类型（如boolC ++），a并且具有该类型（因此没有C样式int a = TRUE）。

如果您可以找到记录在案的资源，我也很想了解例如C ++设计人员是否在考虑bool成为内置类型时是否考虑过添加这样的运算符，如果是，为什么他们反对这样做。

（注意：我知道有些人认为不应使用赋值 =，++并且+=它不是有用的运算符，而是设计缺陷；让我们假设我对它们感到满意，并专注于为什么它们不会扩展到布尔值）。

从纯粹的理论角度来看，这个问题确实很有趣。抛开一元，可变的布尔型触发器运算符是否有用，或者为什么许多语言选择不提供一种，我冒险探索它是否确实存在。

TL; DR显然没有，但是Swift允许您实现一个。如果您只想看看它是如何完成的，则可以滚动到此答案的底部。

在对各种语言的功能进行（快速）搜索之后，我可以肯定地说没有一种语言将此操作符实现为严格的变异就地操作（如果找到一种，请进行纠正）。因此，接下来的事情就是看看是否有可以让您构建语言的语言。这将需要两件事：

1. 能够实现具有功能的（一元）运算符
2. 允许所述函数具有按引用传递的参数（以便它们可以直接更改其参数）

由于不支持这两种要求之一或全部，许多语言将立即被排除在外。Java for One不允许运算符重载（或自定义运算符），此外，所有原始类型均按值传递。Go完全不支持操作员重载（黑客除外）。Rust只允许运算符重载自定义类型。您几乎可以在Scala中实现这一点，它使您可以使用非常有创意的命名函数，并且也可以省略括号，但是遗憾的是没有通过引用。Fortran非常接近，因为它允许自定义运算符，但特别禁止他们使用inout 参数（正常功能和子例程中允许使用）。

但是，至少有一种语言在所有必要的方框中打勾：Swift。虽然有些人已链接到即将发布的.toggle（）成员函数，但您也可以编写自己的运算符，该运算符确实支持inout参数。瞧瞧：

prefix operator ^

prefix func ^ (b: inout Bool) {
    b = !b
}

var foo = true
print(foo)
// true

^foo

print(foo)
// false

切换布尔位

...这将使我a = !a 无需重复a ... 的表达

这种方法并不是真正的“变异翻转”运算符，但确实满足您的上述条件；表达式的右侧不涉及变量本身。

任何具有布尔XOR赋值的语言（例如^=）都可以a通过XOR赋值将变量的当前值翻转，例如true：

// type of a is bool
a ^= true;  // if a was false, it is now true,
            // if a was true, it is now false

正如@cmaster在下面的注释中指出的那样，以上假设a是类型bool，而不是例如整数或指针。如果a实际上还有其他东西（例如，某些东西未bool对“真值”或“虚假”值进行评估，并且用位表示形式分别不是0b1或0b0），则以上内容不成立。

举一个具体的例子，Java是一种语言，定义明确且不受任何静默转换的影响。从下面引用@Boann的评论：

在Java中，^并^=已明确定义行为布尔和整数（15.22.2。布尔逻辑运算符&，^和|），其中无论是运营商的双方必须是布尔值，或双方必须是整数。这些类型之间没有静默转换。因此，如果a将其声明为整数，则不会产生静默故障，而是会给出编译错误。因此a ^= true;在Java中安全且定义明确。

迅速： toggle()

从Swift 4.2开始，以下改进方案已被接受并实施：

• SE-0199：向Bool添加切换

这toggle()为BoolSwift中的类型添加了本机函数。

toggle()

切换布尔变量的值。

宣言

mutating func toggle()

讨论区

使用此方法可将布尔值从切换true到false或从切换false到true。

var bools = [true, false]

bools[0].toggle() // bools == [false, false]

本身不是运算符，但确实允许使用语言本机方法进行布尔切换。

在C ++中，可能会犯下重新定义运算符含义的基本原则。考虑到这一点，再加上一点ADL，我们需要做的就是在用户群中释放混乱：

#include <iostream>

namespace notstd
{
    // define a flag type
    struct invert_flag {    };

    // make it available in all translation units at zero cost
    static constexpr auto invert = invert_flag{};

    // for any T, (T << invert) ~= (T = !T)    
    template<class T>
    constexpr T& operator<<(T& x, invert_flag)
    {
        x = !x;
        return x;
    }
}

int main()
{
    // unleash Hell
    using notstd::invert;

    int a = 6;
    std::cout << a << std::endl;

    // let confusion reign amongst our hapless maintainers    
    a << invert;
    std::cout << a << std::endl;

    a << invert;
    std::cout << a << std::endl;

    auto b = false;
    std::cout << b << std::endl;

    b << invert;
    std::cout << b << std::endl;
}

预期输出：

6
0
1
0
1

只要我们包含汇编语言...

向前

INVERT 进行逐位补码。

0= 用于逻辑（对/错）补码。

递减C99 bool会达到预期的效果，递增或递减bit某些微型微控制器方言支持的类型（根据我的观察，将位视为单个位宽的位域，因此所有偶数都将被截断为0，而所有奇数为1）。我不会特别推荐这种用法，部分原因是我不喜欢bool类型语义[IMHO，该类型应已指定a bool，除读取0或1之外的任何值时，其a 都可能在读取时表现为它持有一个未指定（不一定一致）的整数值；如果程序正在尝试存储一个未知的0或1的整数值，则应!!首先在其上使用]。

汇编语言

NOT eax

参见https://www.tutorialspoint.com/assembly_programming/assembly_logical_instructions.htm

我假设您不会仅基于此来选择一种语言:-)在任何情况下，您都可以在C ++中执行以下操作：

inline void makenot(bool &b) { b = !b; }

例如，请参见以下完整程序：

#include <iostream>

inline void makenot(bool &b) { b = !b; }

inline void outBool(bool b) { std::cout << (b ? "true" : "false") << '\n'; }

int main() {
    bool this_dataSource_trackedObject_currentValue_booleanFlag = false;
    outBool(this_dataSource_trackedObject_currentValue_booleanFlag);

    makenot(this_dataSource_trackedObject_currentValue_booleanFlag);
    outBool(this_dataSource_trackedObject_currentValue_booleanFlag);

    makenot(this_dataSource_trackedObject_currentValue_booleanFlag);
    outBool(this_dataSource_trackedObject_currentValue_booleanFlag);
}

预期输出：

false
true
false

PostScript是像Forth这样的连接性，面向堆栈的语言，具有一元切换，而不是。在不操作切换堆栈顶部的值。例如，

true    % push true onto the stack
not     % invert the top of stack
        % the top of stack is now false

请参见第1页的《PostScript语言参考手册》（pdf）。458。

Visual Basic.Net通过扩展方法支持此功能。

定义扩展方法，如下所示：

<Extension>
Public Sub Flip(ByRef someBool As Boolean)
    someBool = Not someBool
End Sub

然后这样称呼它：

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

因此，您的原始示例如下所示：

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

在Rust中，您可以创建自己的特征以扩展实现Not特征的类型：

use std::ops::Not;
use std::mem::replace;

trait Flip {
    fn flip(&mut self);
}

impl<T> Flip for T
where
    T: Not<Output = T> + Default,
{
    fn flip(&mut self) {
        *self = replace(self, Default::default()).not();
    }
}

#[test]
fn it_works() {
    let mut b = true;
    b.flip();

    assert_eq!(b, false);
}

您也可以^= true按照建议的方式使用，在Rust的情况下，这样做false是不可能的，因为它不是像C或C ++中那样的“伪装”整数：

fn main() {
    let mut b = true;
    b ^= true;
    assert_eq!(b, false);

    let mut b = false;
    b ^= true;
    assert_eq!(b, true);
}

在Python中

如果变量具有运算符的布尔类型（True或False），则Python支持此类功能exclusive or (^=)：

a = False
a ^= True
print(a)  # --> True
a ^= True
print(a)  # --> False

在C＃中：

boolean.variable.down.here ^= true;

布尔^运算符是XOR，与true的XORing与取反相同。