Örtük argüman dönüşümüne güvenmek tehlikeli midir?

C ++, bağımsız değişkenler beklenen türler değilse, parametre türlerinin eşleşen yapıcılarını otomatik olarak çağıran bir özelliğe sahiptir (doğru adını anlayamıyorum).

Bunun çok temel bir örneği, std::stringbir const char*argümanla beklenen bir işlevi çağırmaktır . Derleyici, uygun kurucuyu çağırmak için otomatik olarak kod oluşturur std::string.

Merak ediyorum, düşündüğüm kadar okunabilirlik için kötü mü?

İşte bir örnek:

class Texture {
public:
    Texture(const std::string& imageFile);
};

class Renderer {
public:
    void Draw(const Texture& texture);
};

Renderer renderer;
std::string path = "foo.png";
renderer.Draw(path);

Bu iyi mi? Yoksa çok mu ileri gidiyor? Eğer yapmamam gerekirse, bir şekilde Clang veya GCC'yi uyarması yapabilir miyim?

Buna, dönüştürücü bir kurucu (veya bazen örtük kurucu veya örtük dönüşüm) denir.

Bu olduğunda uyarmak için bir derleme zamanı anahtarının farkında değilim, ancak önlenmesi çok kolay; sadece explicitanahtar kelimeyi kullanın .

class Texture {
public:
    explicit Texture(const std::string& imageFile);
};

Dönüştürücü kurucuların iyi bir fikir olup olmadığı konusunda: O bağlıdır.

Örtük dönüştürmenin mantıklı olduğu durumlar:

• Sınıf, örtük olarak inşa edilip edilmediğini umursamayacağınız kadar ucuzdur.
• Bazı sınıflar kavramsal olarak argümanlarına benzer ( örtük olarak dönüştürebildiği ile std::stringaynı kavramı yansıtmak gibi const char *), dolaylı dönüşüm mantıklıdır.
• Örtülü dönüşüm devre dışı bırakılırsa bazı sınıfların kullanımı çok daha rahatsız edici olur. (Bir dize hazır bilgisini her geçmek istediğinizde açıkça std :: string'i çağırmayı düşünün. Boost'un Parçaları benzerdir.)

Örtük dönüştürmenin daha az anlamlı olduğu durumlar:

• İnşaat pahalıdır (grafik dosyasının yüklenmesi ve ayrıştırılması gereken Doku örneğiniz gibi).
• Sınıflar kavramsal olarak argümanlarından çok farklıdır. Örneğin, boyutunu bağımsız değişken olarak alan dizi benzeri bir kapsayıcı düşünün:

    sınıf FlagList
    {
        FlagList (int initial_size); 
    };

    void SetFlags (const FlagList & flag_list);

    int main () {
        // Şimdi bu açıkça görülmemesine rağmen derleniyor
        // ne yapıyor.
        SetFlags (42);
    }

• Yapının istenmeyen yan etkileri olabilir. Örneğin, bir AnsiStringsınıf gerekir değil dolaylı bir den inşa UnicodeStringUnicode ve ANSI dönüşüm bilgilerini kaybedebilir çünkü.

Daha fazla okuma:

• C ++ SSS açık kurucular üzerinde
• Google C ++ Stil Kılavuzu neredeyse her zaman açık kurucular kullanmayı söylüyor.
• Bu StackOverflow sorusu daha fazla artıları ve eksileri gider.

Bu, bir yanıttan çok bir yorumdur, ancak bir yorum koymak için çok büyüktür.

İlginçtir, g++bunu yapmama izin vermiyor:

#include <iostream>
#include <string>

class Texture {
        public:
                Texture(const std::string& imageFile)
                {
                        std::cout << "Texture()" << std::endl;
                }
};

class Renderer {
        public:
                void Draw(const Texture& texture)
                {
                        std::cout << "Renderer.Draw()" << std::endl;
                }
};

int main(int argc, char* argv[])
{
        Renderer renderer;
        renderer.Draw("foo.png");

        return 0;
}

Aşağıdakileri üretir:

$ g++ -o Conversion.exe Conversion.cpp 
Conversion.cpp: In function ‘int main(int, char**)’:
Conversion.cpp:23:25: error: no matching function for call to ‘Renderer::Draw(const char [8])’
Conversion.cpp:14:8: note: candidate is: void Renderer::Draw(const Texture&)

Ancak, eğer satırı değiştirirseniz:

   renderer.Draw(std::string("foo.png"));

Bu dönüşümü gerçekleştirecektir.

Buna örtük tür dönüşümü denir. Genel olarak, gereksiz tekrarları engellediği için iyi bir şeydir. Örneğin, fazladan bir kod yazmak zorunda kalmadan otomatik olarak bir std::stringsürümünü alırsınız Draw. Kendisini Rendererdeğiştirmeden yeteneklerini genişletmenize izin verdiği için açık-kapalı prensibini takip etmeye de yardımcı olabilir Renderer.

Öte yandan, dezavantajları yoktur. Bir argümanın nereden geldiğini bulmak zor olabilir. Bazen başka durumlarda beklenmedik sonuçlar doğurabilir. Yani ne explicitkelime içindir. Yapıcıya koyarsanız Texture, örtük tür dönüşümü için bu yapıcıyı kullanmayı devre dışı bırakır. Örtük tür dönüşüm hakkında küresel olarak uyarmak için bir yöntemin farkında değilim, ama bu bir yöntemin var olmadığı anlamına gelmez, sadece gcc'nin anlaşılmaz derecede çok sayıda seçeneği vardır.