const static int foo = 42;

Saya melihat ini di beberapa kode di sini di StackOverflow dan saya tidak tahu apa fungsinya. Kemudian saya melihat beberapa jawaban yang membingungkan di forum lain. Tebakan terbaik saya adalah bahwa ini digunakan di C untuk menyembunyikan konstanta foodari modul lain. Apakah ini benar? Jika demikian, mengapa ada orang yang menggunakannya dalam konteks C ++ di mana Anda bisa membuatnya private?

Ini memiliki kegunaan di C dan C ++.

Seperti yang Anda duga, staticbagian tersebut membatasi cakupannya pada unit kompilasi tersebut . Ini juga menyediakan inisialisasi statis. consthanya memberitahu kompilator untuk tidak membiarkan siapa pun memodifikasinya. Variabel ini diletakkan di segmen data atau bss tergantung pada arsitekturnya, dan mungkin berada dalam memori bertanda hanya-baca.

Semua itu adalah bagaimana C memperlakukan variabel ini (atau bagaimana C ++ memperlakukan variabel namespace). Di C ++, anggota yang ditandai staticdibagikan oleh semua instance kelas tertentu. Entah itu privat atau tidak, tidak memengaruhi fakta bahwa satu variabel digunakan bersama oleh banyak contoh. Setelah constdi sana akan memperingatkan Anda jika ada kode yang mencoba memodifikasi itu.

Jika itu benar-benar pribadi, maka setiap instance kelas akan mendapatkan versinya sendiri (terlepas dari pengoptimal).

Banyak orang memberikan jawaban dasar tetapi tidak ada yang menunjukkan bahwa dalam C ++ constdefault staticpada namespacetingkat (dan beberapa memberikan informasi yang salah). Lihat standar C ++ 98 bagian 3.5.3.

Pertama beberapa latar belakang:

Unit terjemahan: File sumber setelah pra-prosesor (secara rekursif) menyertakan semua file yang disertakan.

Kaitan statis: Simbol hanya tersedia di dalam unit terjemahannya.

Keterkaitan eksternal: Simbol tersedia dari unit terjemahan lain.

Di namespacelevel

Ini termasuk namespace global alias variabel global .

static const int sci = 0; // sci is explicitly static
const int ci = 1;         // ci is implicitly static
extern const int eci = 2; // eci is explicitly extern
extern int ei = 3;        // ei is explicitly extern
int i = 4;                // i is implicitly extern
static int si = 5;        // si is explicitly static

Di tingkat fungsi

staticberarti nilainya dipertahankan di antara panggilan fungsi.
Semantik staticvariabel fungsi mirip dengan variabel global karena berada di segmen data program (dan bukan tumpukan atau tumpukan), lihat pertanyaan ini untuk detail selengkapnya tentang staticmasa pakai variabel.

Di classlevel

staticartinya nilai tersebut dibagi antara semua instance kelas dan constartinya tidak berubah.

Baris kode tersebut sebenarnya dapat muncul dalam beberapa konteks berbeda dan meskipun perilakunya kira-kira sama, ada perbedaan kecil.

Cakupan Namespace

// foo.h
static const int i = 0;

' i' akan terlihat di setiap unit terjemahan yang menyertakan tajuk. Namun, kecuali Anda benar-benar menggunakan alamat objek (misalnya. ' &i'), Saya cukup yakin bahwa kompilator akan memperlakukan ' i' hanya sebagai tipe aman 0. Jika dua unit terjemahan lagi menggunakan ' &i' maka alamatnya akan berbeda untuk setiap unit terjemahan.

// foo.cc
static const int i = 0;

' i' memiliki hubungan internal, sehingga tidak dapat dirujuk dari luar unit terjemahan ini. Namun, sekali lagi kecuali Anda menggunakan alamatnya, kemungkinan besar akan diperlakukan sebagai tipe-aman 0.

Satu hal yang perlu diperhatikan, adalah pernyataan berikut:

const int i1 = 0;

adalah persis sama dengan static const int i = 0. Variabel dalam namespace yang dideklarasikan dengan constdan tidak secara eksplisit dideklarasikan dengan externstatis secara implisit. Jika Anda memikirkan hal ini, komite C ++ bermaksud untuk mengizinkan constvariabel dideklarasikan dalam file header tanpa selalu memerlukan statickata kunci untuk menghindari kerusakan ODR.

Ruang Lingkup Kelas

class A {
public:
  static const int i = 0;
};

Dalam contoh di atas, standar secara eksplisit menetapkan bahwa ' i' tidak perlu ditentukan jika alamatnya tidak diperlukan. Dengan kata lain jika Anda hanya menggunakan ' i' sebagai tipe-aman 0 maka kompilator tidak akan mendefinisikannya. Satu perbedaan antara versi kelas dan namespace adalah bahwa alamat ' i' (jika digunakan dalam dua atau lebih unit terjemahan) akan sama untuk anggota kelas. Jika alamat digunakan, Anda harus memiliki definisinya:

// a.h
class A {
public:
  static const int i = 0;
};

// a.cc
#include "a.h"
const int A::i;            // Definition so that we can take the address

Ini adalah pengoptimalan ruang kecil.

Saat Anda berkata

const int foo = 42;

Anda tidak mendefinisikan sebuah konstanta, tetapi membuat variabel hanya-baca. Kompilator cukup pintar untuk menggunakan 42 setiap kali ia melihat foo, tetapi ia juga akan mengalokasikan ruang di area data yang diinisialisasi untuknya. Ini dilakukan karena, sebagaimana didefinisikan, foo memiliki keterkaitan eksternal. Unit kompilasi lain dapat mengatakan:

extern const int foo;

Untuk mendapatkan akses ke nilainya. Itu bukan praktik yang baik karena unit kompilasi itu tidak tahu apa nilai foo. Itu hanya tahu itu adalah const int dan harus memuat ulang nilai dari memori setiap kali digunakan.

Sekarang, dengan menyatakan bahwa itu statis:

static const int foo = 42;

Kompilator dapat melakukan pengoptimalan seperti biasa, tetapi ia juga dapat berkata "hei, tidak ada orang di luar unit kompilasi ini yang dapat melihat foo dan saya tahu selalu 42 sehingga tidak perlu mengalokasikan ruang untuk itu."

Saya juga harus mencatat bahwa di C ++, cara yang disukai untuk mencegah nama keluar dari unit kompilasi saat ini adalah dengan menggunakan namespace anonim:

namespace {
    const int foo = 42; // same as static definition above
}

Ini kehilangan 'int'. Harus:

const static int foo = 42;

Di C dan C ++, ia mendeklarasikan konstanta integer dengan cakupan file lokal bernilai 42.

Mengapa 42? Jika Anda belum mengetahuinya (dan sulit dipercaya bahwa Anda belum mengetahuinya), ini merujuk pada Jawaban atas Kehidupan, Semesta, dan Segalanya .

Di C ++,

static const int foo = 42;

adalah cara yang lebih disukai untuk mendefinisikan & menggunakan konstanta. Yaitu menggunakan ini daripada

#define foo 42

karena tidak merusak sistem keamanan tipe.

Untuk semua jawaban hebat, saya ingin menambahkan detail kecil:

Jika Anda menulis plugin (mis. DLL atau pustaka .so untuk dimuat oleh sistem CAD), maka statis adalah penyelamat yang menghindari benturan nama seperti ini:

1. Sistem CAD memuat plugin A, yang memiliki "const int foo = 42;" di dalamnya.
2. Sistem memuat plugin B, yang memiliki "const int foo = 23;" di dalamnya.
3. Hasilnya, plugin B akan menggunakan nilai 42 untuk foo, karena plugin loader akan menyadari, bahwa sudah ada "foo" dengan external linkage.

Lebih buruk lagi: Langkah 3 mungkin berperilaku berbeda tergantung pada pengoptimalan kompiler, mekanisme pemuatan plugin, dll.

Saya mengalami masalah ini sekali dengan dua fungsi pembantu (nama yang sama, perilaku berbeda) di dua plugin. Mendeklarasikan mereka statis memecahkan masalah.

Menurut spesifikasi C99 / GNU99:

• static

  • adalah penentu kelas penyimpanan

  • objek lingkup tingkat file secara default memiliki hubungan eksternal

  • objek lingkup tingkat file dengan penentu statis memiliki hubungan internal

• const

  • adalah type-qualifier (merupakan bagian dari type)

  • Kata kunci diterapkan ke contoh kiri langsung - yaitu

    • MyObj const * myVar; - penunjuk yang tidak memenuhi syarat ke tipe objek yang memenuhi syarat

    • MyObj * const myVar; - const pointer yang memenuhi syarat ke tipe objek yang tidak memenuhi syarat

  • Penggunaan paling kiri - diterapkan pada tipe objek, bukan variabel

    • const MyObj * myVar; - penunjuk yang tidak memenuhi syarat ke tipe objek yang memenuhi syarat

JADI:

static NSString * const myVar; - penunjuk konstan ke string yang tidak dapat diubah dengan hubungan internal.

Tidak adanya statickata kunci akan membuat nama variabel menjadi global dan dapat menyebabkan konflik nama dalam aplikasi.

inlineVariabel C ++ 17

Jika Anda mencari "C ++ const static" di Google, kemungkinan besar yang benar-benar ingin Anda gunakan adalah variabel inline C ++ 17 .

Fitur C ++ 17 yang luar biasa ini memungkinkan kita untuk:

• dengan mudah gunakan hanya satu alamat memori untuk setiap konstanta
• simpan sebagai constexpr: Bagaimana cara mendeklarasikan constexpr extern?
• lakukan dalam satu baris dari satu header

main.cpp

#include <cassert>

#include "notmain.hpp"

int main() {
    // Both files see the same memory address.
    assert(&notmain_i == notmain_func());
    assert(notmain_i == 42);
}

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

inline constexpr int notmain_i = 42;

const int* notmain_func();

#endif

notmain.cpp

#include "notmain.hpp"

const int* notmain_func() {
    return &notmain_i;
}

Kompilasi dan jalankan:

g++ -c -o notmain.o -std=c++17 -Wall -Wextra -pedantic notmain.cpp
g++ -c -o main.o -std=c++17 -Wall -Wextra -pedantic main.cpp
g++ -o main -std=c++17 -Wall -Wextra -pedantic main.o notmain.o
./main

GitHub upstream .

Lihat juga: Bagaimana cara kerja variabel sebaris?

Standar C ++ pada variabel sebaris

Standar C ++ menjamin bahwa alamatnya akan sama. C ++ 17 N4659 standard draft 10.1.6 "The inline specifier":

6 Fungsi atau variabel sebaris dengan hubungan eksternal harus memiliki alamat yang sama di semua unit terjemahan.

cppreference https://en.cppreference.com/w/cpp/language/inline menjelaskan bahwa jika statictidak diberikan, maka ia memiliki tautan eksternal.

Penerapan variabel sebaris GCC

Kita dapat mengamati bagaimana ini diterapkan dengan:

nm main.o notmain.o

yang mengandung:

main.o:
                 U _GLOBAL_OFFSET_TABLE_
                 U _Z12notmain_funcv
0000000000000028 r _ZZ4mainE19__PRETTY_FUNCTION__
                 U __assert_fail
0000000000000000 T main
0000000000000000 u notmain_i

notmain.o:
0000000000000000 T _Z12notmain_funcv
0000000000000000 u notmain_i

dan man nmmengatakan tentang u:

"u" Simbolnya adalah simbol global yang unik. Ini adalah ekstensi GNU untuk set standar binding simbol ELF. Untuk simbol seperti itu, dynamic linker akan memastikan bahwa dalam keseluruhan proses hanya ada satu simbol dengan nama dan tipe ini yang digunakan.

jadi kami melihat bahwa ada ekstensi ELF khusus untuk ini.

Pra-C ++ 17: extern const

Sebelum C ++ 17, dan di C, kita dapat mencapai efek yang sangat mirip dengan sebuah extern const, yang akan mengarah ke satu lokasi memori yang digunakan.

Kerugiannya inlineadalah:

• tidak mungkin membuat variabel constexprdengan teknik ini, hanya inlinememungkinkan: Bagaimana cara mendeklarasikan constexpr extern?
• ini kurang elegan karena Anda harus mendeklarasikan dan mendefinisikan variabel secara terpisah di file header dan cpp

main.cpp

#include <cassert>

#include "notmain.hpp"

int main() {
    // Both files see the same memory address.
    assert(&notmain_i == notmain_func());
    assert(notmain_i == 42);
}

notmain.cpp

#include "notmain.hpp"

const int notmain_i = 42;

const int* notmain_func() {
    return &notmain_i;
}

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

extern const int notmain_i;

const int* notmain_func();

#endif

GitHub upstream .

Alternatif header saja Pre-C ++ 17

Ini tidak sebaik externsolusinya, tetapi berfungsi dan hanya menggunakan satu lokasi memori:

Sebuah constexprfungsi, karena constexprmenyiratkaninline dan inline memungkinkan (memaksa) definisi tersebut muncul di setiap unit terjemahan :

constexpr int shared_inline_constexpr() { return 42; }

dan saya yakin bahwa setiap kompiler yang layak akan melakukan panggilan inline.

Anda juga dapat menggunakan variabel constatau constexprstatis seperti di:

#include <iostream>

struct MyClass {
    static constexpr int i = 42;
};

int main() {
    std::cout << MyClass::i << std::endl;
    // undefined reference to `MyClass::i'
    //std::cout << &MyClass::i << std::endl;
}

tetapi Anda tidak dapat melakukan hal-hal seperti mengambil alamatnya, atau menjadi digunakan odr, lihat juga: Mendefinisikan anggota data statis constexpr

C

Dalam C situasinya sama dengan C ++ sebelum C ++ 17, saya telah mengunggah contoh di: Apa artinya "statis" di C?

Satu-satunya perbedaan adalah bahwa dalam C ++, constmenyiratkan staticuntuk GLOBALS, tapi tidak di C: C ++ semantik `const` statis vs` const`

Adakah cara untuk membuatnya sebaris sepenuhnya?

TODO: apakah ada cara untuk menyebariskan variabel sepenuhnya, tanpa menggunakan memori sama sekali?

Mirip seperti yang dilakukan preprocessor.

Ini akan membutuhkan entah bagaimana:

• melarang atau mendeteksi jika alamat variabel diambil
• menambahkan informasi tersebut ke file objek ELF, dan biarkan LTO mengoptimalkannya

Terkait:

• C ++ 11 enum dengan anggota kelas dan pengoptimalan waktu tautan constexpr

Diuji di Ubuntu 18.10, GCC 8.2.0.

Ya, itu menyembunyikan variabel dalam modul dari modul lain. Di C ++, saya menggunakannya ketika saya tidak ingin / perlu mengubah file .h yang akan memicu pembuatan ulang file lain yang tidak perlu. Juga, saya menempatkan statis terlebih dahulu:

static const int foo = 42;

Selain itu, bergantung pada penggunaannya, compiler bahkan tidak akan mengalokasikan penyimpanan untuknya dan hanya "menyebariskan" nilai tempatnya digunakan. Tanpa statik, kompilator tidak dapat menganggap itu tidak digunakan di tempat lain dan tidak bisa sebaris.

Konstanta global ini hanya terlihat / dapat diakses dalam modul kompilasi (file .cpp). BTW yang menggunakan statis untuk tujuan ini tidak digunakan lagi. Lebih baik gunakan namespace anonim dan enum:

namespace
{
  enum
  {
     foo = 42
  };
}

Menjadikannya pribadi tetap berarti itu muncul di header. Saya cenderung menggunakan cara "terlemah" yang berhasil. Lihat artikel klasik ini oleh Scott Meyers: http://www.ddj.com/cpp/184401197 (ini tentang fungsi, tetapi dapat diterapkan di sini juga).