Ciąg stały ciąg (członek klasy)

Chciałbym mieć prywatną stałą statyczną dla klasy (w tym przypadku fabrykę kształtów).

Chciałbym mieć coś w tym rodzaju.

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

Niestety dostaję różnego rodzaju błędy z kompilatora C ++ (g ++), takie jak:

ISO C ++ zabrania inicjalizacji elementu „RECTANGLE”

niepoprawna inicjalizacja w klasie elementu danych statycznych typu niezintegrowanego „std :: string”

błąd: statyczne ustawienie „RECTANGLE”

Mówi mi to, że tego rodzaju konstrukcja pręta nie jest zgodna ze standardem. Jak masz prywatną literalną stałą (a może publiczną) bez konieczności stosowania dyrektywy #define (Chcę uniknąć brzydoty globalności danych!)

Każda pomoc jest mile widziana.

Musisz zdefiniować element statyczny poza definicją klasy i podać tam inicjator.

Pierwszy

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

i wtedy

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

Składnia, której pierwotnie próbowałeś użyć (inicjator wewnątrz definicji klasy), jest dozwolona tylko w przypadku typów całkowych i wyliczeniowych.

Począwszy od C ++ 17 masz inną opcję, która jest dość podobna do twojej oryginalnej deklaracji: zmienne wbudowane

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

Nie jest wymagana dodatkowa definicja.

Lub zamiast tego constmożesz zadeklarować constexprw tym wariancie. Jawne inlinenie byłoby już konieczne, ponieważ constexprimplikuje inline.

W C ++ 11 możesz teraz:

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

Wewnątrz definicji klas można deklarować tylko elementy statyczne. Muszą być zdefiniowane poza klasą. W przypadku stałych całkowania w czasie kompilacji standard stanowi wyjątek, że można „inicjować” elementy. Jednak wciąż nie jest to definicja. Na przykład adres nie działałby bez definicji.

Chciałbym wspomnieć, że nie widzę korzyści z używania std :: string nad const char [] dla stałych . std :: string jest niezły i wymaga dynamicznej inicjalizacji. Więc jeśli napiszesz coś takiego

const std::string foo = "hello";

w obszarze nazw konstruktor foo zostanie uruchomiony tuż przed wykonaniem startów głównych, a ten konstruktor utworzy kopię stałej „hello” w pamięci sterty. Chyba że naprawdę potrzebujesz RECTANGLE, aby był std :: string, możesz równie dobrze napisać

// 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";

Tam! Bez alokacji sterty, bez kopiowania, bez dynamicznej inicjalizacji.

Pozdrawiam, s.

To tylko dodatkowe informacje, ale jeśli naprawdę chcesz, aby ciąg znaków w pliku nagłówkowym, spróbuj czegoś takiego:

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

        return str;
    }
};

Chociaż wątpię, żeby to było zalecane.

W C ++ 17 możesz używać zmiennych wbudowanych :

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

Zauważ, że różni się to od odpowiedzi w otchłani. 7 : Ta określa rzeczywisty std::stringobiekt, a nieconst char*

Aby zastosować tę klasową składnię inicjującą, stała musi być stałą statyczną typu całkowego lub typu wyliczenia zainicjowaną przez wyrażenie stałe.

To jest ograniczenie. Dlatego w tym przypadku musisz zdefiniować zmienną poza klasą. skieruj odpowiedź z @AndreyT

Zmienne statyczne klasy można zadeklarować w nagłówku, ale muszą być zdefiniowane w pliku .cpp. Wynika to z faktu, że może istnieć tylko jedna instancja zmiennej statycznej, a kompilator nie może zdecydować, w którym wygenerowanym pliku obiektowym go umieścić, więc musisz podjąć decyzję.

Aby zachować definicję wartości statycznej z deklaracją w C ++ 11, można użyć zagnieżdżonej struktury statycznej. W takim przypadku element statyczny jest strukturą i musi zostać zdefiniowany w pliku .cpp, ale wartości znajdują się w nagłówku.

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

Zamiast inicjowania poszczególnych elementów cała struktura statyczna jest inicjowana w .cpp:

A::_Shapes A::shape;

Dostęp do wartości można uzyskać za pomocą

A::shape.RECTANGLE;

lub - ponieważ członkowie są prywatni i mają być używane tylko z A - z

shape.RECTANGLE;

Zauważ, że w tym rozwiązaniu nadal występuje problem kolejności inicjalizacji zmiennych statycznych. Gdy wartość statyczna jest używana do inicjalizacji innej zmiennej statycznej, pierwsza może jeszcze nie zostać zainicjowana.

// 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 };

W takim przypadku nagłówki zmiennych statycznych będą zawierać {""} lub {".h", ".hpp"}, w zależności od kolejności inicjowania utworzonej przez linker.

Jak wspomniano w @ abyss.7, można również użyć, constexprjeśli wartość zmiennej można obliczyć w czasie kompilacji. Ale jeśli zadeklarujesz swoje ciągi, static constexpr const char*a twój program użyje std::stringinaczej, powstanie narzut, ponieważ nowy std::stringobiekt będzie tworzony za każdym razem, gdy użyjesz takiej stałej:

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.
}

Obecny standard zezwala tylko na taką inicjalizację dla statycznych typów całek stałych. Musisz więc postępować zgodnie z wyjaśnieniem AndreyT. Będzie to jednak dostępne w następnym standardzie poprzez nową składnię inicjującą członka .

możliwe po prostu zrób:

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

lub

#define RECTANGLE "rectangle"

Możesz albo wybrać const char*wyżej wspomniane rozwiązanie, ale jeśli potrzebujesz ciągów przez cały czas, będziesz miał dużo narzutów.
Z drugiej strony ciąg statyczny wymaga dynamicznej inicjalizacji, więc jeśli chcesz użyć jego wartości podczas inicjalizacji innej zmiennej globalnej / statycznej, możesz napotkać problem z kolejnością inicjalizacji. Aby tego uniknąć, najtańszą rzeczą jest dostęp do obiektu ciągu statycznego przez moduł pobierający, który sprawdza, czy obiekt został zainicjowany, czy nie.

//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;  
}  

Pamiętaj, aby używać tylko A::getS(). Ponieważ wszelkie wątki mogą być uruchamiane tylko main()i A_s_initializedinicjowane wcześniej main(), nie potrzebujesz blokad nawet w środowisku wielowątkowym. A_s_initializeddomyślnie jest 0 (przed dynamiczną inicjalizacją), więc jeśli używasz getS()przed inicjalizacją s, bezpiecznie wywołujesz funkcję init.

Btw, w odpowiedzi powyżej: „ static const std :: string RECTANGLE () const ”, funkcje statyczne nie mogą być, constponieważ nie mogą zmienić stanu, jeśli jakikolwiek obiekt (mimo to nie ma tego wskaźnika).

Przewiń do 2018 i C ++ 17.

• nie używaj std :: string, używaj literałów std :: string_view
• zwróć uwagę na poniższy „constexpr”. Jest to również mechanizm „czasu kompilacji”.
• brak inline nie oznacza powtórzeń
• żadne pliki CPP nie są do tego potrzebne

• static_assert „działa” tylko w czasie kompilacji

  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_  ;
  }

  };

Powyżej znajduje się odpowiedni i legalny obywatel C ++. Może łatwo zaangażować się we wszystkie algorytmy std ::, kontenery, narzędzia i tym podobne. Na przykład:

// 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" 
 );

Ciesz się standardowym C ++