C ++ 'da Çifte Olumsuzluk

Az önce oldukça büyük bir kod tabanı olan bir projeye geldim.

Çoğunlukla C ++ ile uğraşıyorum ve yazdıkları kodun çoğu boole mantığı için çift olumsuzlama kullanıyor.

 if (!!variable && (!!api.lookup("some-string"))) {
       do_some_stuff();
 }                                   

Bu adamların zeki programcılar olduklarını biliyorum, bunu kazara yapmadıkları açık.

Deneyimli bir C ++ uzmanı değilim, bunu neden yaptıklarına dair tek tahminim, değerlendirilen değerin gerçek boole temsili olduğu konusunda kesinlikle pozitif yapmak istedikleridir. Böylece, onu olumsuzlarlar, sonra onu gerçek boole değerine geri döndürmek için tekrar reddederler.

Bu doğru mu yoksa bir şey mi kaçırıyorum?

Bool'a dönüştürmek için bir numara.

Aslında bazı bağlamlarda çok kullanışlı bir deyim. Bu makroları alın (örneğin Linux çekirdeğinden). GCC için aşağıdaki şekilde uygulanırlar:

#define likely(cond)   (__builtin_expect(!!(cond), 1))
#define unlikely(cond) (__builtin_expect(!!(cond), 0))

Bunu neden yapmak zorundalar? GCC __builtin_expect, parametrelerini kabul eder longve etmez bool, bu nedenle bir tür dönüşüm olması gerekir. condBu makroları yazarken ne olduğunu bilmedikleri için, en genel olarak !!deyimi kullanmak basittir .

Muhtemelen 0 ile karşılaştırarak aynı şeyi yapabilirler, ancak bana göre, C'nin sahip olduğu bir bool'a en yakın olanı bu olduğundan, çifte olumsuzlamayı yapmak aslında daha basittir.

Bu kod C ++ 'da da kullanılabilir ... en düşük ortak payda bir şeydir. Mümkünse, hem C hem de C ++ 'da işe yarayan şeyi yapın.

Kodlayıcılar, işleneni bool'a dönüştürebileceğini düşünüyorlar, ancak && işlenenleri zaten dolaylı olarak bool'a dönüştürüldüğünden, tamamen gereksizdir.

Yazmaktan kaçınmak için bir tekniktir (değişken! = 0) - yani, hangi türden olursa olsun bir bool'a dönüştürmek.

Bunun gibi IMO Kodunun bakımı gereken sistemlerde yeri yoktur - çünkü hemen okunabilir bir kod değildir (bu nedenle ilk etapta soru).

Kod okunaklı olmalıdır - aksi takdirde gelecek için bir zaman borcu mirası bırakırsınız - çünkü gereksiz yere kıvrılan bir şeyi anlamak zaman alır.

Evet doğru ve hayır bir şeyi kaçırmıyorsun. !!bool'a bir dönüşümdür. Daha fazla tartışma için bu soruya bakın .

Bir derleyici uyarısına yandan adım atar. Bunu dene:

int _tmain(int argc, _TCHAR* argv[])
{
    int foo = 5;
    bool bar = foo;
    bool baz = !!foo;
    return 0;
}

"Bar" satırı, MSVC ++ üzerinde "doğru" ya da "yanlış" (performans uyarısı) bool yapmaya zorlayan bir değer "üretir, ancak" baz "satırı, cezadan gizlice geçer.

Operatördür! aşırı?
Değilse, muhtemelen bunu bir uyarı üretmeden değişkeni bir bool'a dönüştürmek için yapıyorlar. Bu kesinlikle bir şeyler yapmanın standart bir yolu değil.

Legacy C geliştiriciler genellikle bu yüzden, hiçbir Boole türü vardı #define TRUE 1ve #define FALSE 0ardından Boole karşılaştırmaları için keyfi sayısal veri türleri kullanılır. Artık sahip olduğumuza göre bool, birçok derleyici, sayısal türlerin ve Boolean türlerinin bir karışımı kullanılarak belirli türdeki atamalar ve karşılaştırmalar yapıldığında uyarılar yayınlayacaktır. Bu iki kullanım, eski kodla çalışırken sonunda çakışacaktır.

Bu soruna geçici bir çözüm bulmak için, bazı geliştiriciler aşağıdaki Boole kimliğini kullanır: eğer !num_valuedöndürür ; aksi takdirde. eğer döndürür ; aksi takdirde. Tek olumsuzlama, dönüştürmek için yeterlidir ; ancak, Boole ifadesinin orijinal anlamını geri yüklemek için çifte olumsuzlama gereklidir.bool truenum_value == 0false!!num_valuebool falsenum_value == 0truenum_valuebool

Bu kalıp deyim olarak bilinir , yani dile aşina olan insanlar tarafından yaygın olarak kullanılan bir şeydir. Bu nedenle, bunu benim kadar bir anti-model olarak görmüyorum static_cast<bool>(num_value). Oyuncu kadrosu çok iyi sonuçları verebilir, ancak bazı derleyiciler daha sonra bir performans uyarısı verir, bu nedenle yine de bunu ele almanız gerekir.

Bunu ele almanın diğer yolu, şunu söylemektir (num_value != FALSE). Bunda da sorun yok, ama sonuçta !!num_valueçok daha az ayrıntılı, daha net olabilir ve ikinci kez gördüğünüzde kafa karıştırıcı değil.

!! boole tipine sahip olmayan orijinal C ++ ile başa çıkmak için kullanıldı (C'nin de yapmadığı gibi).

Örnek Problem:

İçeride if(condition), vb. conditionGibi bir tür için değerlendirme ihtiyacı var double, int, void*, ancak boolhenüz mevcut olmadığı gibi değil.

Bir sınıfın var olduğunu int256(256 bitlik bir tamsayı) ve tüm tamsayı dönüşümlerinin / yayınlarının aşırı yüklendiğini varsayalım.

int256 x = foo();
if (x) ...

x"Doğru" olup olmadığını veya sıfır olmadığını test etmek için, bir tam sayıya if (x)dönüştürülür xve ardından bunun intsıfır olmadığı değerlendirilir . Tipik bir aşırı yük, (int) xyalnızca x. if (x)o zaman sadece LSbitlerini test ediyordu x.

Ancak C ++ 'ın !operatörü vardır. Aşırı yüklenme !x, tipik olarak tüm bitlerini değerlendirir x. Yani tersine çevrilmemiş mantığa geri dönmek için if (!!x)kullanılır.

Ref C ++ 'nın eski sürümleri, bir "if ()" ifadesindeki koşulu değerlendirirken bir sınıfın "int" operatörünü kullanıyor muydu?

As Marcin söz operatör yükleme oyunda ise, iyi bir önemi olabilir. Aksi takdirde, C / C ++ 'da aşağıdakilerden birini yapıp yapmamanız dışında önemli değildir:

• doğrudan karşılaştırma true(veya C'de TRUEmakro gibi bir şey ), ki bu neredeyse her zaman kötü bir fikirdir. Örneğin:

  if (api.lookup("some-string") == true) {...}

• bir şeyin katı bir 0/1 değerine dönüştürülmesini istiyorsunuz. C ++ 'da a'ya bir atama boolbunu örtük olarak yapar (örtük olarak dönüştürülebilen şeyler için bool). C'de veya bool olmayan bir değişkenle uğraşıyorsanız, bu gördüğüm bir deyim, ancak ben (some_variable != 0)çeşitliliği tercih ederim .

Bence daha büyük bir mantıksal ifade bağlamında, sadece işleri karıştırıyor.

Eğer değişken bir nesne türünden olup, bir olabilir! işleç tanımlı, ancak bool'a dönüştürme yok (veya daha kötüsü, farklı anlambilimlere sahip int'e örtük bir dönüştürme.! operatörünü iki kez çağırmak, garip durumlarda bile çalışan bir bool'a dönüştürmeyle sonuçlanır.

Bu doğru ama, burada anlamsız - 'eğer' ve '&&' ifadeye '!!' olmadan aynı şekilde davranır.

Bunu C ++ 'da yapmanın nedeni, sanırım,' && 'aşırı yüklenmiş olabilir. Ama sonra, bu yüzden olabilir '!', Değil bu yüzden gerçekten sen türleri için kod bakmadan, bir bool olsun garanti variableve api.call. Belki daha fazla C ++ deneyimi olan biri açıklayabilir; Belki de bu, bir garanti değil, derinlemesine savunma amaçlı bir önlemdir.

Belki programcılar böyle bir şey düşünüyorlardı ...

!! myAnswer boole'dir. Bağlam olarak, boolean olmalı, ama emin olmak için bir şeyleri patlatmayı seviyorum, çünkü bir zamanlar beni ısırtan gizemli bir böcek vardı ve patlama bang, onu öldürdüm.

Bu, çifte patlama numarasına bir örnek olabilir , daha fazla ayrıntı için Güvenli Bool Deyimi'ne bakın. Burada makalenin ilk sayfasını özetliyorum.

C ++ 'da, sınıflar için Boolean testleri sağlamanın birkaç yolu vardır.

Açık bir yol, operator booldönüştürme operatörüdür.

// operator bool version
  class Testable {
    bool ok_;
  public:
    explicit Testable(bool b=true):ok_(b) {}

    operator bool() const { // use bool conversion operator
      return ok_;
    }
  };

Sınıfı test edebiliriz,

Testable test;
  if (test) 
    std::cout << "Yes, test is working!\n";
  else 
    std::cout << "No, test is not working!\n";

Ancak, veya opereator boolgibi anlamsız işlemlere izin verdiği için güvensiz olarak kabul edilir .test << 1;int i=test

operator!Örtülü dönüştürme veya aşırı yükleme sorunlarından kaçındığımız için kullanmak daha güvenlidir.

Uygulama önemsizdir,

bool operator!() const { // use operator!
    return !ok_;
  }

TestableNesneyi test etmenin iki deyimsel yolu

  Testable test;
  if (!!test) 
    std::cout << "Yes, test is working!\n";
  if (!test2) {
    std::cout << "No, test2 is not working!\n";

İlk versiyon if (!!test), bazılarının çift ​​patlama numarası olarak adlandırdığı şeydir .