Cara membebani std :: swap ()

std::swap()digunakan oleh banyak kontainer std (seperti std::listdan std::vector) selama penyortiran dan bahkan penugasan.

Tetapi implementasi std swap()sangat umum dan agak tidak efisien untuk tipe kustom.

Dengan demikian, efisiensi dapat diperoleh dengan membebani std::swap()dengan implementasi khusus tipe kustom. Tetapi bagaimana Anda bisa menerapkannya sehingga akan digunakan oleh kontainer std?

Cara yang benar untuk membebani swap adalah dengan menuliskannya di namespace yang sama dengan apa yang Anda tukar, sehingga dapat ditemukan melalui pencarian yang bergantung pada argumen (ADL) . Satu hal yang sangat mudah dilakukan adalah:

class X
{
    // ...
    friend void swap(X& a, X& b)
    {
        using std::swap; // bring in swap for built-in types

        swap(a.base1, b.base1);
        swap(a.base2, b.base2);
        // ...
        swap(a.member1, b.member1);
        swap(a.member2, b.member2);
        // ...
    }
};

Perhatian Mozza314

Berikut adalah simulasi dari efek std::algorithmpemanggilan generik std::swap, dan meminta pengguna menyediakan swap mereka di namespace std. Karena ini adalah sebuah eksperimen, simulasi ini menggunakan namespace expbukan namespace std.

// simulate <algorithm>

#include <cstdio>

namespace exp
{

    template <class T>
    void
    swap(T& x, T& y)
    {
        printf("generic exp::swap\n");
        T tmp = x;
        x = y;
        y = tmp;
    }

    template <class T>
    void algorithm(T* begin, T* end)
    {
        if (end-begin >= 2)
            exp::swap(begin[0], begin[1]);
    }

}

// simulate user code which includes <algorithm>

struct A
{
};

namespace exp
{
    void swap(A&, A&)
    {
        printf("exp::swap(A, A)\n");
    }

}

// exercise simulation

int main()
{
    A a[2];
    exp::algorithm(a, a+2);
}

Bagi saya ini cetakannya:

generic exp::swap

Jika kompilator Anda mencetak sesuatu yang berbeda maka kompilator tidak menerapkan "pencarian dua fase" untuk template dengan benar.

Jika kompiler Anda sesuai (ke salah satu dari C ++ 98/03/11), maka itu akan memberikan keluaran yang sama yang saya tunjukkan. Dan dalam kasus seperti itu, apa yang Anda takuti akan terjadi, benar-benar terjadi. Dan memasukkan Anda swapke dalam namespace std( exp) tidak menghentikannya terjadi.

Dave dan saya adalah anggota komite dan telah mengerjakan bidang standar ini selama satu dekade (dan tidak selalu sesuai satu sama lain). Tetapi masalah ini telah diselesaikan untuk waktu yang lama, dan kami berdua sepakat tentang cara menyelesaikannya. Abaikan pendapat / jawaban ahli Dave di bidang ini atas risiko Anda sendiri.

Masalah ini terungkap setelah C ++ 98 diterbitkan. Mulai sekitar 2001 Dave dan saya mulai mengerjakan bidang ini . Dan inilah solusi modern:

// simulate <algorithm>

#include <cstdio>

namespace exp
{

    template <class T>
    void
    swap(T& x, T& y)
    {
        printf("generic exp::swap\n");
        T tmp = x;
        x = y;
        y = tmp;
    }

    template <class T>
    void algorithm(T* begin, T* end)
    {
        if (end-begin >= 2)
            swap(begin[0], begin[1]);
    }

}

// simulate user code which includes <algorithm>

struct A
{
};

void swap(A&, A&)
{
    printf("swap(A, A)\n");
}

// exercise simulation

int main()
{
    A a[2];
    exp::algorithm(a, a+2);
}

Outputnya adalah:

swap(A, A)

Memperbarui

Pengamatan telah dilakukan bahwa:

namespace exp
{    
    template <>
    void swap(A&, A&)
    {
        printf("exp::swap(A, A)\n");
    }

}

berhasil! Jadi mengapa tidak menggunakan itu?

Pertimbangkan kasus Anda Aadalah template kelas:

// simulate user code which includes <algorithm>

template <class T>
struct A
{
};

namespace exp
{

    template <class T>
    void swap(A<T>&, A<T>&)
    {
        printf("exp::swap(A, A)\n");
    }

}

// exercise simulation

int main()
{
    A<int> a[2];
    exp::algorithm(a, a+2);
}

Sekarang tidak berfungsi lagi. :-(

Jadi Anda bisa memasukkan swapnamespace std dan membuatnya berfungsi. Tapi Anda harus ingat untuk menempatkan swapdiA 's namespace untuk kasus ketika Anda memiliki template: A<T>. Dan karena kedua kasus akan bekerja jika Anda meletakkan swapdi A's namespace, itu hanya lebih mudah untuk mengingat (dan mengajar orang lain) untuk hanya melakukannya bahwa salah satu cara.

Anda tidak diizinkan (oleh standar C ++) untuk membebani std :: swap, namun Anda secara khusus diizinkan untuk menambahkan spesialisasi template untuk tipe Anda sendiri ke namespace std. Misalnya

namespace std
{
    template<>
    void swap(my_type& lhs, my_type& rhs)
    {
       // ... blah
    }
}

maka penggunaan di std containers (dan di mana pun) akan memilih spesialisasi Anda, bukan yang umum.

Perhatikan juga bahwa menyediakan implementasi kelas dasar swap tidak cukup baik untuk tipe turunan Anda. Misalnya jika sudah

class Base
{
    // ... stuff ...
}
class Derived : public Base
{
    // ... stuff ...
}

namespace std
{
    template<>
    void swap(Base& lha, Base& rhs)
    {
       // ...
    }
}

ini akan berfungsi untuk kelas Basis, tetapi jika Anda mencoba menukar dua objek Turunan, ini akan menggunakan versi generik dari std karena swap templated sama persis (dan ini menghindari masalah hanya menukar bagian 'dasar' dari objek turunan Anda ).

CATATAN: Saya telah memperbarui ini untuk menghapus bit yang salah dari jawaban terakhir saya. D'oh! (terima kasih puetzk dan j_random_hacker untuk menunjukkannya)

Meskipun benar bahwa seseorang seharusnya tidak menambahkan barang ke std :: namespace, menambahkan spesialisasi template untuk tipe yang ditentukan pengguna secara khusus diperbolehkan. Membebani fungsi tidak. Ini adalah perbedaan halus :-)

17.4.3.1/1 Tidak ditentukan untuk program C ++ untuk menambahkan deklarasi atau definisi ke namespace std atau namespace dengan namespace std kecuali ditentukan lain. Sebuah program dapat menambahkan spesialisasi template untuk template perpustakaan standar ke namespace std. Spesialisasi seperti itu (lengkap atau sebagian) dari pustaka standar menghasilkan perilaku yang tidak ditentukan kecuali jika deklarasi bergantung pada nama yang ditentukan pengguna dari tautan eksternal dan kecuali spesialisasi templat memenuhi persyaratan pustaka standar untuk templat asli.

Spesialisasi dari std :: swap akan terlihat seperti ini:

namespace std
{
    template<>
    void swap(myspace::mytype& a, myspace::mytype& b) { ... }
}

Tanpa template <> bit itu akan menjadi overload, yang tidak terdefinisi, bukan spesialisasi, yang diijinkan. @ Wilka menyarankan pendekatan untuk mengubah namespace default dapat bekerja dengan kode pengguna (karena pencarian Koenig lebih memilih versi tanpa namespace) tetapi itu tidak dijamin, dan pada kenyataannya tidak benar-benar seharusnya (implementasi STL harus menggunakan sepenuhnya -qualified std :: swap).

Ada utas di comp.lang.c ++. Yang dimoderasi dengan diskusi panjang tentang topik. Sebagian besar tentang spesialisasi parsial, meskipun (yang saat ini tidak ada cara yang baik untuk melakukannya).