C ++ derleyicileri neden işleç == ve işleç! = Tanımlamıyor?

Derleyicinin sizin için olabildiğince fazla çalışmasına izin verme büyük bir hayranıyım. Basit bir sınıf yazarken derleyici size 'ücretsiz' için aşağıdakileri verebilir:

• Varsayılan (boş) bir yapıcı
• Bir kopya oluşturucu
• Bir yıkıcı
• Bir atama operatörü ( operator=)

Ancak size herhangi bir karşılaştırma operatörü veremiyor gibi görünüyor - operator==veya operator!=. Örneğin:

class foo
{
public:
    std::string str_;
    int n_;
};

foo f1;        // Works
foo f2(f1);    // Works
foo f3;
f3 = f2;       // Works

if (f3 == f2)  // Fails
{ }

if (f3 != f2)  // Fails
{ }

Bunun için iyi bir neden var mı? Neden bir üye-üye karşılaştırması yapmak sorun olur? Eğer sınıf hafızayı ayırırsa, o zaman dikkatli olmak istersiniz, ancak basit bir sınıf için derleyici bunu sizin için yapabilir mi?

Derleyici bir işaretçi karşılaştırması mı yoksa derin (iç) bir karşılaştırma mı istediğinizi bilemez.

Uygulamamak ve programcının bunu kendileri yapmasına izin vermek daha güvenlidir. Sonra istedikleri tüm varsayımları yapabilirler.

Derleyici varsayılan bir kopya oluşturucu sağlayabilirse, benzer bir varsayılan değer sağlayabilmesi argümanı operator==()belirli bir miktar mantıklıdır. Bu operatör için derleyici tarafından oluşturulan bir varsayılan sağlama kararının sebebinin Stroustrup'un "C ++ Tasarım ve Evrimi" nde varsayılan kopya yapıcı hakkında söyledikleriyle tahmin edilebileceğini düşünüyorum (Bölüm 11.4.1 - Kopyalama Kontrolü) :

Şahsen ben kopyalama işlemlerinin varsayılan olarak tanımlanmasını talihsiz görüyorum ve sınıflarımın çoğunun nesnelerinin kopyalanmasını yasaklıyorum. Ancak, C ++ varsayılan atamasını ve kopya yapıcılarını C'den devralmıştır ve sıklıkla kullanılırlar.

Yani "yerine neden C ++ 'ın bir varsayılanı yok operator==() ?" Yerine, "C ++ neden varsayılan bir atama ve kopya oluşturucuya sahip?" Sorusu olmalıdır; yanıt, bu öğelerin C ile geriye doğru uyumluluk için Stroustrup tarafından isteksizce dahil edilmesidir. (muhtemelen C ++ 'nın siğillerinin çoğunun nedeni, aynı zamanda C ++' ın popülaritesinin başlıca nedeni).

Kendi amaçlarım için, IDE'mde yeni sınıflar için kullandığım snippet, özel atama operatörü ve kopya oluşturucu için bildirimler içeriyor, böylece yeni bir sınıf oluşturduğumda varsayılan atama ve kopyalama işlemleri alamıyorum - bildirimi açıkça kaldırmam gerekiyor private:Derleyicinin bunları benim için üretmesini istiyorsanız , bölümden bu işlemlerin .

C ++ 20'de bile, derleyici hala operator==sizin için örtük olarak üretmeyecektir

struct foo
{
    std::string str;
    int n;
};

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ill-formed

Ancak, C ++ 20'den beri açıkça varsayılan olarak ayarlama becerisi kazanacaksınız :==

struct foo
{
    std::string str;
    int n;

    // either member form
    bool operator==(foo const&) const = default;
    // ... or friend form
    friend bool operator==(foo const&, foo const&) = default;
};

Varsayılan ==, üye olarak yapar ==(varsayılan kopya yapıcısının üye olarak kopya yapması gibi). Yeni kurallar ==ve arasındaki beklenen ilişkiyi de sağlar !=. Örneğin, yukarıdaki beyanname ile her ikisini de yazabilirim:

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ok!
assert(foo{"Anton", 1} != foo{"Anton", 2}); // ok!

Bu özel özelliği (varsaymak operator==ve simetri arasındaki ==ve !=) gelen bir teklifin olduğunu daha geniş dil özelliğinin parçasıydı operator<=>.

IMHO, "iyi" bir sebep yok. Bu tasarım kararını kabul eden pek çok insanın nedeni, değere dayalı anlambilimin gücüne hakim olmayı öğrenmedikleri içindir. İnsanların uygulamalarında ham işaretçiler kullandıkları için birçok özel kopya oluşturucu, karşılaştırma operatörü ve yıkıcı yazmaları gerekir.

Uygun akıllı işaretçiler (std :: shared_ptr gibi) kullanıldığında, varsayılan kopya oluşturucu genellikle iyidir ve varsayımsal varsayılan karşılaştırma operatörünün açık şekilde uygulanması iyi olacaktır.

C ++, C vermediği için yanıt vermedi ve C'nin ilk olarak neden yalnızca varsayılan = = no == sağladığı yanıtlandı. C basit tutmak istedi: C uygulandı = memcpy tarafından; ancak == dolgu nedeniyle memcmp tarafından uygulanamaz. Dolgu başlatılmadığından memcmp, aynı olmalarına rağmen farklı olduklarını söylüyor. Boş sınıf için de aynı sorun vardır: memcmp boş sınıfların boyutu sıfır olmadığından farklı olduklarını söyler. Yukarıdan görülebilir. == uygulamasının C'de uygulamaktan daha karmaşık olduğu görülebilir. Bununla ilgili bazı kod örnekleri . Eğer yanılıyorsam düzeltmeniz takdir edilecektir.

Bu videoda STL'nin yaratıcısı Alex Stepanov bu soruyu 13:00 civarında ele alıyor. Özetlemek gerekirse, C ++ evrimini izledikten sonra şunu savunuyor:

• == ve! = ' Nin dolaylı olarak beyan edilmemesi talihsiz bir durumdur (ve Bjarne onunla hemfikirdir). Doğru bir dil bu şeyleri sizin için hazır bulundurmalıdır ( == anlamını kıran bir ! = Tanımlayamamanız gerektiğini ileri sürmektedir )
• Bu davanın kökleri (C ++ problemlerinin çoğu gibi) C'de olmasıdır. Burada, atama operatörü dolaylı olarak bitler halinde atama ile tanımlanır, ancak == için işe yaramaz . Bjarne Stroustrup'un bu makalesinde daha ayrıntılı bir açıklama bulunabilir .
• Takip eden soruda Neden o zaman üye karşılaştırmasıyla üye değildim , inanılmaz bir şey söylüyor : C biraz kendi kendine yetişen bir dildi ve Ritchie için bu şeyleri uygulayan adam, bunu uygulamak zor olduğunu söyledi!

Daha sonra (uzak) gelecekte == ve ! = Örtük olarak üretileceğini söyler.

C ++ 20, kolayca bir varsayılan karşılaştırma işleci uygulamak için bir yol sağlar.

Cppreference.com'dan bir örnek :

class Point {
    int x;
    int y;
public:
    auto operator<=>(const Point&) const = default;
    // ... non-comparison functions ...
};

// compiler implicitly declares operator== and all four relational operators work
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // ok, calls implicit Point::operator==
std::set<Point> s; // ok
s.insert(pt1); // ok
if (pt1 <= pt2) { /*...*/ } // ok, makes only a single call to Point::operator<=>

Varsayılan tanımlamak mümkün değildir ==, ancak varsayılan tanımlayabilirsiniz !=aracılığıyla ==genellikle kendinizi tanımlamak gerekir ki. Bunun için aşağıdaki şeyleri yapmalısınız:

#include <utility>
using namespace std::rel_ops;
...

class FooClass
{
public:
  bool operator== (const FooClass& other) const {
  // ...
  }
};

Ayrıntılar için http://www.cplusplus.com/reference/std/utility/rel_ops/ adresini görebilirsiniz .

Ayrıca operator< , tanımlarsanız , <=,>,> = için işleçler kullanılırken bundan çıkarılabilir std::rel_ops.

Ancak kullanırken dikkatli olmalısınız std::rel_ops çünkü karşılaştırma işleçleri beklenmedik türler için çıkarılabilir.

İlgili operatörü temel olandan çıkarmanın daha fazla tercih edilen yolu, boost :: operatörlerini kullanmaktır .

Desteklemede kullanılan yaklaşım daha iyidir, çünkü kapsamdaki tüm sınıflar için değil, yalnızca istediğiniz sınıf için işleç kullanımını tanımlar.

Ayrıca, "+ =", - "- =", vb. Öğelerinden "+" oluşturabilirsiniz ... (tam listeye buradan bakın )

C ++ 0x gelmiştir diyorsunuz böylece, varsayılan fonksiyonları için bir öneri vardı default operator==; Biz bu şeylerin açık hale getirmek için yardımcı olduğunu öğrendik.

Kavramsal olarak eşitliği tanımlamak kolay değildir. POD verileri için bile, alanlar aynı olsa bile, ancak farklı bir nesne (farklı bir adreste) olması gerektiği iddia edilemez. Bu aslında operatörün kullanımına bağlıdır. Ne yazık ki derleyiciniz psişik değil ve bunu çıkaramaz.

Bunun yanı sıra, varsayılan işlevler kendini ayağa vurmanın mükemmel yoludur. Açıkladığınız varsayılanlar temel olarak POD yapılarıyla uyumluluğu korumak için vardır. Bununla birlikte, geliştiriciler onları veya varsayılan uygulamaların anlambilimini unutarak fazlasıyla yıkıma neden olurlar.

Bunun için iyi bir neden var mı? Neden bir üye-üye karşılaştırması yapmak sorun olur?

İşlevsel olarak bir sorun olmayabilir, ancak performans açısından varsayılan üye-üye karşılaştırması, varsayılan üye-üye atama / kopyalama işleminden daha düşük optimal olabilir. Atama sırasından farklı olarak, karşılaştırma sırası performansı etkiler çünkü ilk eşit olmayan üye geri kalanın atlanabileceğini ima eder. Dolayısıyla, genellikle eşit olan bazı üyeler varsa, bunları en son karşılaştırmak istersiniz ve derleyici hangi üyelerin eşit olma olasılığının daha yüksek olduğunu bilmez.

verboseDescriptionNispeten küçük olası hava durumu tanımlarından seçilen uzun bir dizenin olduğu bu örneği düşünün .

class LocalWeatherRecord {
    std::string verboseDescription;
    std::tm date;
    bool operator==(const LocalWeatherRecord& other){
        return date==other.date
            && verboseDescription==other.verboseDescription;
    // The above makes a lot more sense than
     // return verboseDescription==other.verboseDescription
     //     && date==other.date;
    // because some verboseDescriptions are liable to be same/similar
    }
}

(Tabii ki derleyici, yan etkisi olmadığını fark ederse karşılaştırma sırasını göz ardı etme hakkına sahip olacaktır, ancak muhtemelen kuyruğunu, daha iyi bilgi sahibi olmadığı kaynak kodundan alacaktır.)

Sadece bu sorunun cevapları zaman geçtikçe tam kalır: C ++ 20'den beri komutla otomatik olarak oluşturulabilir auto operator<=>(const foo&) const = default;

Tüm işleçleri oluşturur: ==,! =, <, <=,> Ve> =, ayrıntılar için bkz. Https://en.cppreference.com/w/cpp/language/default_comparisons .

Operatörün görünümü nedeniyle <=>, buna uzay gemisi operatörü denir. Ayrıca bkz. Neden C ++ uzay gemisi operatörüne ihtiyacımız var? .

DÜZENLEME: Ayrıca C ++ 11 ile bunun için oldukça temiz bir yedek mevcuttur ile tam bir kod örneği için std::tiebkz. Https://en.cppreference.com/w/cpp/utility/tuple/tiebool operator<(…) . Çalışmak için değiştirilen ilginç kısım ==:

#include <tuple>

struct S {
………
bool operator==(const S& rhs) const
    {
        // compares n to rhs.n,
        // then s to rhs.s,
        // then d to rhs.d
        return std::tie(n, s, d) == std::tie(rhs.n, rhs.s, rhs.d);
    }
};

std::tie tüm karşılaştırma operatörleriyle çalışır ve derleyici tarafından tamamen optimize edilmiştir.

Kabul ediyorum, POD tipi sınıflar için derleyici bunu sizin için yapabilirdi. Ancak basit olarak düşünebileceğiniz derleyici yanlış olabilir. Bu yüzden programcının bunu yapmasına izin vermek daha iyidir.

Bir zamanlar iki alanın benzersiz olduğu bir POD vakam vardı - bu yüzden bir karşılaştırma asla doğru kabul edilmeyecekti. Ancak sadece yüke kıyasla ihtiyacım olan karşılaştırma - derleyicinin asla anlamayacağı veya kendi başına çözebileceği bir şey.

Ayrýca - yazmak uzun sürmüyorlar deđil mi ?!