Herhangi bir dilde tek yönlü bir boole değiştirme operatörü var mı?

Bu daha çok teorik bir soru. C ++ ve diller (in) doğrudan buna dayalı olarak (Java, C #, PHP) çoğu ikili işleçin sonucunu ilk işlenene atamak için kısayol işleçlerine sahiptir .

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

ama boole ifadesini değiştirmek istediğimde kendimi hep böyle bir şey yazarken bulurum

a = !a;

Bu auzun bir ifade gibi olduğunda sinir bozucu olur .

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

(evet, Demeter Yasası, biliyorum).

Merak ediyordum, tekdüze bir boole geçiş operatörüne sahip , örneğin a = !aifadeyi tekrar etmeden kısaltmamı sağlayacak herhangi bir dil var mı?a

!=a;  
// or
a!!;

Diyelim ki dilimizin uygun bir boole türü var ( boolC ++ gibi ) ve abu türden (yani C stili yok int a = TRUE).

Belgelendirilmiş bir kaynak bulabilirseniz, örneğin C ++ tasarımcılarının boolyerleşik bir tür haline geldiğinde böyle bir operatör eklemeyi düşünüp düşünmediğini ve neden öyleyse buna karşı karar verdiklerini öğrenmek isterim .

(Not: Bazı insanlar atama kullanmaması gerektiğini görüşünde olduğunu biliyoruz =ve o ++ve +=kullanışlı operatörler ama dizayn hataları değildir; let sadece onlar bool değerlerden oluşan kapsamaz neden onlarla ve odak mutluyum varsayalım ediyor).

Bu soru gerçekten de tamamen teorik açıdan ilginç. Tek , mutasyona uğrayan bir boole geçiş operatörünün yararlı olup olmayacağını veya birçok dilin neden bir dil sağlamayı seçmediğini bir kenara bırakarak , gerçekten var olup olmadığını görmek için bir arayışa girdim.

TL; DR görünüşe göre hayır, ama Swift bir tane uygulamanızı sağlar. Sadece nasıl yapıldığını görmek istiyorsanız, bu cevabın en altına gidebilirsiniz.

Çeşitli dillerin özelliklerine (hızlı) bir arama yaptıktan sonra, hiçbir dilin bu operatörü katı bir mutasyona uğrayan yerinde işlem olarak uygulamadığını söylemek güvenli olur (bulursanız beni düzeltin). Bir sonraki şey, bir tane oluşturmanıza izin veren diller olup olmadığını görmek olacaktır. Bunun için iki şey gerekir:

1. işleve sahip (tekli) operatörleri uygulayabilme
2. adı geçen işlevlerin referansla bağımsız değişkenlere sahip olmasına izin vermek (böylece bağımsız değişkenlerini doğrudan değiştirebilmeleri için)

Birçok dil, bu gereksinimlerin herhangi birini veya her ikisini de desteklemediği için derhal reddedilecektir. Birincisi için Java , operatörün aşırı yüklenmesine (veya özel işleçlere) izin vermez ve ek olarak, tüm ilkel türler değere göre geçirilir. Go'nun operatör aşırı yüklemesi (bilgisayar korsanları hariç ) için desteği yoktur. Pas yalnızca özel tipler için operatörün aşırı yüklenmesine izin verir. Bunu , çok yaratıcı bir şekilde adlandırılmış işlevleri kullanmanıza ve parantezleri atlamanıza izin veren Scala'da neredeyse başarabilirsiniz , ancak ne yazık ki doğrudan referans yok. Fortran o özel operatörler için izin verdiğini çok yakın alır, ama özellikle sahip olmaktan onları yasaklar inout parametreleri (normal fonksiyonlarda ve altyordamlarda izin verilir).

Ancak, gerekli tüm kutuları işaretleyen en az bir dil var: Swift . Bazı insanlar yaklaşan bağlı olsa da .toggle () üye fonksiyonu, aynı zamanda gerçekten destekleyen kendi operatörü, yazabilir inout argümanlar. Bakın ve görün:

prefix operator ^

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

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Boole bitini değiştirme

... bu a = !a ifadeyi tekrar etmedena kısaltmamı sağlayacaktı ...

Bu yaklaşım gerçekten saf bir "mutasyona uğrayan flip" operatörü değildir, ancak yukarıdaki kriterlerinizi karşılar; ifadenin sağ tarafı değişkenin kendisini içermez.

Bir boolean XOR atama (örn sahip herhangi bir dil ^=) bir değişken, diyelim mevcut değerini saygısız sağlayacak aXOR ataması vasıtasıyla, true:

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

Aşağıdaki yorumlarda @cmaster tarafından belirtildiği gibi, yukarıdaki varsayım atürdür boolve örneğin bir tamsayı veya bir işaretçi değildir. Eğer agerçekte (non örn şey başka bir şeydir booldeğil biraz gösterimi ile bir "truthy" veya "falsy" değerine değerlendiren, 0b1ya 0b0sırasıyla), yukarıda tutmaz.

Somut bir örnek olarak, Java bunun iyi tanımlandığı ve sessiz dönüşümlere tabi olmadığı bir dildir. Aşağıdan @ Boann'ın yorumundan alıntı:

Java'da, ^ve ^=açıkça boolelerde için ve tamsayılar için davranışını tanımladık ( 15.22.2. Boolean Mantıksal Operatörleri &, ^ve| ), operatörün her iki taraf ya mantıksal ifadenin olması gereken ya da her iki taraf tamsayı olmalıdır. Bu türler arasında sessiz bir dönüşüm yoktur. Bu nedenle a, bir tamsayı olarak bildirilirse sessizce arızalanmayacak , daha ziyade bir derleme hatası verecektir. Yani a ^= true;güvenli ve Java iyi tanımlanmış olduğunu.

Swift: toggle()

Swift 4.2 itibariyle, aşağıdaki evrim teklifi kabul edilmiş ve uygulanmıştır:

• SE-0199: Boole geçiş yapma

Bu , Swift'teki türe yerel bir toggle()işlev ekler Bool.

toggle()

Boolean değişkeninin değerini değiştirir.

deklarasyon

mutating func toggle()

Tartışma

Bir Boolean değeri geçiş yapmak için bu yöntemi kullanın trueiçin falseya gelen falseetmek true.

var bools = [true, false]

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

Bu, kendi başına bir operatör değildir, ancak boole geçişi için yerel bir dil yaklaşımına izin verir.

C ++ 'da, Kardinal Günah'ın operatörlerin anlamını yeniden tanımlamasını taahhüt etmek mümkündür. Bunu göz önünde bulundurarak ve biraz ADL ile, kullanıcı tabanımızda kargaşayı serbest bırakmak için tek yapmamız gereken şey şudur:

#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;
}

beklenen çıktı:

6
0
1
0
1

Montaj dilini içerdiğimiz sürece ...

ORTAYA

INVERT bitsel bir tamamlayıcı için.

0= mantıklı (doğru / yanlış) bir tamamlayıcı için.

Bir C99 eksiltim boolarttırılması veya eksiltim irade olarak, istenilen etkiye sahip olacaktır bit(bazı küçük-mikrodenetleyici lehçelerde desteklenen türlerini hangi ı gözlenen tedavi bitlerini ettik neyi gibi tek bit çift numaralar 0 ve tüm kesilmiş olsun, böylece geniş bitfields 1'e tek sayılar). Bu tür bir kullanımı özellikle tavsiye etmem, çünkü booltip semantiğinin büyük bir hayranı değilim [IMHO, tip bool0 veya 1 dışında herhangi bir değerin saklandığı bir a'nın sanki okunduğunda davranabileceğini belirtmiş olmalı belirtilmemiş (zorunlu olarak tutarlı olmayan) bir tamsayı değeri taşır; bir program 0 veya 1 olarak bilinmeyen bir tamsayı değerini saklamaya çalışıyorsa, önce onu kullanmalıdır !!].

Montaj dili

NOT eax

Bkz. Https://www.tutorialspoint.com/assembly_programming/assembly_logical_instructions.htm

Ben sadece bu dayalı bir dil seçmeyeceğim varsayıyorum :-) Her durumda, böyle bir şey ile C ++ yapabilirsiniz:

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

Örneğin aşağıdaki tam programa bakın:

#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);
}

Bu çıktı, beklendiği gibi:

false
true
false

Forth gibi birleştirici , yığın odaklı bir dil olan PostScript , tek bir geçişe sahiptir, değil . Olup operatör yığınının üstünde değerini değiştirir. Örneğin,

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

Bkz. PostScript Dil Referans Kılavuzu (pdf) , s. 458.

Visual Basic.Net bunu bir uzantı yöntemi ile destekler.

Uzantı yöntemini şu şekilde tanımlayın:

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

Ve sonra şöyle deyin:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Yani, orijinal örneğiniz şöyle görünecektir:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

Rust'ta, özelliği uygulayan türleri genişletmek için kendi özelliğinizi oluşturabilirsiniz 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);
}

Ayrıca ^= trueönerildiği gibi kullanabilirsiniz ve Rust durumunda, falseC veya C ++ gibi "gizlenmiş" bir tamsayı olmadığı için bunu yapmak mümkün değildir:

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

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

Python bölgesinde

Python, değişkenin operatörle bool türüne (Doğru veya Yanlış) sahip olması durumunda bu işlevselliği destekler exclusive or (^=):

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

C # dilinde :

boolean.variable.down.here ^= true;

Boolean ^ işleci XOR'dir ve true ile XORing, ters çevirme ile aynıdır.