Neden std::cout yazmak zorunda mıyım ve ayrıca böyle bir kod std::<<:

#include <iostream>

int main() {
    std::cout << "Hello, world!";
    return 0;
}

cout std kütüphane geliyor, ve << genellikle bit kaydırma yapmak kullanılmaz? Ben neden kapsam operatörü yazmak zorunda :: ayrıca daha önce de başka bir anlamı ile kullanıldığından, 12**, değil mi? Derleyici nasıl std::cout, << başka bir şey anlamına gelir sonra bilir?

İlk olarak, derleyici << sol ve sağ tip bakar. std::cout tip std::ostream edebi türü dize15 const char dizisi. Sol sınıf türü olduğu gibi, bir fonksiyon operator<< adlı aranır. Soru, nereye bakacağız?

Bu isim için arama operator<< işlev adı std::operator<< gibi nitelikli değildir, çünkü sözde niteliksiz bir arama. İşlev adları için niteliksiz arama bağımlı değişken arama çağırır. Bağımlı değişken arama, ad alanları ve sınıfları bağımsız değişken türleri ile ilgili arama olacaktır.

<iostream> imza ücretsiz bir fonksiyonu vardır

template<typename traits>
std::basic_ostream<char, traits>& operator<<(std::basic_ostream<char, traits>&,
                                             const char*);

ad alanı ilan edilen 24**. Bu ad std::cout Bu işlev bulunacak bu nedenle bu tür ile ilişkilidir.

std::ostream ** 27, ve sadece bir typedef*28 15* dizisiörtülü olarak char const* (dizinin ilk elemanına işaret) dönüştürülebilir. Bu nedenle, bu işlevi iki bağımsız değişken türleri ile çağrılabilir.

operator<< ama bu bağımsız değişken için en iyi eşleşme yukarıda bahsettiğim fonksiyon türleri diğer aşırı ve bu durumda seçilmiş vardır.

Bağımlı değişken arama: basit bir örnek

namespace my_namespace
{
    struct X {};

    void find_me(X) {}
}

int main()
{
    my_namespace::X x;
    find_me(x);       // finds my_namespace::find_me because of the argument type
}

Bu işlev, bir operatör Olarak N. B., gerçek arama biraz daha karmaşık. Baktım ilk tartışma kapsamında nitelikli Arama Eğer bu sınıf tipi (varsa), yani üye bir fonksiyonu olarak. o kadar.Ayrıcakalitesiz bir arama yapıldı, ancak tüm üye fonksiyonları yok sayılıyor. Sonuç niteliksiz arama aslında bağımlı değişken arama ikinci adım iki adımlı bir prosedür gibi olduğundan biraz farklı. Eğer ilk adım bir üye işlev bulursa, ikinci adım, yani bağımlı değişken arama yapıldıdeğilkullanılır.

Karşılaştırın:

namespace my_namespace
{
    struct X
    {
        void find_me(X, int) {}
        void search();
    };
    void find_me(X, double) {}

    void X::search() {
        find_me(*this, 2.5); // only finds X::find_me(int)
        // pure unqualified lookup (1st step) finds the member function
        // argument-dependent lookup is not performed
    }
}

için:

namespace my_namespace
{
    struct X
    {
        void operator<<(int) {}
        void search();
    };
    void operator<<(X, double) {}

    void X::search() {
        *this << 2.5; // find both because both steps are always performed
        // and overload resolution selects the free function
    }
}