Menggunakan std Namespace

Tampaknya ada pandangan yang berbeda tentang penggunaan 'using' sehubungan dengan namespace std.

Beberapa mengatakan gunakan ' using namespace std', yang lain mengatakan jangan melainkan awalan fungsi std yang akan digunakan dengan ' std::' sementara yang lain mengatakan gunakan sesuatu seperti ini:

using std::string;
using std::cout;
using std::cin;
using std::endl;
using std::vector;

untuk semua fungsi std yang akan digunakan.

Apa pro dan kontra dari masing-masing?

Sebagian besar pengguna C ++ cukup senang membaca std::string, std::vectordll. Faktanya, melihat mentah vectormembuat saya bertanya-tanya apakah ini adalah std::vectordefinisi pengguna atau yang berbeda vector.

Saya selalu menentang penggunaan using namespace std;. Ini mengimpor semua jenis nama ke dalam namespace global dan dapat menyebabkan segala macam ambiguitas yang tidak jelas.

Berikut adalah beberapa pengenal umum yang ada di stdnamespace: count, sort, find, equal, reverse. Memiliki variabel yang disebut lokal countberarti bahwa using namespace stdtidak akan memungkinkan Anda untuk menggunakan countbukan std::count.

Contoh klasik dari konflik nama yang tidak diinginkan adalah seperti berikut ini. Bayangkan Anda seorang pemula dan tidak tahu tentang std::count. Bayangkan Anda menggunakan sesuatu yang lain <algorithm>atau ditarik oleh tajuk yang tampaknya tidak berhubungan.

#include <algorithm>
using namespace std;

int count = 0;

int increment()
{
    return ++count; // error, identifier count is ambiguous
}

Kesalahan biasanya panjang dan tidak bersahabat karena std::countmerupakan template dengan beberapa tipe bersarang yang panjang.

Ini tidak masalah, karena std::countmasuk ke namespace global dan jumlah fungsi menyembunyikannya.

#include <algorithm>
using namespace std;

int increment()
{
    static int count = 0;
    return ++count;
}

Mungkin sedikit mengejutkan, ini tidak masalah. Pengenal yang diimpor ke dalam cakupan deklaratif muncul di ruang nama umum yang melingkupi tempat mereka didefinisikan dan di mana mereka diimpor. Dengan kata lain, std::countterlihat seperti countpada namespace global, tetapi hanya di dalam increment.

#include <algorithm>

int increment()
{
    using namespace std;
    static int count = 0;
    return ++count;
}

Dan untuk alasan serupa, countambigu di sini. using namespace stdtidak menyebabkan std::count, sembunyikan bagian luar countseperti yang diharapkan. The using namespaceAturan berarti bahwa std::countpenampilan (dalam incrementfungsi) seolah-olah itu dideklarasikan di lingkup global, yaitu pada ruang lingkup yang sama seperti int count = 0;dan karenanya menyebabkan ambiguitas.

#include <algorithm>

int count = 0;

int increment()
{
    using namespace std;
    return ++count; // error ambiguous
}

Mengecualikan dasar-dasar (Harus menambahkan std :: infront dari semua objek / fungsi stl dan lebih sedikit kemungkinan konflik jika Anda tidak memiliki 'using namespace std')

Perlu juga dicatat bahwa Anda tidak boleh menaruh

using namespace std

Dalam file header, karena file header dapat menyebar ke semua file yang menyertakan file header tersebut, meskipun mereka tidak ingin menggunakan namespace tersebut.

Dalam beberapa kasus, sangat bermanfaat untuk menggunakan hal-hal seperti

using std::swap

Seolah-olah ada versi swap khusus, kompiler akan menggunakannya, jika tidak maka akan kembali aktif std::swap.

Jika Anda menelepon std::swap, Anda selalu menggunakan versi dasar, yang tidak akan memanggil versi yang dioptimalkan (jika ada).

Pertama, beberapa terminologi:

• menggunakan-deklarasi : using std::vector;
• menggunakan-direktif : using namespace std;

Saya pikir menggunakan direktif penggunaan baik-baik saja, selama mereka tidak digunakan pada lingkup global di file header. Jadi memiliki

using namespace std;

dalam file .cpp Anda sebenarnya tidak menjadi masalah, dan jika ternyata, itu sepenuhnya di bawah kendali Anda (dan bahkan dapat dicakup ke blok tertentu jika diinginkan). Saya tidak melihat alasan partiklar untuk mengacaukan kode dengan banyak std::kualifikasi - itu hanya menjadi sekumpulan gangguan visual. Namun, jika Anda tidak menggunakan sejumlah besar nama dari stdnamespace di kode Anda, saya juga melihat tidak ada masalah dengan meninggalkan arahan. Ini tautologi - jika arahan tidak diperlukan, maka tidak perlu menggunakannya.

Demikian pula, jika Anda bisa bertahan dengan beberapa menggunakan-deklarasi (daripada menggunakan-direktif ) untuk tipe spesifik di stdnamespace, maka tidak ada alasan Anda tidak boleh hanya membawa nama-nama spesifik itu ke namespace saat ini. Dengan cara yang sama, saya pikir itu akan menjadi gila dan kerumitan pembukuan untuk memiliki 25 atau 30 deklarasi penggunaan ketika satu petunjuk penggunaan akan melakukan trik dengan baik.

Juga baik untuk diingat bahwa ada kalanya Anda harus menggunakan deklarasi menggunakan. Lihat "Item 25: Pertimbangkan dukungan untuk pertukaran non-lempar" Scott Meyers dari Effective C ++, Edisi Ketiga. Untuk memiliki fungsi generik dan templated menggunakan metode swap 'terbaik' untuk tipe berparameter, Anda perlu menggunakan pencarian yang bergantung pada deklarasi penggunaan dan argumen (alias pencarian ADL atau Koenig):

template< typename T >
void foo( T& x, T& y)
{
    using std::swap;     // makes std::swap available in this function

    // do stuff...

    swap( x, y);         // will use a T-specific swap() if it exists,
                         //  otherwise will use std::swap<T>()

    // ...
 }

Saya pikir kita harus melihat idiom umum untuk berbagai bahasa yang menggunakan ruang nama secara signifikan. Misalnya, Java dan C # menggunakan banyak ruang nama (bisa dibilang lebih dari C ++). Cara yang paling umum digunakan dalam namespace dalam bahasa tersebut adalah dengan membawanya ke ruang lingkup saat ini secara massal dengan ekuivalen menggunakan direktif. Hal ini tidak menyebabkan masalah yang tersebar luas, dan beberapa kali masalah tersebut ditangani dengan basis 'pengecualian' dengan menangani nama yang dimaksud melalui nama yang sepenuhnya memenuhi syarat atau dengan aliasing - seperti yang dapat dilakukan di C ++.

Herb Sutter dan Andrei Alexandrescu mengatakan ini di "Item 59: Jangan tulis penggunaan namespace di file header atau sebelum #include" pada buku mereka, C ++ Coding Standards: 101 Rules, Guidelines, dan Best Practices:

Singkatnya: Anda dapat dan harus menggunakan namespace menggunakan deklarasi dan arahan secara bebas dalam file implementasi Anda setelah #includearahan dan merasa nyaman karenanya. Meskipun pernyataan berulang yang bertentangan, namespace yang menggunakan deklarasi dan arahan tidak jahat dan tidak mengalahkan tujuan namespace. Sebaliknya, itulah yang membuat namespace dapat digunakan.

Stroupstrup sering dikutip mengatakan, "Jangan mencemari namespace global", dalam "Bahasa Pemrograman C ++, Edisi Ketiga". Dia sebenarnya mengatakan itu (C.14 [15]), tetapi mengacu pada bab C.10.1 di mana dia mengatakan:

Sebuah menggunakan-deklarasi menambahkan nama untuk lingkup lokal. A using-directive tidak; itu hanya membuat nama dapat diakses dalam cakupan di mana mereka dideklarasikan. Sebagai contoh:

namespaceX {
    int i , j , k ;
}

int k ;
void f1()
{
    int i = 0 ;

    using namespaceX ; // make names from X accessible

    i++; // local i
    j++; // X::j
    k++; // error: X::k or global k ?

    ::k ++; // the global k

    X::k ++; // X’s k
}

void f2()
{
    int i = 0 ;

    using X::i ; // error: i declared twice in f2()
    using X::j ;
    using X::k ; // hides global k

    i++;
    j++; // X::j
    k++; // X::k
}

Nama yang dideklarasikan secara lokal (dideklarasikan dengan deklarasi biasa atau dengan deklarasi menggunakan) menyembunyikan deklarasi nonlokal dengan nama yang sama, dan setiap overloading ilegal dari nama tersebut terdeteksi pada titik deklarasi.

Perhatikan kesalahan ambiguitas untuk k++dalam f1(). Nama global tidak lebih diutamakan daripada nama dari namespace yang dapat diakses dalam lingkup global. Hal ini memberikan perlindungan yang signifikan terhadap benturan nama yang tidak disengaja, dan - yang terpenting - memastikan bahwa tidak ada keuntungan yang bisa diperoleh dari pencemaran namespace global.

Saat library yang mendeklarasikan banyak nama dibuat dapat diakses melalui using-directives, ada keuntungan signifikan bahwa benturan nama yang tidak digunakan tidak dianggap sebagai error.

...

Saya berharap melihat penurunan drastis dalam penggunaan nama global dalam program baru yang menggunakan ruang nama dibandingkan dengan program C dan C ++ tradisional. Aturan untuk namespace secara khusus dibuat untuk tidak memberikan keuntungan bagi pengguna nama global yang '' malas '' dibandingkan seseorang yang berhati-hati untuk tidak mencemari cakupan global.

Dan bagaimana seseorang memiliki keuntungan yang sama sebagai 'pengguna malas nama global'? Dengan memanfaatkan arahan using, yang dengan aman membuat nama di namespace tersedia untuk cakupan saat ini.

Perhatikan bahwa ada perbedaan - nama dalam stdnamespace yang tersedia untuk cakupan dengan penggunaan yang tepat dari direktif penggunaan (dengan menempatkan direktif setelah #includes) tidak mencemari namespace global. Itu hanya membuat nama-nama itu tersedia dengan mudah, dan dengan perlindungan berkelanjutan terhadap bentrokan.

Jangan pernah menggunakan menggunakan namespace pada lingkup global dalam file header. Itu dapat menyebabkan konflik dan orang yang bertanggung jawab atas file tempat konflik muncul tidak memiliki kendali atas penyebabnya.

Dalam file implementasi, pilihan dipotong jauh lebih baik.

• Menempatkan menggunakan namespace std membawa semua simbol dari namespace itu. Ini bisa merepotkan karena hampir tidak ada badan yang mengetahui semua simbol yang ada di sana (sehingga memiliki kebijakan tanpa konflik tidak mungkin diterapkan dalam praktiknya) tanpa membicarakan simbol yang akan ditambahkan. Dan standar C ++ memungkinkan sebuah header untuk menambahkan simbol dari header lain (yang C tidak mengizinkannya). Ini masih dapat bekerja dengan baik dalam praktiknya untuk menyederhanakan penulisan dalam kasus terkontrol. Dan jika terjadi kesalahan, itu terdeteksi di file yang bermasalah.

• Menggunakan std :: name; memiliki keuntungan dari kesederhanaan penulisan tanpa risiko mengimpor simbol yang tidak dikenal. Biayanya adalah Anda harus mengimpor secara eksplisit semua simbol yang diinginkan.

• Kualifikasi secara eksplisit menambah sedikit kekacauan, tetapi saya pikir itu adalah sedikit masalah dalam beberapa latihan.

Dalam proyek saya, saya menggunakan kualifikasi eksplisit untuk semua nama, saya menerima menggunakan std :: name, saya melawan penggunaan namespace std (kami memiliki juru bahasa lisp yang memiliki jenis daftar sendiri dan konflik adalah hal yang pasti).

Untuk ruang nama lain, Anda juga harus mempertimbangkan konvensi penamaan yang digunakan. Saya mengetahui sebuah proyek yang menggunakan namespace (untuk pembuatan versi) dan awalan pada nama. Melakukan using namespace Xkemudian hampir tanpa risiko dan tidak melakukannya mengarah ke kode yang terlihat bodoh PrefixNS::pfxMyFunction(...).

Ada beberapa kasus di mana Anda ingin mengimpor simbol. std :: swap adalah kasus yang paling umum: Anda mengimpor std :: swap dan kemudian menggunakan swap tidak memenuhi syarat. Pencarian yang bergantung pada argumen akan menemukan swap yang memadai di namespace dari jenis tersebut jika ada dan kembali ke template standar jika tidak ada.

Edit:

Dalam komentarnya, Michael Burr bertanya-tanya apakah konflik itu terjadi di dunia nyata. Ini adalah contoh langsung yang nyata. Kami memiliki bahasa ekstensi dengan dialek cadel. Penerjemah kami memiliki file include, lisp.h yang berisi

typedef struct list {} list;

Kami harus mengintegrasikan dan menyesuaikan beberapa kode (yang akan saya beri nama "mesin") yang terlihat seperti ini:

#include <list>
...
using std::list;
...
void foo(list const&) {}

Jadi kami memodifikasi seperti ini:

#include <list>

#include "module.h"
...
using std::list;
...
void foo(list const&) {}

Baik. Semuanya bekerja. Beberapa bulan kemudian, "module.h" diubah menjadi "list.h". Tes lulus. "modul" tidak dimodifikasi sedemikian rupa sehingga mempengaruhi ABI-nya, jadi pustaka "engine" dapat digunakan tanpa mengompilasi ulang penggunanya. Tes integrasi baik-baik saja. "Modul" baru diterbitkan. Kompilasi mesin berikutnya rusak ketika kodenya belum dimodifikasi.

Jika Anda tidak memiliki risiko konflik nama dalam kode Anda dengan std dan pustaka lain, Anda dapat menggunakan:

using namespace std;

Tetapi jika Anda ingin mengetahui dengan tepat ketergantungan kode Anda untuk dokumentasi atau ada risiko konflik nama gunakan cara lain:

using std::string;
using std::cout;

Solusi ketiga, jangan gunakan solusi ini dan tulis std :: sebelum setiap penggunaan dalam kode memberi Anda lebih banyak keamanan tetapi, mungkin sedikit beban dalam kode ...

Kedua

using std::string;

dan

using namespace std;

tambahkan beberapa simbol (satu atau banyak) ke namespace global. Dan menambahkan simbol ke namespace global adalah sesuatu yang tidak boleh Anda lakukan di file header. Anda tidak memiliki kontrol siapa yang akan menyertakan header Anda, ada banyak header yang menyertakan header lain (dan header yang menyertakan header yang menyertakan header dan sebagainya ...).

Dalam implementasi file (.cpp) itu terserah Anda (hanya ingat untuk melakukannya setelah semua perintah #include). Anda hanya dapat memecahkan kode dalam file khusus ini, jadi lebih mudah untuk mengelola dan mencari tahu alasan konflik nama. Jika Anda lebih suka menggunakan std :: (atau prefiks lainnya, mungkin terdapat banyak namespace dalam proyek Anda) sebelum indentifiers, tidak apa-apa. Jika Anda ingin menambahkan pengenal yang Anda gunakan ke namespace global, tidak apa-apa. Jika Anda ingin membawa seluruh namespace di kepala Anda :-), terserah Anda. Meskipun efeknya terbatas pada unit kompilasi tunggal, itu dapat diterima.

Bagi saya, saya lebih suka menggunakan ::bila memungkinkan.

std::list<int> iList;

Saya benci menulis:

for(std::list<int>::iterator i = iList.begin(); i != iList.end(); i++)
{
    //
}

Mudah-mudahan, dengan C ++ 0x saya akan menulis ini:

for(auto i = iList.begin(); i != iList.end(); i++)
{
    //
}

Jika namespace sangat panjang,

namespace dir = boost::filesystem;

dir::directory_iterator file("e:/boost");
dir::directory_iterator end;

for( ; file != end; file++)
{
    if(dir::is_directory(*file))
        std::cout << *file << std::endl;
}

Anda tidak boleh berada using namespace stddi cakupan namespace di header. Juga, saya kira sebagian besar programmer akan bertanya-tanya kapan mereka melihat vectoratau stringtidak std::, jadi menurut saya tidak using namespace stdlebih baik. Oleh karena itu saya berdebat untuk tidak pernah menjadi using namespace stdsama sekali.

Jika Anda merasa harus, tambahkan deklarasi penggunaan lokal seperti using std::vector. Tetapi tanyakan pada diri Anda: Berapa harga ini? Sebaris kode ditulis sekali (mungkin dua kali), tetapi dibaca sepuluh, seratus atau ribuan kali. Upaya pengetikan yang disimpan dengan menambahkan deklarasi atau petunjuk penggunaan adalah marjinal dibandingkan dengan upaya membaca kode.

Dengan pemikiran tersebut, dalam sebuah proyek sepuluh tahun lalu kami memutuskan untuk secara eksplisit memenuhi syarat semua pengenal dengan nama namespace lengkap mereka. Apa yang tampak canggung pada awalnya menjadi rutinitas dalam dua minggu. Sekarang, di semua proyek di seluruh perusahaan tidak ada lagi yang menggunakan arahan atau deklarasi. (Dengan satu pengecualian, lihat di bawah.) Melihat kode (beberapa MLoC) setelah sepuluh tahun, saya merasa kami telah membuat keputusan yang tepat.

Saya menemukan bahwa biasanya, mereka yang menentang pelarangan usingbiasanya belum mencobanya untuk satu proyek. Mereka yang telah mencoba, seringkali merasa lebih baik daripada menggunakan arahan / deklarasi setelah waktu yang sangat singkat.

Catatan: Satu-satunya pengecualian adalah using std::swapyang diperlukan (terutama dalam kode generik) untuk mengambil kelebihan beban swap()yang tidak dapat dimasukkan ke dalam stdnamespace (karena kami tidak diizinkan untuk meletakkan kelebihan stdfungsi ke dalam namespace ini).

Namespaces menyimpan kode untuk mencegah kebingungan dan polusi tanda tangan fungsi.

Berikut demo lengkap dan terdokumentasi tentang penggunaan namespace yang benar :

#include <iostream>
#include <cmath>  // Uses ::log, which would be the log() here if it were not in a namespace, see /programming/11892976/why-is-my-log-in-the-std-namespace

// Silently overrides std::log
//double log(double d) { return 420; }

namespace uniquename {
    using namespace std;  // So we don't have to waste space on std:: when not needed.

    double log(double d) {
        return 42;
    }

    int main() {
        cout << "Our log: " << log(4.2) << endl;
        cout << "Standard log: " << std::log(4.2);
        return 0;
    }
}

// Global wrapper for our contained code.
int main() {
    return uniquename::main();
}

Keluaran:

Our log: 42
Standard log: 1.43508

using namespace stdmengimpor konten stdnamespace saat ini. Jadi, keuntungannya adalah Anda tidak perlu mengetik std::di depan semua fungsi namespace itu. Namun, mungkin saja Anda memiliki ruang nama berbeda yang memiliki fungsi dengan nama yang sama. Jadi, Anda mungkin tidak akan menelepon yang Anda inginkan.

Menentukan secara manual mana yang ingin Anda impor stdmencegah hal itu terjadi, tetapi dapat mengakibatkan daftar panjang penggunaan di awal file Anda, yang menurut beberapa pengembang akan jelek;)!

Secara pribadi, saya lebih suka menentukan namespace setiap kali saya menggunakan fungsi, kecuali jika namespace terlalu panjang, dalam hal ini saya menggunakan beberapa di awal file.

EDIT: seperti yang dicatat dalam jawaban lain, Anda tidak boleh memasukkan using namespacefile header, karena ini akan menyebar ke semua file termasuk header ini dan dengan demikian dapat menghasilkan perilaku yang tidak diinginkan.

EDIT2: mengoreksi jawaban saya, terima kasih kepada komentar Charles.

Sama seperti di Java di mana Anda dapat menggunakan salah satunya dapat menyertakan java.util. * Atau cukup memilih setiap kelas satu per satu, itu tergantung gayanya. Perhatikan bahwa Anda tidak menginginkannya using namespace stddi awal file / cakupan lebar karena Anda akan mencemari namespace dan mungkin mengalami bentrok, mengalahkan titik namespace. Tetapi jika Anda memiliki fungsi yang menggunakan banyak STL, itu mengacaukan kode untuk memiliki campuran sintaks prefiks dalam logika Anda dan Anda mungkin harus mempertimbangkan untuk menggunakan baik using namespace std(saat menggunakan berbagai kelas) atau individu using(saat menggunakan beberapa kelas sering).

Diskusi ini akan aktif selama IDE yang Anda gunakan tidak cukup fleksibel untuk menampilkan atau menyembunyikan informasi persis yang Anda butuhkan.

Itu karena tampilan kode yang Anda inginkan bergantung pada tugas yang ada.

Saat membuat kode sumber, saya lebih suka melihat dengan tepat kelas mana yang saya gunakan: apakah itu std::string, atau BuzFlox::Obs::stringkelasnya?

Saat mendesain aliran kontrol, saya bahkan tidak tertarik pada jenis variabel, tapi saya ingin fokus pada if's dan while' dan continue's.

Jadi ini saran saya:

Bergantung pada audiens kode Anda dan kekuatan alat Anda, pilih cara yang paling mudah dibaca, atau memberikan sebagian besar informasi.

Ada beberapa cara untuk memperbaikinya.

Pertama: gunakan seperti yang Anda lakukan.

Kedua: lakukan namespace S = std;, kurangi 2 karakter.

Ketiga: gunakan static.

Keempat: jangan gunakan nama yang stdmenggunakan.

Apa pro dan kontra dari masing-masing

Satu-satunya alasan untuk meninggalkan std :: adalah bahwa Anda dapat, secara teori, menerapkan ulang semua fungsi STL sendiri. Kemudian fungsi Anda dapat dialihkan dari menggunakan std :: vector ke my :: vector tanpa mengubah kode.

Mengapa tidak misalnya

typedef std::vector<int> ints_t;
ints_t ints1;
....
ints_t ints2;

bukannya yang berat

std::vector<int> ints1;
...
std::vector<int> ints2;

Saya merasa jauh lebih mudah dibaca dan ini adalah standar saya untuk pengkodean.

Anda bahkan dapat menggunakannya untuk memasukkan beberapa informasi semantik untuk pembaca. Misalnya, pertimbangkan prototipe fungsi

void getHistorgram(std::vector<unsigned int>&, std::vector<unsigned int>&);

yang mana nilai kembaliannya?

Bagaimana sebaliknya

typedef std::vector<unsigned int> values_t;
typedef std::vector<unsigned int> histogram_t;
...
void getHistogram(values_t&, histogram_t&);