Bu konuyu aşağıdaki konunun bir devamı olarak düşünün:

Önceki taksit
Tanımlanmamış davranış ve sıra noktaları

Bu komik ve kıvrımlı ifadeyi tekrar gözden geçirelim (italik ifadeler yukarıdaki konudan alınmıştır * gülümseme *):

i += ++i;

Bunun tanımsız davranışı çağırdığını söylüyoruz. Bunu derken, biz örtülü farz farz türü arasında iyerleşik türlerinden biridir.

Ya tip ait ikullanıcı tanımlı türüdür? IndexBu yazıda daha sonra tanımlanan türünün olduğunu söyleyin (aşağıya bakın). Yine de tanımsız davranışa neden olur mu?

Cevabınız evet ise neden? Yazmakla eşdeğer, i.operator+=(i.operator++());hatta sözdizimsel olarak daha basit değil i.add(i.inc());mi? Yoksa onlar da tanımlanmamış davranışa mı başvururlar?

Hayır ise, neden olmasın? Sonuçta, nesne ardışık sıralama noktaları arasında iki kezi değiştirilir . Lütfen pratik kuralı hatırlayın: Bir ifade, bir nesnenin değerini ardışık "sıra noktaları arasında yalnızca bir kez değiştirebilir . Ve eğer bir ifade ise, o zaman tanımsız davranışı çağırmalıdır. Eğer öyleyse, eşdeğerleri ve ayrıca tanımsız davranışı çağırmalıdır. doğru değil gibi görünüyor! (anladığım kadarıyla)i += ++ii.operator+=(i.operator++());i.add(i.inc());

Yoksa başlamak için i += ++ibir ifade değil mi? Eğer öyleyse, o zaman nedir ve ifadenin tanımı nedir?

Bir ifadeyse ve aynı zamanda davranışı da iyi tanımlanmışsa, bir ifadeyle ilişkili sıra noktalarının sayısının bir şekilde ifadede yer alan işlenenlerin türüne bağlı olduğunu ima eder . Doğru muyum (kısmen de olsa)?

Bu arada, bu ifade nasıl olur?

//Consider two cases:
//1. If a is an array of a built-in type
//2. If a is user-defined type which overloads the subscript operator!

a[++i] = i; //Taken from the previous topic. But here type of `i` is Index.

Cevabınızda bunu da göz önünde bulundurmalısınız (davranışını kesin olarak biliyorsanız). :-)

Dır-dir

++++++i;

C ++ 03'te iyi tanımlanmış mı? Sonuçta, bu bu,

((i.operator++()).operator++()).operator++();

class Index
{
    int state;

    public:
        Index(int s) : state(s) {}
        Index& operator++()
        {
            state++;
            return *this;
        }
        Index& operator+=(const Index & index)
        {
            state+= index.state;
            return *this;
        }
        operator int()
        {
            return state;
        }
        Index & add(const Index & index)
        {
            state += index.state;
            return *this;
        }
        Index & inc()
        {
            state++;
            return *this;
        }
};

Kod gibi görünüyor

i.operator+=(i.operator ++());

Sıralama noktalarına göre mükemmel şekilde çalışır. C ++ ISO standardının 1.9.17 Bölümü, sıra noktaları ve işlev değerlendirmesi hakkında şunları söyler:

Bir işlevi çağırırken (işlev satır içi olsun ya da olmasın), tüm işlev bağımsız değişkenlerinin (varsa) değerlendirilmesinden sonra işlev gövdesindeki herhangi bir ifade veya deyimin yürütülmesinden önce gerçekleşen bir sıra noktası vardır. Ayrıca, döndürülen bir değerin kopyalanmasından sonra ve işlevin dışındaki herhangi bir ifadenin yürütülmesinden önce bir sıra noktası vardır.

Bu, örneğin, i.operator ++()parametrenin operator +=değerlendirilmesinden sonra bir sıra noktasına sahip olduğunu gösterir . Kısaca, aşırı yüklenmiş operatörler işlevler olduğundan, normal sıralama kuralları geçerlidir.

Bu arada harika bir soru! Beni zaten bildiğimi sandığım (ve bildiğimi düşündüğümü düşündüğüm) bir dilin tüm nüanslarını anlamaya nasıl zorladığınızı gerçekten seviyorum. :-)

http://www.eelis.net/C++/analogliterals.xhtml Analog değişmezler aklıma geliyor

  unsigned int c = ( o-----o
                     |     !
                     !     !
                     !     !
                     o-----o ).area;

  assert( c == (I-----I) * (I-------I) );

  assert( ( o-----o
            |     !
            !     !
            !     !
            !     !
            o-----o ).area == ( o---------o
                                |         !
                                !         !
                                o---------o ).area );

Başkalarının dediği gibi, senin i += ++i örneğin işlevleri çağırdığınız için kullanıcı tanımlı türle çalışır ve işlevler sıra noktalarını içerir.

Öte yandan, a[++i] = ibunun asizin temel dizi türünüz, hatta kullanıcı tanımlı bir dizi olduğunu varsayarsak o kadar da şanslı sayılmaz . Burada sahip olduğunuz sorun, ifadenin hangi kısmının iönce değerlendirildiğini bilmememizdir . Bu ++i, değerlendirilebilir, operator[]nesneyi oraya geri getirmek için (veya ham sürüme) iaktarılabilir ve daha sonra değerin ona aktarılması (ki bu, i artırıldıktan sonra) olabilir. Öte yandan, belki de ikinci taraf önce değerlendirilir, daha sonraki ödev için saklanır ve ardından ++iparça değerlendirilir.

Bence iyi tanımlanmış:

C ++ taslak standardından (n1905) §1.9 / 16:

"Döndürülen bir değerin kopyalanmasından sonra ve işlevin dışındaki herhangi bir ifadenin yürütülmesinden önce de bir sıra noktası vardır13). C ++ 'daki çeşitli bağlamlar, çeviri biriminde karşılık gelen işlev çağrısı sözdizimi görünmese bile, bir işlev çağrısının değerlendirilmesine neden olur. [ Örnek : yeni bir ifadenin değerlendirilmesi, bir veya daha fazla ayırma ve yapıcı işlevi çağırır; bkz. 5.3.4. Başka bir örnek için, işlev çağrısı sözdiziminin görünmediği bağlamlarda bir dönüştürme işlevinin (12.3.2) çağrılması ortaya çıkabilir. - end örnek ] İşlev girişindeki ve işlev çıkışındaki sıra noktaları (yukarıda açıklandığı gibi) , ifadenin sözdizimi ne olursa olsun değerlendirilen işlev çağrılarının özellikleridir.işlevi çağıran olabilir. "

Kalın yazdığım kısma dikkat edin. Bu, gerçekten de artış fonksiyonu çağrısından ( i.operator ++()) sonra, ancak bileşik atama çağrısından ( i.operator+=) önce bir sıra noktası olduğu anlamına gelir .

Peki. Önceki cevapları okuduktan sonra, kendi sorumu, özellikle de sadece Noah'ın cevap vermeye çalıştığı, ancak ona tamamen ikna olmadığım kısmı yeniden düşündüm .

a[++i] = i;

Dava 1:

If abir yerleşik tür dizisidir. O halde Noah'ın söylediği doğru. Yani,

a [++ i] = i, a'nın temel dizi türünüz olduğunu varsayarsak o kadar şanslı değil, hatta bir kullanıcı tanımlı . Buradaki sorun, i içeren ifadenin hangi kısmının önce değerlendirildiğini bilmememizdir.

Yani a[++i]=itanımsız davranışı çağırır veya sonuç belirsizdir. Her ne ise, iyi tanımlanmış değil!

Not: Yukarıdaki alıntıda, üstü çizili tabii ki benim.

Durum 2:

Eğer aaşırı yükler kullanıcı tanımlı tür bir amacı operator[], daha sonra yine iki durum vardır.

1. Aşırı yüklenmiş operator[]işlevin dönüş türü yerleşik tür ise, yeniden a[++i]=itanımsız davranışı çağırır veya sonuç belirtilmez.
2. Aşırı dönüş tipi Ama eğer operator[]fonksiyonunun daha sonra davranışı kullanıcı tanımlı türüdür a[++i] = i(bildiğim kadarıyla anladığım kadarıyla) iyi tanımlanmış olup, bu durumda bu yana a[++i]=iyazılı eşdeğerdir a.operator[](++i).operator=(i);, aynıdır a[++i].operator=(i);. Yani, çok iyi tanımlanmış gibi görünen operator=, döndürülen nesnede atama çağrılır a[++i], çünkü zaman a[++i]geri dönüşleri ++izaten değerlendirilmiştir ve sonra döndürülen nesne operator=, güncellenmiş değerini iargüman olarak ona ileten işlevi çağırır . Bu iki çağrı arasında bir sıra noktası olduğuna dikkat edin, . Ve sözdizimi bu iki çağrı arasında rekabet olmamasını sağlar veoperator[]önce çağrılırdı ve ard arda, ++iona aktarılan argüman da önce değerlendirilirdi.

Bunu, someInstance.Fun(++k).Gun(10).Sun(k).Tun();her ardışık işlev çağrısının kullanıcı tanımlı türde bir nesne döndürdüğü gibi düşünün . Bana göre bu durum daha çok şuna benziyor: eat(++k);drink(10);sleep(k)çünkü her iki durumda da, her işlev çağrısından sonra sıra noktası var.

Yanılıyorsam lütfen beni düzeltin. :-)