String konstan statis (anggota kelas)

Saya ingin memiliki konstanta statis pribadi untuk kelas (dalam hal ini bentuk-pabrik).

Saya ingin memiliki sesuatu seperti itu.

class A {
   private:
      static const string RECTANGLE = "rectangle";
}

Sayangnya saya mendapatkan semua jenis kesalahan dari kompiler C ++ (g ++), seperti:

ISO C ++ melarang inisialisasi anggota 'RECTANGLE'

inisialisasi in-class yang tidak valid dari anggota data statis tipe non-integral 'std :: string'

kesalahan: membuat 'RECTANGLE' statis

Ini memberitahu saya bahwa desain anggota semacam ini tidak sesuai dengan standar. Bagaimana Anda memiliki konstanta literal pribadi (atau mungkin publik) tanpa harus menggunakan arahan #define (saya ingin menghindari keburukan data global!)

Bantuan apa pun dihargai.

Anda harus mendefinisikan anggota statis Anda di luar definisi kelas dan menyediakan inisialisasi di sana.

Pertama

// In a header file (if it is in a header file in your case)
class A {   
private:      
  static const string RECTANGLE;
};

lalu

// In one of the implementation files
const string A::RECTANGLE = "rectangle";

Sintaks yang awalnya Anda coba gunakan (initializer di dalam definisi kelas) hanya diperbolehkan dengan tipe integral dan enum.

Mulai dari C ++ 17 Anda memiliki opsi lain, yang sangat mirip dengan deklarasi asli Anda: variabel inline

// In a header file (if it is in a header file in your case)
class A {   
private:      
  inline static const string RECTANGLE = "rectangle";
};

Tidak diperlukan definisi tambahan.

Atau alih-alih constAnda dapat mendeklarasikannya constexprdalam varian ini. Eksplisit inlinetidak lagi diperlukan, karena constexprtersirat inline.

Di C ++ 11 Anda dapat melakukannya sekarang:

class A {
 private:
  static constexpr const char* STRING = "some useful string constant";
};

Di dalam definisi kelas Anda hanya dapat mendeklarasikan anggota statis. Mereka harus didefinisikan di luar kelas. Untuk konstanta integral kompilasi waktu, standar membuat pengecualian bahwa Anda dapat "menginisialisasi" anggota. Itu masih bukan definisi. Mengambil alamat tidak akan berfungsi tanpa definisi, misalnya.

Saya ingin menyebutkan bahwa saya tidak melihat manfaat dari menggunakan std :: string over const char [] untuk konstanta . std :: string bagus dan semua tetapi membutuhkan inisialisasi dinamis. Jadi, jika Anda menulis sesuatu seperti

const std::string foo = "hello";

pada lingkup namespace, konstruktor foo akan dijalankan tepat sebelum eksekusi mulai utama dan konstruktor ini akan membuat salinan konstanta "halo" di memori tumpukan. Kecuali Anda benar-benar membutuhkan RECTANGLE untuk menjadi std :: string yang Anda bisa tulis

// class definition with incomplete static member could be in a header file
class A {
    static const char RECTANGLE[];
};

// this needs to be placed in a single translation unit only
const char A::RECTANGLE[] = "rectangle";

Sana! Tidak ada alokasi tumpukan, tidak ada penyalinan, tidak ada inisialisasi dinamis.

Cheers, s.

Ini hanya informasi tambahan, tetapi jika Anda benar-benar menginginkan string dalam file header, coba sesuatu seperti:

class foo
{
public:
    static const std::string& RECTANGLE(void)
    {
        static const std::string str = "rectangle";

        return str;
    }
};

Meskipun aku ragu itu direkomendasikan.

Di C ++ 17 Anda dapat menggunakan variabel sebaris :

class A {
 private:
  static inline const std::string my_string = "some useful string constant";
};

Perhatikan bahwa ini berbeda dari jawaban yang buruk.7 : Yang ini mendefinisikan std::stringobjek aktual , bukan aconst char*

Untuk menggunakan sintaks inisialisasi di dalam kelas, konstanta harus berupa konstanta statis integral atau tipe enumerasi yang diinisialisasi dengan ekspresi konstan.

Ini batasannya. Karenanya, dalam hal ini Anda perlu mendefinisikan variabel di luar kelas. lihat jawaban dari @AndreyT

Variabel statis kelas dapat dideklarasikan di header tetapi harus didefinisikan dalam file .cpp. Ini karena hanya ada satu contoh variabel statis dan kompilator tidak dapat memutuskan di mana file objek yang dihasilkan untuk meletakkannya sehingga Anda harus membuat keputusan.

Untuk menjaga definisi nilai statis dengan deklarasi di C ++ 11 struktur statis bersarang dapat digunakan. Dalam hal ini anggota statis adalah struktur dan harus didefinisikan dalam file .cpp, tetapi nilainya ada di header.

class A
{
private:
  static struct _Shapes {
     const std::string RECTANGLE {"rectangle"};
     const std::string CIRCLE {"circle"};
  } shape;
};

Alih-alih menginisialisasi anggota individu seluruh struktur statis diinisialisasi dalam .cpp:

A::_Shapes A::shape;

Nilai diakses dengan

A::shape.RECTANGLE;

atau - karena anggotanya pribadi dan dimaksudkan untuk digunakan hanya dari A - with

shape.RECTANGLE;

Perhatikan bahwa solusi ini masih menderita dari masalah urutan inisialisasi variabel statis. Ketika nilai statis digunakan untuk menginisialisasi variabel statis lain, yang pertama mungkin belum diinisialisasi.

// file.h
class File {
public:
  static struct _Extensions {
    const std::string h{ ".h" };
    const std::string hpp{ ".hpp" };
    const std::string c{ ".c" };
    const std::string cpp{ ".cpp" };
  } extension;
};

// file.cpp
File::_Extensions File::extension;

// module.cpp
static std::set<std::string> headers{ File::extension.h, File::extension.hpp };

Dalam hal ini header variabel statis akan berisi {""} atau {".h", ".hpp"}, tergantung pada urutan inisialisasi yang dibuat oleh penghubung.

Seperti disebutkan oleh @ abyss.7 Anda juga dapat menggunakan constexprjika nilai variabel dapat dihitung pada waktu kompilasi. Tetapi jika Anda mendeklarasikan string Anda static constexpr const char*dan program Anda menggunakan std::stringsebaliknya, akan ada overhead karena std::stringobjek baru akan dibuat setiap kali Anda menggunakan konstanta seperti itu:

class A {
public:
   static constexpr const char* STRING = "some value";
};
void foo(const std::string& bar);
int main() {
   foo(A::STRING); // a new std::string is constructed and destroyed.
}

Standar saat ini hanya memungkinkan inisialisasi tersebut untuk jenis integral konstan statis. Jadi, Anda perlu melakukan seperti yang dijelaskan AndreyT. Namun, itu akan tersedia dalam standar berikutnya melalui sintaks inisialisasi anggota baru .

mungkin lakukan saja:

static const std::string RECTANGLE() const {
    return "rectangle";
} 

atau

#define RECTANGLE "rectangle"

Anda bisa menggunakan const char*solusi yang disebutkan di atas, tetapi jika Anda membutuhkan string setiap saat, Anda akan memiliki banyak overhead.
Di sisi lain, string statis membutuhkan inisialisasi dinamis, jadi jika Anda ingin menggunakan nilainya selama inisialisasi variabel global / statis lain, Anda mungkin mengalami masalah urutan inisialisasi. Untuk menghindari itu, hal termurah adalah mengakses objek string statis melalui pengambil, yang memeriksa apakah objek Anda diinisialisasi atau tidak.

//in a header  
class A{  
  static string s;   
public:   
  static string getS();  
};  
//in implementation  
string A::s;  
namespace{  
  bool init_A_s(){  
    A::s = string("foo");   
    return true;  
  }  
  bool A_s_initialized = init_A_s();  
}  
string A::getS(){      
  if (!A_s_initialized)  
    A_s_initialized = init_A_s();  
  return s;  
}  

Ingatlah untuk hanya menggunakan A::getS(). Karena setiap threading hanya dapat dimulai dengan main(), dan A_s_initializeddiinisialisasi sebelumnya main(), Anda tidak perlu kunci bahkan dalam lingkungan multithreaded A_s_initializedadalah 0 secara default (sebelum inisialisasi dinamis), jadi jika Anda menggunakan getS()sebelum s diinisialisasi, Anda memanggil fungsi init dengan aman.

Btw, dalam jawaban di atas: " static const std :: string RECTANGLE () const ", fungsi statis tidak bisa constkarena mereka tidak dapat mengubah keadaan jika objek tetap (tidak ada pointer ini).

Maju cepat ke 2018 dan C ++ 17.

• jangan gunakan std :: string, gunakan std :: string_view literals
• mohon perhatikan 'constexpr' di bawah. Ini juga merupakan mekanisme "waktu kompilasi".
• tidak ada sebaris tidak berarti pengulangan
• tidak ada file cpp tidak diperlukan untuk ini

• static_assert 'works' hanya pada waktu kompilasi

  using namespace std::literals;
  
  namespace STANDARD {
  constexpr 
  inline 
  auto 
  compiletime_static_string_view_constant() {
  // make and return string view literal
  // will stay the same for the whole application lifetime
  // will exhibit standard and expected interface
  // will be usable at both
  // runtime and compile time
  // by value semantics implemented for you
      auto when_needed_ =  "compile time"sv;
      return when_needed_  ;
  }

  };

Di atas adalah standar warga negara C ++ yang tepat dan sah. Itu bisa dengan mudah terlibat dalam setiap dan semua std :: algoritma, wadah, utilitas dan semacamnya. Sebagai contoh:

// test the resilience
auto return_by_val = []() {
    auto return_by_val = []() {
        auto return_by_val = []() {
            auto return_by_val = []() {
return STANDARD::compiletime_static_string_view_constant();
            };
            return return_by_val();
        };
        return return_by_val();
    };
    return return_by_val();
};

// actually a run time 
_ASSERTE(return_by_val() == "compile time");

// compile time 
static_assert(
   STANDARD::compiletime_static_string_view_constant() 
   == "compile time" 
 );

Nikmati C ++ standar