Neden şu işi?

void foo() {
    cout << "Foo to you too!\n";
};

int main() {
    void (*p1_foo)() = foo;
    void (*p2_foo)() = *foo;
    void (*p3_foo)() = &foo;
    void (*p4_foo)() = *&foo;
    void (*p5_foo)() = &*foo;
    void (*p6_foo)() = **foo;
    void (*p7_foo)() = **********************foo;

    (*p1_foo)();
    (*p2_foo)();
    (*p3_foo)();
    (*p4_foo)();
    (*p5_foo)();
    (*p6_foo)();
    (*p7_foo)();
}

Operatörler bu kombinasyonlar aynı şekilde çalışmasını sağlamak, bu birkaç parça vardır.

Bu iş temel neden de bir işlev (foo) işlevi için bir işaretçi örtük olarak dönüştürülebilir olmasıdır. Bu void (*p1_foo)() = foo; çalışıyor: foo dolaylı olarak kendisi için bir işaretçi dönüştürülür ve bu işaretçi p1_foo. atanır

Bir fonksiyonu uygulandığında & bir nesneye uygulanan bir nesnenin adresi verir gibi işlev işaretçisi verir, tekli. Sıradan işlev işaretçileri için, her zaman örtülü-fonksiyon-işlev işaretçisi dönüşüm nedeniyle gereksiz. Her durumda, bu void (*p3_foo)() = &foo; çalışıyor.

Birli *, ne zaman uygulanan bir işlev işaretçisi, verim sivri işlevi, gibi verim sivri nesne ne zaman uygulanır sıradan bir gösterici bir nesne.

Bu kurallar ile birlikte. İkinci, 9**: örnek son düşünün

• İlk foo dolaylı olarak kendisi için bir işaretçi ve * Bu işlev işaretçisi uygulanan ilk dönüştürülür, işlevini oluşturan 12* *tekrar.
• O zaman, sonuç yine dolaylı olarak kendisi için bir işaretçi ve * tekrar fonksiyonu foo verimli uygulandığı ikinci dönüştürülür.
• Sonra örtülü olarak işlev işaretçisi tekrar çevrilir ve değişken atanır.

İstediğiniz gibi *s gibi birçok ekleyebilirsiniz, sonuç hep aynı. *s daha fazla, daha eğlenceli.

Ayrıca, 17**: beşinci örnek sayabiliriz

• İlk, foo dolaylı olarak kendisi için bir işaretçi dönüştürülür; birli * tekrar foo verimli uygulanır.
• Daha sonra & foo, değişkene atanmış olan foo bir işaretçi getirisi için uygulanır.

& sadece uygulanan bir işlevi olmasına rağmen, bir işlevi sahip olan dönüştürülmüş bir işlev işaretçisi (tabii, sürece, işlev gösterici değişkeni, bu durumda sonucu bir işaretçi bir işaretçi için bir fonksiyon; örneğin, sen-ebil eklemek için listesi void (**pp_foo)() = &p7_foo;).

Bu &&foo çalışmıyor neden: &foo bir fonksiyonu değildir; bir rvalue bir işlev işaretçisi. 29**, bu ifadelerin her ikisi de çünkü gibi ancak, &*&*&*&*&*&*foo çalışacak, & her zaman rvalue işlev işaretçisi bir işlev için uygulanmaz.

Not da ihtiyaç duymazsınız kullanmak için tekli * yap arama) işlevi işaretçi; (*p1_foo)(); (p1_foo)(); aynı sonuç, yine çünkü işlevi-fonksiyonu-işaretçi dönüşüm.