Virgül içeren üçlü operatör neden gerçek durumda yalnızca bir ifadeyi değerlendirir?

Şu anda C ++ Primer kitabıyla C ++ öğreniyorum ve kitaptaki alıştırmalardan biri:

Aşağıdaki ifadenin ne yaptığını açıklayın: someValue ? ++x, ++y : --x, --y

Biz ne biliyoruz? Üçlü operatörün virgül operatöründen daha yüksek önceliğe sahip olduğunu biliyoruz. İkili operatörlerde bunu anlamak oldukça kolaydı, ancak üçlü operatörle biraz mücadele ediyorum. İkili operatörler ile "daha yüksek önceliğe sahip" ifadesi, daha yüksek önceliğe sahip ifadenin etrafında parantezler kullanabileceğimiz ve yürütmeyi değiştirmeyeceği anlamına gelir.

Üçlü operatör için şunu yapardım:

(someValue ? ++x, ++y : --x, --y)

etkili bir şekilde aynı kodla sonuçlanır ve bu da derleyicinin kodu nasıl gruplayacağını anlamama yardımcı olmaz.

Bununla birlikte, bir C ++ derleyicisiyle test ettiğimden, ifadenin derlendiğini biliyorum ve bir :operatörün kendi başına neyi temsil edebileceğini bilmiyorum . Böylece derleyici üçlü operatörü doğru yorumluyor gibi görünüyor.

Sonra programı iki şekilde çalıştırdım:

#include <iostream>

int main()
{
    bool someValue = true;
    int x = 10, y = 10;

    someValue ? ++x, ++y : --x, --y;

    std::cout << x << " " << y << std::endl;
    return 0;
}

Sonuçlar:

11 10

Öte yandan, someValue = falsebununla birlikte şunları yazdırır:

9 9

Neden C ++ derleyici, üçlü operatörün gerçek dalı için yalnızca xartarken, üçlü öğenin yanlış dalı için hem xve hem de azaltan kod üretiyor y?

Hatta gerçek dalın etrafına parantez koyacak kadar ileri gittim:

someValue ? (++x, ++y) : --x, --y;

ama yine de sonuçlanır 11 10.

@Rakete'nin mükemmel yanıtlarında söylediği gibi , bu aldatıcıdır. Buna biraz daha eklemek istiyorum.

Üçlü operatör şu forma sahip olmalıdır:

mantıksal-veya-ifade ? ifade : atama-ifade

Bu yüzden aşağıdaki eşleştirmelerimiz var:

• someValue: mantıksal veya ifade
• ++x, ++y: ifade
• ??? olan atama-ifadesi --x, --y yoksa sadece --x?

Aslında bunun --xnedeni, bir atama ifadesinin virgülle ayrılmış iki ifade olarak ayrıştırılamamasıdır (C ++ dilbilgisi kurallarına göre), bu nedenle --x, --ybir atama ifadesi olarak değerlendirilemez .

Bu, üçlü (koşullu) ifade bölümünün şöyle görünmesine neden olur:

someValue?++x,++y:--x

Okunabilirlik uğruna parantez ++x,++yiçine alınmış gibi hesaplandığını düşünmek yardımcı olabilir (++x,++y); ?ve arasında bulunan her şey :koşulludan sonra sıralanacaktır. (Yazının geri kalanı için onları parantez içine alacağım).

ve şu sırayla değerlendirildi:

1. someValue?
2. (++x,++y)veya --x( bool1. sonuca bağlı olarak )

Bu ifade daha sonra virgül operatörünün sol alt ifadesi olarak değerlendirilir, sağ alt ifade --yşu şekilde olur:

(someValue?(++x,++y):--x), --y;

Bu, sol tarafın atılmış bir değer ifadesi olduğu anlamına gelir, yani kesinlikle değerlendirilir, ancak sonra sağ tarafı değerlendirip geri döndürürüz.

Öyleyse ne zaman someValueolur true?

1. (someValue?(++x,++y):--x)yürütür ve artırır xve yolmak 11ve11
2. Sol ifade atılır (artışın yan etkileri kalsa da)
3. : Biz virgül operatörünün sağ tarafını değerlendirmek --y, daha sonra azaltır ygeri10

Davranış "düzeltme" için, grup olabilir --x, --yparantez ile dönüşmesi için birincil ifade olan bir için geçerli bir giriş atama ifade *:

someValue?++x,++y:(--x, --y);

* Bir atama ifadesini birincil ifadeye geri bağlayan oldukça komik uzun bir zincir :

atama-ifade --- (şunlardan oluşabilir) -> koşullu ifade -> mantıksal veya ifade -> mantıksal ve ifade -> kapsayıcı veya ifade -> dışlayıcı veya ifade - -> ve-ifade -> eşitlik-ifade -> ilişkisel-ifade -> kaydırma-ifade -> eklemeli-ifade -> çarpan-ifade -> pm-ifade -> döküm-ifade -> tekli ifade -> sonek ifade -> birincil ifade

Vay canına, bu zor.

Derleyici ifadenizi şu şekilde görür:

(someValue ? (++x, ++y) : --x), --y;

Üçlü operatörün bir : , bu bağlamda kendi başına duramaz, ancak ondan sonra virgülün yanlış duruma ait olması için hiçbir neden yoktur.

Şimdi neden bu çıktıyı aldığınız daha mantıklı olabilir. Eğer someValuedoğruysa, o zaman ++x, ++yve --yetkili bir şekilde değişmez, hangi idam yfakat bir eklerx .

Eğer someValueyanlış, o zaman --xve --yteker ikisini de, azaltarak yürütülür.

Neden C ++ derleyicisi, üçlü operatörün gerçek dalı için yalnızca artan bir kod üretir? x

Olanları yanlış yorumladın. Gerçek dal hem xve y. Ancak,y bundan hemen sonra koşulsuz olarak indirilir.

Bu şu şekilde olur: Koşullu operatör C ++ 'da virgül operatöründen daha yüksek önceliğe sahip olduğundan , derleyici ifadeyi şu şekilde ayrıştırır:

   (someValue ? ++x, ++y : --x), (--y);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^

--yVirgülden sonra "öksüz" ifadesine dikkat edin. yBaşlangıçta artmış olan azalmaya yol açan şey budur .

Hatta gerçek dalın etrafına parantez koyacak kadar ileri gittim:

someValue ? (++x, ++y) : --x, --y;

Doğru yoldaydınız, ancak yanlış bir dalı parantezize ettiniz: Bunu, diğer dalı parantez içine alarak, şu şekilde düzeltebilirsiniz:

someValue ? ++x, ++y : (--x, --y);

Demo (baskılar 11 11)

Senin sorunun, üçlü ifadenin virgülden daha yüksek önceliğe sahip olmamasıdır. Aslında, C ++ basitçe öncelik ile doğru bir şekilde tanımlanamaz - ve tam olarak üç terimli operatör ile virgülün bozulduğu yer arasındaki etkileşimdir.

a ? b++, c++ : d++

şu şekilde ele alınır:

a ? (b++, c++) : d++

(virgül daha yüksek önceliğe sahipmiş gibi davranır). Diğer yandan,

a ? b++ : c++, d++

şu şekilde ele alınır:

(a ? b++ : c++), d++

ve üçlü operatör daha yüksek önceliklidir.

Cevaplarda göz ardı edilen bir nokta (yorumlara değinilmiş olsa da), koşullu operatörün değişkene iki değerden birini atamak için bir kısayol olarak gerçek kodda her zaman (tasarım tarafından amaçlanıyor mu?) Kullanılmasıdır.

Yani, daha geniş bağlam şöyle olacaktır:

whatIreallyWanted = someValue ? ++x, ++y : --x, --y;

Yüzünde saçma olan, bu yüzden suçlar çok çeşitlidir:

• Dil, bir ödevde saçma yan etkilere izin veriyor.
• Derleyici tuhaf şeyler yaptığınız konusunda sizi uyarmadı.
• Kitap, 'hileli' sorulara odaklanıyor gibi görünüyor. Sadece arkadaki cevabın "Bu ifadenin yaptığı şey, kimsenin beklemediği yan etkilerin üretilmesi için uydurma bir örnekteki tuhaf uç durumlara dayanmasıdır. Bunu asla yapma."