Mengapa ruang nama yang tidak disebutkan namanya digunakan dan apa manfaatnya?

Saya baru saja bergabung dengan proyek perangkat lunak C ++ baru dan saya mencoba memahami desainnya. Proyek ini sering menggunakan ruang nama yang tidak disebutkan namanya. Misalnya, sesuatu seperti ini dapat terjadi di file definisi kelas:

// newusertype.cc
namespace {
  const int SIZE_OF_ARRAY_X;
  const int SIZE_OF_ARRAY_Y;
  bool getState(userType*,otherUserType*);
}

newusertype::newusertype(...) {...

Apa pertimbangan desain yang mungkin menyebabkan seseorang menggunakan namespace yang tidak disebutkan namanya? Apa kelebihan dan kekurangannya?

Ruang nama tanpa nama adalah utilitas untuk menjadikan unit terjemahan pengidentifikasi lokal. Mereka berperilaku seolah-olah Anda akan memilih nama unik per unit terjemahan untuk namespace:

namespace unique { /* empty */ }
using namespace unique;
namespace unique { /* namespace body. stuff in here */ }

Langkah ekstra menggunakan tubuh kosong itu penting, jadi Anda sudah bisa merujuk di dalam tubuh namespace ke pengidentifikasi seperti ::nameyang didefinisikan dalam namespace itu, karena direktif penggunaan sudah terjadi.

Ini berarti Anda dapat memiliki fungsi gratis yang disebut (misalnya) helpyang dapat ada di beberapa unit terjemahan, dan mereka tidak akan berbenturan pada waktu tautan. Efeknya hampir identik dengan menggunakan statickata kunci yang digunakan dalam C yang dapat Anda masukkan ke dalam deklarasi pengidentifikasi. Ruang nama yang tidak disebutkan namanya adalah alternatif yang unggul, bahkan dapat membuat unit terjemahan jenis lokal.

namespace { int a1; }
static int a2;

Keduanya aadalah unit terjemahan lokal dan tidak akan berbenturan pada waktu tautan. Tetapi perbedaannya adalah bahwa a1dalam namespace anonim mendapatkan nama yang unik.

Baca artikel yang bagus di Comeau-Computing Mengapa namespace tanpa nama digunakan sebagai ganti statik? ( Archive.org mirror ).

Memiliki sesuatu dalam namespace anonim berarti itu lokal untuk unit terjemahan ini (file .cpp dan semua termasuk) ini berarti bahwa jika simbol lain dengan nama yang sama didefinisikan di tempat lain tidak akan ada pelanggaran Aturan Definisi Satu (ODR).

Ini sama dengan cara C memiliki variabel global statis atau fungsi statis tetapi dapat digunakan untuk definisi kelas juga (dan harus digunakan daripada staticdi C ++).

Semua ruang nama anonim dalam file yang sama diperlakukan sebagai ruang nama yang sama dan semua ruang nama anonim dalam file yang berbeda berbeda. Namespace anonim sama dengan:

namespace __unique_compiler_generated_identifer0x42 {
    ...
}
using namespace __unique_compiler_generated_identifer0x42;

Namespace yang tidak disebutkan namanya membatasi akses kelas, variabel, fungsi dan objek ke file yang didefinisikan. Fungsionalitas namespace yang tidak disebutkan namanya mirip dengan statickata kunci dalam C / C ++.
statickata kunci membatasi akses variabel global dan fungsi ke file di mana mereka didefinisikan.
Ada perbedaan antara namespace tanpa nama dan statickata kunci karena namespace yang tidak disebutkan namanya memiliki keunggulan dibandingkan statis. statickata kunci dapat digunakan dengan variabel, fungsi dan objek tetapi tidak dengan kelas yang ditentukan pengguna.
Sebagai contoh:

static int x;  // Correct 

Tapi,

static class xyz {/*Body of class*/} //Wrong
static structure {/*Body of structure*/} //Wrong

Tetapi hal yang sama bisa terjadi dengan namespace yang tidak disebutkan namanya. Sebagai contoh,

 namespace {
           class xyz {/*Body of class*/}
           static structure {/*Body of structure*/}
  } //Correct

Selain jawaban lain untuk pertanyaan ini, menggunakan namespace anonim juga dapat meningkatkan kinerja. Karena simbol dalam namespace tidak memerlukan tautan eksternal, kompiler lebih bebas untuk melakukan optimasi kode secara agresif dalam namespace. Sebagai contoh, suatu fungsi yang disebut beberapa kali satu kali dalam satu lingkaran dapat digarisbawahi tanpa berdampak pada ukuran kode.

Sebagai contoh, pada sistem saya kode berikut ini memakan waktu sekitar 70% dari waktu berjalan jika namespace anonim digunakan (x86-64 gcc-4.6.3 dan -O2; perhatikan bahwa kode tambahan di add_val membuat kompiler tidak mau memasukkan dua kali).

#include <iostream>

namespace {
  double a;
  void b(double x)
  {
    a -= x;
  }
  void add_val(double x)
  {
    a += x;
    if(x==0.01) b(0);
    if(x==0.02) b(0.6);
    if(x==0.03) b(-0.1);
    if(x==0.04) b(0.4);
  }
}

int main()
{
  a = 0;
  for(int i=0; i<1000000000; ++i)
    {
      add_val(i*1e-10);
    }
  std::cout << a << '\n';
  return 0;
}

Contoh tersebut menunjukkan bahwa orang-orang di proyek yang Anda ikuti tidak memahami ruang nama anonim :)

namespace {
    const int SIZE_OF_ARRAY_X;
    const int SIZE_OF_ARRAY_Y;

Ini tidak perlu berada dalam namespace anonim, karena constobjek sudah memiliki hubungan statis dan karenanya tidak mungkin bertentangan dengan pengidentifikasi dari nama yang sama di unit terjemahan lain.

    bool getState(userType*,otherUserType*);
}

Dan ini sebenarnya pesimis: getState()memiliki hubungan eksternal. Biasanya lebih baik untuk memilih tautan statis, karena itu tidak mencemari tabel simbol. Lebih baik menulis

static bool getState(/*...*/);

sini. Saya jatuh ke dalam perangkap yang sama (ada kata-kata dalam standar yang menunjukkan bahwa file-statika entah bagaimana sudah ditinggalkan dalam mendukung ruang nama anonim), tetapi bekerja di proyek C ++ besar seperti KDE, Anda mendapatkan banyak orang yang memutar kepala Anda dengan cara yang benar berkeliling lagi :)

Namespace anonim membuat variabel terlampir, fungsi, kelas, dll. Hanya tersedia di dalam file itu. Dalam contoh Anda ini adalah cara untuk menghindari variabel global. Tidak ada perbedaan kinerja waktu runtime atau kompilasi.

Tidak ada banyak keuntungan atau kerugian selain dari "apakah saya ingin variabel, fungsi, kelas, dll ini menjadi publik atau pribadi?"