A +++++ b neden çalışmıyor?

int main ()
{
   int a = 5,b = 2;
   printf("%d",a+++++b);
   return 0;
}

Bu kod aşağıdaki hatayı verir:

hata: artış işlenen olarak ldeğer gerekli

Ama baştan sona boşluk koyarsam a++ +ve ++bo zaman iyi çalışır.

int main ()
{
   int a = 5,b = 2;
   printf("%d",a++ + ++b);
   return 0;
}

İlk örnekteki hata ne anlama geliyor?

printf("%d",a+++++b);(a++)++ + bMaximal Munch Kuralına göre yorumlanır ^! .

++(postfix) bir olarak değerlendirilmez lvalueancak işleneninin bir lvalue.

_{! 6.4 / 4, bir sonraki ön işleme belirtecinin bir ön işleme belirteci oluşturabilecek en uzun karakter dizisi olduğunu söylüyor "}

Derleyiciler aşamalar halinde yazılır. İlk aşama lexer olarak adlandırılır ve karakterleri sembolik bir yapıya dönüştürür. Böylece "++", birenum SYMBOL_PLUSPLUS . Daha sonra ayrıştırıcı aşaması bunu soyut bir söz dizimi ağacına dönüştürür, ancak sembolleri değiştiremez. Sözcüğü boşluk ekleyerek etkileyebilirsiniz (tırnak içinde olmadıkları sürece bitiş sembolleri).

Normal lexers açgözlüdür (bazı istisnalar dışında), bu nedenle kodunuz şu şekilde yorumlanıyor:

a++ ++ +b

Ayrıştırıcının girdisi bir sembol akışıdır, bu nedenle kodunuz aşağıdaki gibi olacaktır:

[ SYMBOL_NAME(name = "a"), 
  SYMBOL_PLUS_PLUS, 
  SYMBOL_PLUS_PLUS, 
  SYMBOL_PLUS, 
  SYMBOL_NAME(name = "b") 
]

Ayrıştırıcının sözdizimsel olarak yanlış olduğunu düşündüğü. (Yorumlara göre DÜZENLE: Anlamsal olarak yanlış çünkü bir r-değerine ++ uygulayamazsınız, bu a ++ sonucunu verir)

a+++b 

dır-dir

a++ +b

Hangisi tamam. Diğer örnekleriniz de öyle.

Lexer, token oluşturmak için genellikle "maksimum munch" algoritması olarak adlandırılan şeyi kullanır. Bu, karakterleri okurken, halihazırda sahip olduğu ile aynı simgenin parçası olamayacak bir şeyle karşılaşana kadar karakterleri okumaya devam ettiği anlamına gelir (örneğin, rakamları okuyorsa, bu yüzden sahip olduğu şey bir sayıdır, eğer karşılaşırsa bir A, sayının parçası olamayacağını bilir. Bu nedenle durur veA sonraki simgenin başlangıcı olarak kullanmak için giriş arabelleğinde ). Daha sonra bu belirteci ayrıştırıcıya geri döndürür.

Bu durumda, bu +++++, lexed anlamına gelir a ++ ++ + b. İlk artım sonrası bir r değeri verdiğinden, ikincisi ona uygulanamaz ve derleyici bir hata verir.

Sadece FWIW, C ++ operator++'da, bunun çalışmasına izin veren bir ldeğer elde etmek için aşırı yükleyebilirsiniz . Örneğin:

struct bad_code { 
    bad_code &operator++(int) { 
        return *this;
    }
    int operator+(bad_code const &other) { 
        return 1;
    }
};

int main() { 
    bad_code a, b;

    int c = a+++++b;
    return 0;
}

Kullanışlı olduğum C ++ derleyicileriyle (VC ++, g ++, Comeau) derler ve çalışır (hiçbir şey yapmaz).

Bu kesin örnek, taslak C99 standardında ( C11'de aynı ayrıntılar ) bölüm 6.4 Sözcüksel öğeler paragraf 4'te şu şekilde anlatılmaktadır:

Girdi akışı, belirli bir karaktere kadar ön işlem belirteçlerine ayrıştırılmışsa, bir sonraki ön işlem simgesi, bir ön işleme belirteci oluşturabilecek en uzun karakter dizisidir. [...]

Sözlük analizinde belirsizliklerden kaçınmak için kullanılan maksimum munch kuralı olarak da bilinen ve geçerli bir simge oluşturmak için olabildiğince çok öğe alarak çalışır.

paragrafta ayrıca iki örnek vardır, ikincisi sizin sorunuz için tam olarak eşleşir ve aşağıdaki gibidir:

ÖRNEK 2 x +++++ y program parçası, x ++ ++ + y olarak ayrıştırılır ve bu, x ++ + ++ y ayrıştırması doğru bir ifade verebilse bile, artırma işleçlerindeki bir kısıtlamayı ihlal eder.

bize şunu söyler:

a+++++b

şu şekilde ayrıştırılacak:

a ++ ++ + b

Bu, ilk art artışının sonucu bir değer olduğundan ve artım bir l değeri gerektirdiğinden, artım sonrası kısıtlamaları ihlal eder. Bu, ( vurgu benim ) yazan 6.5.2.4 Postfix artırma ve azaltma operatörleri bölümünde ele alınmıştır :

Sonek artırma veya azaltma operatörünün işleneni, nitelenmiş veya nitelenmemiş gerçek veya imleç tipine sahip olacak ve değiştirilebilir bir ldeğer olacaktır.

ve

Postfix ++ operatörünün sonucu, işlenenin değeridir.

C ++ Gotchas kitabı da Gotcha #17 Maximal Munch Problems'de bu durumu ele alır, C ++ ' da da aynı problemdir ve ayrıca bazı örnekler verir. Aşağıdaki karakter kümesiyle uğraşırken şunu açıklıyor:

->*

sözcük analizcisi şu üç şeyden birini yapabilir:

• Üç belirteçleri olarak tedavi: -, >ve*
• Bunu iki simge olarak ele alın: ->ve*
• Tek bir simge olarak ele alın: ->*

Maksimal Munch kuralı bu belirsizliklerden kaçınmak için izin verir. Yazar buna işaret ediyor ( C ++ bağlamında ):

neden olduğundan çok daha fazla sorunu çözer, ancak iki yaygın durumda bu bir rahatsızlıktır.

İlk örnek, şablon argümanları aynı zamanda şablon olan ( C ++ 11'de çözülen) şablonlardır , örneğin:

list<vector<string>> lovos; // error!
                  ^^

Kapanış açısı parantezlerini kaydırma operatörü olarak yorumlayan ve bu nedenle belirsizliği gidermek için bir boşluk gerekli:

list< vector<string> > lovos;
                    ^

İkinci durum, işaretçiler için varsayılan argümanları içerir, örneğin:

void process( const char *= 0 ); // error!
                         ^^

*=atama operatörü olarak yorumlanacaktır , bu durumda çözüm, bildirimdeki parametreleri adlandırmaktır.

Derleyiciniz çaresizce ayrıştırmaya çalışıyor a+++++bve bunu olarak yorumluyor (a++)++ +b. Şimdi, artım sonrası ( a++) ' nın sonucu bir ldeğer değildir , yani tekrar sonradan artırılamaz.

Lütfen üretim kalitesi programlarında asla böyle bir kod yazmayın. Kodunuzu yorumlaması gereken zavallı adamı düşünün.

(a++)++ +b

a ++ önceki değeri, bir r değeri döndürür. Bunu artıramazsınız.

Çünkü tanımlanmamış davranışlara neden olur.

Hangisi o?

c = (a++)++ + b
c = (a) + ++(++b)
c = (a++) + (++b)

Evet, ne siz ne de derleyici bunu bilmiyor.

DÜZENLE:

Gerçek sebep, diğerlerinin söylediği gibi:

Olarak yorumlanır (a++)++ + b.

ancak artım sonrası bir ldeğer gerektirir (adı olan bir değişkendir) ancak (a ++), artırılamayan bir r değeri döndürür ve böylece aldığınız hata mesajına yol açar.

Diğerlerine bunu belirtmek için teşekkürler.

Sanırım derleyici bunu

c = ((a ++) ++) + b

++işlenen olarak değiştirilebilecek bir değere sahip olmalıdır. a, değiştirilebilen bir değerdir. a++ancak bir 'rvalue'dur, değiştirilemez.

Bu arada GCC C gördüğüm hata aynıdır, ancak farklı ifadeli: lvalue required as increment operand.

Bu öncelik sırasına uyun

1. ++ (ön artış)

2. + - (toplama veya çıkarma)

3. "x" + "y" her iki diziyi de ekleyin

int a = 5,b = 2; printf("%d",a++ + ++b); //a is 5 since it is post increment b is 3 pre increment return 0; //it is 5+3=8