Eşitsizlik neden birçok C ++ standart kütüphane kodunda (! (A == b)) olarak test ediliyor?

Bu, C ++ standart kitaplık removekodundaki koddur. Eşitsizlik neden if (!(*first == val))yerine test ediliyor if (*first != val)?

 template <class ForwardIterator, class T>
      ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
 {
     ForwardIterator result = first;
     while (first!=last) {
         if (!(*first == val)) {
             *result = *first;
             ++result;
         }
         ++first;
     }
     return result;
 }

Çünkü bu T için tek gereksinimin bir operator==. T'ye sahip olmanız gerekebilir, operator!=ancak burada genel fikir, şablonun kullanıcısına mümkün olduğunca az yük bindirmeniz ve diğer şablonların ihtiyaç duymasıdır operator==.

STL'deki çoğu işlev yalnızca operator<veya ile çalışır operator==. Bu, kullanıcının yalnızca bu iki operatörü (veya bazen bunlardan en az birini) uygulamasını gerektirir. Örneğin std::set, siparişleri yönetmek için değil operator<(daha kesin olarak varsayılan olarak std::lessçağıran operator<) kullanır operator>. removeSizin örnekte şablon benzer bir durumdur - bu sadece kullanan operator==değil operator!=bu yüzden operator!=tanımlanması gerekmez.

Bu kod, C ++ standart kitaplığı kaldırma kodudur.

Yanlış. O değil C ++ standart kütüphanesi kodu. Bu var bir olası iç uygulama C ++ standart kütüphane fonksiyonu. C ++ standardı gerçek kodu yazmaz; fonksiyon prototipleri ve gerekli davranışları öngörür.removeremove

Başka bir deyişle: Katı bir dil açısından gördüğünüz kod mevcut değildir . Derleyicinizin standart kitaplık uygulamasıyla birlikte gelen bazı başlık dosyasından olabilir. C ++ standardının bu başlık dosyalarının varlığını bile gerektirmediğini unutmayın . Dosyalar, derleyici uygulayıcılarının bir satırın gereksinimlerini karşılaması için uygun bir yoldur #include <algorithm>(örn. std::removeVe diğer işlevler kullanılabilir).

Eşitsizlik neden if (!(*first == val))yerine test ediliyor if (*first != val)?

Çünkü sadece operator==fonksiyon gerekli.

Özel türler için operatör aşırı yüklenmesi söz konusu olduğunda, dil her türlü garip şeyi yapmanıza izin verir. Aşırı yüklenmiş operator==ancak aşırı yüklü olmayan bir sınıf oluşturabilirsiniz operator!=. Ya da daha da kötüsü: Aşırı yükleyebilirsiniz, operator!=ancak tamamen ilgisiz şeyler yapmasını sağlayabilirsiniz .

Bu örneği düşünün:

#include <algorithm>
#include <vector>

struct Example
{
    int i;

    Example() : i(0) {}

    bool operator==(Example const& other) const
    {
        return i == other.i;
    }

    bool operator!=(Example const& other) const
    {
        return i == 5; // weird, but nothing stops you
                       // from doing so
    }

};

int main()
{
  std::vector<Example> v(10);
  // ...
  auto it = std::remove(v.begin(), v.end(), Example());
  // ...
}

Eğer std::removekullanılan operator!=, sonuç çok farklı olurdu.

Burada bazı iyi cevaplar. Sadece küçük bir not eklemek istedim.

Tüm iyi kütüphaneler gibi, standart kütüphane (en azından) iki çok önemli prensip göz önünde bulundurularak tasarlanmıştır:

1. Kütüphanenizin kullanıcılarına kurtarabileceğiniz en az sorumluluğu koyun. Bunun bir kısmı, arayüzünüzü kullanırken onlara yapılacak en az işi vermekle ilgilidir. (kaçabildiğiniz kadar az operatör tanımlamak gibi). Diğer kısmı, onları şaşırtmamak ya da hata kodlarını kontrol etmelerini istemekle ilgilidir (bu yüzden arayüzleri tutarlı tutun ve <stdexcept>işler yanlış gittiğinde istisnalar atın ).

2. Tüm mantıksal artıklığı ortadan kaldırın . Tüm karşılaştırmalar sadece bundan çıkarılabilir operator<, o zaman neden kullanıcıların başkalarını tanımlamasını talep etmelisiniz? Örneğin:

   (a> b) (b <a) 'ya eşittir

   (a> = b)! (a <b) 'ye eşittir

   (a == b)! ((a <b) || (b <a)) ile eşdeğerdir

   ve bunun gibi.

   Bu not Tabii ki, bir neden sorabiliriz unordered_mapgerektirir operator==ziyade (en azından varsayılan olarak) operator<. Cevap şudur ki, bir karma tabloda şimdiye kadar ihtiyacımız olan tek karşılaştırma eşitlik içindir. Dolayısıyla, bir eşitlik operatörü tanımlamalarını istemek daha mantıklı olarak tutarlıdır (yani kütüphane kullanıcısı için daha mantıklıdır). Birine operator<ihtiyaç duymak kafa karıştırıcı olacaktır, çünkü neden ona ihtiyaç duyacağınız hemen belli olmaz.

EqualityComparableKavram sadece gerektirir operator==tanımlanabilir.

Sonuç olarak, herhangi bir fonksiyon türleri tatmin edici ile çalışma professes bu EqualityComparable olamaz varlığına bağlıdır operator!=bu tür nesneler için. (varlığını ima eden ek gereksinimler yoksa operator!=).

En ümit verici yaklaşım, operatörün == belirli bir tür için çağrılıp çağrılmayacağını belirlemeye yönelik bir yöntem bulmak ve daha sonra yalnızca mevcut olduğunda bunu desteklemek; diğer durumlarda bir istisna atılır. Bununla birlikte, bugüne kadar f == g isteğe bağlı bir operatör ifadesinin uygun bir şekilde tanımlanıp tanımlanmadığını saptamanın bilinen bir yolu yoktur. Bilinen en iyi çözüm aşağıdaki istenmeyen özelliklere sahiptir:

• Operatör == erişilemediği nesneler için derleme zamanında başarısız olur (örn. Özel olduğu için).
• == çağrısı belirsizse derleme zamanında başarısız olur.
• Operatör == derlemesi doğru olmasa bile, operatör == bildirimi doğruysa doğru görünüyor.

Boost SSS'den: kaynak

==Uygulama gerektirmenin bir yük olduğunu bilerek, uygulama gerektirerek asla ek yük oluşturmak istemezsiniz !=.

Şahsen benim için bu, SOLID (nesne yönelimli tasarım) L bölümü - Liskov ikame ilkesi: “bir programdaki nesneler, o programın doğruluğunu değiştirmeden alt türlerinin örnekleriyle değiştirilmelidir.” Bu durumda ben == ve boole mantığında boole tersi ile değiştirebileceğim operatör ! = .