Stringa costante statica (membro della classe)

Vorrei avere una costante statica privata per una classe (in questo caso una fabbrica di forme).

Mi piacerebbe avere qualcosa del genere.

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

Sfortunatamente ricevo ogni sorta di errore dal compilatore C ++ (g ++), come ad esempio:

ISO C ++ proibisce l'inizializzazione del membro "RETTANGOLO"

inizializzazione in classe non valida del membro di dati statici di tipo non integrale 'std :: string'

errore: rendere statico 'RETTANGOLO'

Questo mi dice che questo tipo di design dei membri non è conforme allo standard. Come hai una costante letterale privata (o forse pubblica) senza dover usare una direttiva #define (voglio evitare la bruttezza della globalità dei dati!)

Qualsiasi aiuto è apprezzato.

Devi definire il tuo membro statico al di fuori della definizione della classe e fornire l'inizializzatore lì.

Primo

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

e poi

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

La sintassi che stavi inizialmente cercando di utilizzare (inizializzatore all'interno della definizione della classe) è consentita solo con tipi integrali ed enum.

A partire da C ++ 17 hai un'altra opzione, che è abbastanza simile alla tua dichiarazione originale: variabili in linea

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

Non è necessaria alcuna definizione aggiuntiva.

O invece di constte puoi dichiararlo constexprin questa variante. Esplicito inlinenon sarebbe più necessario, poiché constexprimplica inline.

In C ++ 11 puoi fare ora:

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

All'interno delle definizioni di classe è possibile dichiarare solo membri statici. Devono essere definiti al di fuori della classe. Per le costanti integrali in fase di compilazione lo standard fa l'eccezione che è possibile "inizializzare" i membri. Tuttavia, non è ancora una definizione. Prendere l'indirizzo non funzionerebbe senza definizione, per esempio.

Vorrei menzionare che non vedo il vantaggio di usare std :: string over const char [] per le costanti . std :: string è bello e tutto ma richiede l'inizializzazione dinamica. Quindi, se scrivi qualcosa del genere

const std::string foo = "hello";

nell'ambito dello spazio dei nomi il costruttore di foo verrà eseguito subito prima dell'esecuzione degli avvii principali e questo costruttore creerà una copia della costante "ciao" nella memoria dell'heap. A meno che tu non abbia davvero bisogno di RECTANGLE per essere una std :: string potresti anche scrivere

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

Là! Nessuna allocazione di heap, nessuna copia, nessuna inizializzazione dinamica.

Saluti, s.

Queste sono solo informazioni extra, ma se vuoi davvero la stringa in un file header, prova qualcosa del tipo:

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

        return str;
    }
};

Anche se dubito che sia raccomandato.

In C ++ 17 puoi usare le variabili inline :

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

Nota che questo è diverso dalla risposta di abyss.7 : questo definisce un std::stringoggetto reale , non unconst char*

Per utilizzare quella sintassi di inizializzazione in classe, la costante deve essere una const statica di tipo integrale o di enumerazione inizializzata da un'espressione costante.

Questa è la restrizione. Quindi, in questo caso è necessario definire una variabile al di fuori della classe. fare riferimento a risposta da @AndreyT

Le variabili statiche della classe possono essere dichiarate nell'intestazione ma devono essere definite in un file .cpp. Questo perché può esserci solo un'istanza di una variabile statica e il compilatore non può decidere in quale file oggetto generato metterlo, quindi devi prendere la decisione.

Per mantenere la definizione di un valore statico con la dichiarazione in C ++ 11 è possibile utilizzare una struttura statica nidificata. In questo caso il membro statico è una struttura e deve essere definito in un file .cpp, ma i valori sono nell'intestazione.

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

Invece di inizializzare i singoli membri l'intera struttura statica viene inizializzata in .cpp:

A::_Shapes A::shape;

Si accede ai valori con

A::shape.RECTANGLE;

oppure - poiché i membri sono privati ​​e devono essere utilizzati solo da A - con

shape.RECTANGLE;

Si noti che questa soluzione soffre ancora del problema dell'ordine di inizializzazione delle variabili statiche. Quando si utilizza un valore statico per inizializzare un'altra variabile statica, la prima potrebbe non essere ancora inizializzata.

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

In questo caso le intestazioni delle variabili statiche conterranno {""} o {".h", ".hpp"}, a seconda dell'ordine di inizializzazione creato dal linker.

Come accennato da @ abyss.7, puoi anche utilizzare constexprse il valore della variabile può essere calcolato al momento della compilazione. Ma se dichiari le tue stringhe con static constexpr const char*e il tuo programma usa std::stringaltrimenti ci sarà un overhead perché un nuovo std::stringoggetto verrà creato ogni volta che usi una tale costante:

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

L'attuale standard consente tale inizializzazione solo per tipi integrali costanti statici. Quindi devi fare come ha spiegato AndreyT. Tuttavia, ciò sarà disponibile nel prossimo standard tramite la sintassi di inizializzazione del nuovo membro .

possibile basta fare:

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

o

#define RECTANGLE "rectangle"

Puoi scegliere la const char*soluzione sopra menzionata, ma se hai sempre bisogno di stringhe, avrai un sacco di spese generali.
D'altra parte, la stringa statica richiede l'inizializzazione dinamica, quindi se si desidera utilizzare il suo valore durante l'inizializzazione di un'altra variabile globale / statica, è possibile che si verifichi il problema dell'ordine di inizializzazione. Per evitare ciò, la cosa più economica è accedere all'oggetto stringa statica tramite un getter, che controlla se l'oggetto è inizializzato o meno.

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

Ricorda di usare solo A::getS(). Poiché qualsiasi threading può solo essere avviato main()e A_s_initializedinizializzato in precedenza main(), non è necessario il blocco anche in un ambiente multithread. A_s_initializedè 0 per impostazione predefinita (prima dell'inizializzazione dinamica), quindi se si utilizza getS()prima dell'inizializzazione di s, si chiama la funzione init in modo sicuro.

A proposito, nella risposta sopra: " static const std :: string RECTANGLE () const ", le funzioni statiche non possono essere constperché non possono cambiare lo stato se qualche oggetto comunque (non c'è questo puntatore).

Avanti veloce al 2018 e C ++ 17.

• non usare std :: string, usa i letterali std :: string_view
• si prega di notare il muggito "constexpr". Questo è anche un meccanismo di "tempo di compilazione".
• nessun inline non significa ripetizione
• non sono necessari file cpp per questo

• static_assert 'funziona' solo in fase di compilazione

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

  };

Sopra è un cittadino C ++ standard adeguato e legale. Può essere facilmente coinvolto in tutti gli algoritmi std ::, container, utility e simili. Per esempio:

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

Goditi il ​​C ++ standard