Cout neden bu kod parçacığında "2 + 3 = 15" yazdırıyor?

Aşağıdaki programın çıktısı neden nedir?

#include <iostream>
using namespace std;

int main(){

    cout << "2+3 = " <<
    cout << 2 + 3 << endl;
}

üretir

2+3 = 15

beklenen yerine

2+3 = 5

Bu soru zaten birden çok kapatma / yeniden açma döngüsüne gitti.

Kapanış için oy vermeden önce, lütfen bu konu hakkındaki bu meta tartışmayı düşünün .

İster kasıtlı olarak ister kazayla, <<muhtemelen kastettiğiniz yerde ilk çıktı satırının sonuna sahipsiniz ;. Yani esasen sahipsin

cout << "2+3 = ";  // this, of course, prints "2+3 = "
cout << cout;      // this prints "1"
cout << 2 + 3;     // this prints "5"
cout << endl;      // this finishes the line

Öyleyse soru şuna indirgeniyor: neden cout << cout;yazdırılıyor "1"?

Bu, belki de şaşırtıcı bir şekilde ince görünüyor. std::cout, Taban sınıfı ile std::basic_ios, içerir , belirli bir tür dönüşüm operatörü olduğu gibi, boolean bağlamında kullanılmak üzere tasarlanmıştır

while (cout) { PrintSomething(cout); }

Çıktının başarısız olması zor olduğu için bu oldukça zayıf bir örnektir - ancak std::basic_iosaslında hem giriş hem de çıkış akışları için temel bir sınıftır ve girdi için çok daha mantıklıdır:

int value;
while (cin >> value) { DoSomethingWith(value); }

(akışın sonunda veya akım karakterleri geçerli bir tam sayı oluşturmadığında döngüden çıkar).

Şimdi, bu dönüştürme operatörünün kesin tanımı, standardın C ++ 03 ve C ++ 11 sürümleri arasında değişti. Eski sürümlerde, operator void*() const;(genellikle olarak uygulanır return fail() ? NULL : this;), daha yeni sürümlerde explicit operator bool() const;(genellikle basitçe uygulanır return !fail();). Her iki bildirim de boole bağlamında iyi çalışır, ancak bu tür bağlamın dışında (yanlış) kullanıldığında farklı davranır.

Özellikle, C ++ 03 kuralları altında, bir adres cout << coutolarak yorumlanacak cout << cout.operator void*()ve bir adres yazdırılacaktır. C ++ 11 kurallarına göre, cout << coutoperatör bildirildiği explicitve dolayısıyla örtük dönüştürmelere katılamayacağı için hiç derlenmemelidir . Aslında değişimin birincil motivasyonu buydu - anlamsız kodların derlenmesini engellemek. Her iki standarda da uyan bir derleyici, yazdıran bir program üretmez "1".

Görünüşe göre, bazı C ++ uygulamaları, derleyici ve kitaplığı uygun olmayan sonuç üretecek şekilde karıştırmaya ve eşleştirmeye izin veriyor (@StephanLechner'dan alıntı: "xcode'da 1 üreten bir ayar ve bir adres veren başka bir ayar buldum: Dil lehçesi "Standart kitaplık libc ++ (c ++ 11 destekli LLVM standart kitaplığı)" ile birleştirilen c ++ 98 1 verirken, libstdc (gnu c ++ standart kitaplığı) ile birleştirilen c ++ 98 bir adres verir; "). explicitDönüşüm operatörlerini (C ++ 11'de yenidir) anlamayan ve dönüşümü operator bool(). Böyle bir karışımla, basitçe ve baskı cout << coutolarak yorumlanmak mümkün hale gelir .cout << cout.operator bool()cout << true"1"

Igor'un dediği gibi, bunu bir C ++ 11 kitaplığı ile elde edersiniz, burada std::basic_iosthe operator boolyerine vardır operator void*, ancak bir şekilde bildirilmez (veya olarak değerlendirilmez) explicit. Doğru beyan için buraya bakın .

Örneğin, uyumlu bir C ++ 11 derleyicisi ile aynı sonucu verecektir.

#include <iostream>
using namespace std;

int main() {
    cout << "2+3 = " << 
    static_cast<bool>(cout) << 2 + 3 << endl;
}

ama sizin durumunuzda, static_cast<bool>örtük bir dönüştürme olarak (yanlış bir şekilde) izin verilmektedir.

Düzenleme: Bu olağan veya beklenen bir davranış olmadığından, platformunuzu, derleyici sürümünü vb. Bilmek yararlı olabilir.

Düzenleme 2: Referans için kod genellikle şu şekilde yazılır

    cout << "2+3 = "
         << 2 + 3 << endl;

veya olarak

    cout << "2+3 = ";
    cout << 2 + 3 << endl;

ve iki stili karıştırarak hatayı açığa çıkarıyor.

Beklenmeyen çıktının nedeni bir yazım hatasıdır. Muhtemelen demek istedin

cout << "2+3 = "
     << 2 + 3 << endl;

Beklenen çıktıya sahip dizeleri göz ardı edersek, kalırız:

cout << cout;

C ++ 11'den beri, bu biçimsizdir. std::coutörtülü bir şekilde std::basic_ostream<char>::operator<<(veya üye olmayan aşırı yüklemenin) kabul edeceği herhangi bir şeye dönüştürülemez . Bu nedenle, standartlara uygun bir derleyici en azından bunu yaptığınız için sizi uyarmalıdır. Derleyicim programınızı derlemeyi reddetti.

std::coutdönüştürülebilir olacaktır boolve akım girdi operatörünün bool aşırı yüklemesi 1'lik gözlemlenen çıktıya sahip olacaktır. Ancak, bu aşırı yük açıktır, bu nedenle örtük bir dönüşüme izin vermemelidir. Derleyici / standart kitaplık uygulamanızın kesinlikle standarda uymadığı görülüyor.

Ön-C ++ 11 standardında, bu iyi oluşturulmuştur. O zamanlar std::cout, void*akış girişi operatörü aşırı yüklemesine sahip örtük bir dönüştürme operatörü vardı . Ancak bunun çıktısı farklı olacaktır. std::coutnesnenin bellek adresini yazdırır .

Gönderilen kod, herhangi bir C ++ 11 (veya daha sonraki uyumlu derleyici) için derlenmemelidir, ancak C ++ 11 öncesi uygulamalarda bir uyarı bile olmadan derlenmelidir.

Aradaki fark, C ++ 11'in bir akışın dönüşümünü açık bir bool'a dönüştürmesidir:

C.2.15 Madde 27: Giriş / çıkış kitaplığı [diff.cpp03.input.output] 27.7.2.1.3, 27.7.3.4, 27.5.5.4

Değişiklik: Mevcut boole dönüştürme işleçlerinde açık kullanımının belirtilmesi
Gerekçe: Amaçları netleştirin, geçici çözümlerden kaçının.
Orijinal özellik üzerindeki etki: Örtük boole dönüşümlerine dayanan geçerli C ++ 2003 kodu bu Uluslararası Standart ile derlenemez. Bu tür dönüşümler aşağıdaki koşullarda gerçekleşir:

• bool türünde bir argüman alan bir işleve bir değer iletmek;
  ...

ostream operatörü << bir bool parametresiyle tanımlanır. Bool'a bir dönüşüm var olduğundan (ve açık olmadığından), C ++ 11 öncesi cout << coutçevrildi ve cout << true1 sonucunu verdi.

Ve C.2.15'e göre, bu artık C ++ 11'den başlayarak derlenmemelidir.

Bu şekilde kodunuzun hatalarını kolayca ayıklayabilirsiniz. coutÇıktınızı kullandığınızda arabelleğe alınır, böylece şu şekilde analiz edebilirsiniz:

İlk oluşumunun couttamponu temsil ettiğini ve operatörün tamponun <<sonuna eklemeyi temsil ettiğini düşünün . <<Sizin durumunuzda, operatörün sonucu çıktı akışıdır cout. Şunlardan başlıyorsunuz:

cout << "2+3 = " << cout << 2 + 3 << endl;

Yukarıda belirtilen kuralları uyguladıktan sonra, aşağıdaki gibi bir dizi eylem alırsınız:

buffer.append("2+3 = ").append(cout).append(2 + 3).append(endl);

Daha önce de söylediğim gibi sonucu buffer.append()tampon. Başlangıçta tamponunuz boştur ve işlemek için aşağıdaki ifadeye sahipsiniz:

Beyan: buffer.append("2+3 = ").append(cout).append(2 + 3).append(endl);

tampon: empty

Önce buffer.append("2+3 = "), verilen dizgeyi doğrudan tampona koyan ve haline gelen var buffer. Şimdi durumunuz şöyle görünüyor:

Beyan: buffer.append(cout).append(2 + 3).append(endl);

tampon: 2+3 = 

Bundan sonra ifadenizi analiz etmeye devam edersiniz coutve tamponun sonuna eklemek için bir argüman olarak karşılaşırsınız. coutOlarak kabul edilir 1Eğer ekler böylece 1sizin tampon sonuna. Şimdi bu durumdasın:

Beyan: buffer.append(2 + 3).append(endl);

tampon: 2+3 = 1

Tamponda sahip olduğunuz sonraki şey 2 + 3ve toplama, çıktı operatöründen daha yüksek önceliğe sahip olduğundan, önce bu iki sayıyı ekleyeceksiniz ve sonra sonucu tampona koyacaksınız. Bundan sonra alırsınız:

Beyan: buffer.append(endl);

tampon: 2+3 = 15

Sonunda endltamponun sonuna değer eklersiniz ve şunlara sahip olursunuz:

Beyan:

tampon: 2+3 = 15\n

Bu işlemden sonra tampondaki karakterler tek tek tampondan standart çıktıya yazdırılır. Yani kodunuzun sonucu 2+3 = 15. Eğer bakarsak ek olsun 1dan coutyazdırmaya çalıştı. Ekstrenizden çıkararak << coutistediğiniz çıktıyı alacaksınız.