Bu şablon işlevi neden beklendiği gibi davranmıyor?

Şablon işlevleri hakkında okuyordum ve bu sorunla karıştım:

#include <iostream>

void f(int) {
    std::cout << "f(int)\n";
}

template<typename T>
void g(T val) {
    std::cout << typeid(val).name() << "  ";
    f(val);
}

void f(double) {
    std::cout << "f(double)\n";
}

template void g<double>(double);

int main() {
    f(1.0); // f(double)
    f(1);   // f(int)
    g(1.0); // d  f(int), this is surprising
    g(1);   // i  f(int)
}

Yazmazsam sonuçlar aynı template void g<double>(double);.

Ben düşünüyorum g<double>sonra örneği alınmalıdır f(double)ve bu nedenle çağrısı fiçinde gçağırmalıdır f(double). Şaşırtıcı bir şekilde, yine çağırır f(int)içinde g<double>. Biri bunu anlamama yardımcı olabilir mi?

Cevapları okuduktan sonra kafa karışıklığımın gerçekte ne olduğunu anladım.

İşte güncellenmiş bir örnek. Çoğunlukla değişmedi, ancak aşağıdakiler için bir uzmanlık ekledim g<double>:

#include <iostream>

void f(int){cout << "f(int)" << endl;}

template<typename T>
void g(T val)
{
    cout << typeid(val).name() << "  ";
    f(val);
}

void f(double){cout << "f(double)" << endl;}

//Now use user specialization to replace
//template void g<double>(double);

template<>
void g<double>(double val)
{
    cout << typeid(val).name() << "  ";
    f(val);
}

int main() {
    f(1.0); // f(double)
    f(1);  // f(int)
    g(1.0); // now d  f(double)
    g(1);  // i  f(int)
}

Kullanıcı uzmanlığı ile g(1.0)beklediğim gibi davranır.

Derleyici bu aynı örneği otomatik olarak g<double>aynı yerde yapmamalı mı (hatta C ++ Programlama Dili , 4. baskı main()bölüm 26.3.3'te açıklandığı gibi )?

Ad f, bağımlı bir addır ( Tbağımsız değişkene bağlıdır val) ve iki adıma çözümlenir :

1. ADL dışı arama , şablon tanımı bağlamından görülebilen işlev bildirimlerini inceler .
2. ADL , şablon tanımı bağlamından veya şablon örneği bağlamından görülebilen işlev bildirimlerini inceler .

void f(double)şablon tanımı içeriğinden görünmez ve ADL de bulamaz, çünkü

Temel tür argümanları için, ilişkili ad alanları ve sınıflar kümesi boş

Örneğinizi biraz değiştirebiliriz:

struct Int {};
struct Double : Int {};

void f(Int) { 
    std::cout << "f(Int)";
}

template<typename T>
void g(T val) {
    std::cout << typeid(val).name() << ' ';
    f(val);
    // (f)(val);
}

void f(Double) { 
    std::cout << "f(Double)";
}

int main() {
    g(Double{});
}

Şimdi ADL void f(Double)ikinci adımda bulacaktır ve çıktı olacaktır 6Double f(Double). ADL yerine yazarak (f)(val)(veya ::f(val)) devre dışı bırakabiliriz f(val). Daha sonra çıktı, 6Double f(Int)örneğinizle uyumlu olacaktır.

Sorun, f(double)aradığınız noktada bildirilmemiştir; eğer beyanını önüne taşırsanız, template gçağrılacaktır.

Düzenleme: Neden manuel örnekleme kullanılır?

(Yalnızca işlev şablonları hakkında konuşacağım, sınıf şablonları için de benzer argüman tutulur.) Ana kullanım, derleme sürelerini azaltmak ve / veya şablonun kodunu kullanıcılardan gizlemektir.

C ++ programı 2 adımda ikili dosyalara yerleştirilmiştir: derleme ve bağlantı. Bir fonksiyonun derlenmesi için sadece fonksiyonun başlığı gereklidir. Bağlamanın başarılı olması için, işlevin derlenmiş gövdesini içeren bir nesne dosyası gerekir.

Derleyici şablonlanmış bir işlevin çağrısını gördüğünde , yaptığı şey şablonun gövdesini mi yoksa yalnızca üstbilgiyi mi bildiğine bağlıdır. Yalnızca üstbilgiyi görürse, işlevin şablonlaştırılmamış haliyle aynı şeyi yapar: bağlayıcı dosyasına yapılan çağrıyla ilgili bilgileri nesne dosyasına koyar. Ancak şablonun gövdesini de görürse başka bir şey yapar: vücudun uygun örneğini başlatır, bu gövdeyi derler ve nesne dosyasına da koyar.

Birden çok kaynak dosya, şablonlanmış işlevin aynı örneğini çağırırsa, nesne dosyalarının her biri, işlevin örneğinin derlenmiş bir sürümünü içerir. (Linker bunu bilir ve tek bir derlenmiş işleve yapılan tüm çağrıları çözer, bu nedenle programın / kütüphanenin son ikili dosyasında yalnızca bir tane olacaktır.) Ancak, kaynak dosyaların her birini derlemek için işlevin somutlaştırılması ve derledi, hangi zaman aldı.

Fonksiyonun gövdesi bir nesne dosyasındaysa, bağlayıcının işini yapması yeterlidir. Şablonu kaynak dosyaya el ile başlatmak, derleyicinin işlevin gövdesini söz konusu kaynak dosyanın nesne dosyasına koymasını sağlamanın bir yoludur. (Bu işlev çağrılmış gibi olabilir, ancak örnekleme işlev çağrısının geçersiz olacağı bir yere yazılır.) Bu yapıldığında, işlevinizi çağıran tüm dosyalar yalnızca işlevin başlığını bilerek derlenebilir. fonksiyonun gövdesini her bir çağrıda somutlaştırmak ve derlemek zaman alır.

İkinci neden (uygulama gizleme) şimdi mantıklı olabilir. Bir kütüphane yazarı, şablon işlevinin kullanıcılarının işlevi kullanabilmesini isterse, genellikle onlara şablonun kodunu verir, böylece kendileri derleyebilirler. Şablonun kaynak kodunu gizli tutmak isterse, kütüphaneyi oluşturmak ve kullanıcılara kaynak yerine bu şekilde elde edilen nesne sürümünü vermek için şablonu kodda manuel olarak başlatabilir.

Bu bir anlam ifade ediyor mu?