Classe di lunghezza fissa C++?

Question

C'è qualcosa di simile in Standard C++/STL? Idealmente dovrebbe essere costruito come

fstring s = fstring(10); 

Ho bisogno di costruire a volte o avere una stringa di dimensioni fisse. A volte per essere in grado di leggere/scrivere solo molti caratteri in un flusso.

Edit:

Nota che la dimensione è nota solo in fase di esecuzione, ed è diverso da uno all'altro. Ma tutti i fstring s dovrebbero sapere come lavorare insieme e avere tutto il fantastico comportamento string.

Answer 1

Serie di caratteri stile C?

char label[10] = "a string"; 

Answer 2

Perché non utilizzare std :: basic_string da STL come classe di stringa fissa?

È possibile utilizzare il costruttore

basic_string(
    size_type _Count, 
    value_type _Ch, 
    const allocator_type& _Al = Allocator () 
); 

come inizializzazione.

Successivamente modificare: Esempio:

std::string my10CharStringInitializedWithSpace(10, ' '); 

Answer 3

Se ho capito bene, non si vuole usare std::string perché siete preoccupati che potrebbe silenziosamente espandere su di voi. Vedo un paio di opzioni:

1. utilizzare una stringa C-stile crudo e le funzioni da cstdio che prendere un argomento di lunghezza (per esempio, fgets).

2. Utilizzare un std::vector<char>.

Answer 4

C'è probabilmente qualcosa in spinta che fornisce questo (la più vicina Ho visto personalmente è Boost.Array, che è insufficiente). Tuttavia, se si sta solo cercando di modellare il "importante sottoinsieme" di std::string, non è molto difficile fare una lunghezza fissa equivalente:

template <size_t N> 
class fixed_string 
{ 
    // ... interface looks like std::string 
}; 

Per chiunque chiedendo il motivo per preoccuparsi di fare questo a tutti, il Il vantaggio principale è evitare l'allocazione della memoria senza perdere gran parte dell'utile API std::string. Se c'è un altro modo per farlo con std::allocator, sarei curioso di sapere.

Answer 5

l'approssimazione più vicina oggi è boost::array<char, 10>

Answer 6

Usa per esempio

std::tr1::array<char, 10> 

Answer 7

ne dite di ereditare std::string privatamente quindi esporre un'interfaccia più piccolo con using, e scrivere i propri < < e >> funzioni?

Answer 8

Ho usato qualcosa di simile per le stringhe allocate nello stack o come parte di un altro oggetto. Che in versione diventa un char *

#ifdef DEBUG 
#define STR_DEBUG 
#endif 

#define FIXED_STRING(maxSize) ReservedString<maxSize> _Tmp##__LINE__; 

class FixedString{ 
public: 
    FixedString& operator =(char const * const pStr); 
    //FixedString& operator =(FixedString const &pStr); 
    operator const char*() const { return mStr; } 
    const char* cStr() const { return mStr; } 
    FixedString& operator +=(const char *pStr); 
    bool equals(const char *pStr); 
    bool beginsWith(const char *pStr); 
    /// rises ASSERT if not enough 
    void ensureEnoughForNMore(int NMoreSymbols); 
protected: 
    char *mStr; 
    #ifdef STR_DEBUG 
     ui16 mMaxLength; 
    #endif 

private: 
    #ifdef STR_DEBUG 
     FixedString(char *str, ui16 maxLength): mStr(str), mMaxLength(maxLength) {} 
    #else 
     FixedString(char *str): mStr(str) {} 
    #endif 
    template<int> 
    friend class ReservedString; 
}; 

template <int MAX_LENGTH> class ReservedString{ 
public: 
    operator FixedString() { 
     #ifdef STR_DEBUG 
      return FixedString(mBuf, MAX_LENGTH); 
     #else 
      return FixedString(mBuf); 
     #endif 
    } 
private: 
    char mBuf[MAX_LENGTH+1]; 
}; 

Answer 9

Con C++ 11, si può andare per

std::array<char,10> s; 

anche std :: string equivalente può sempre essere costruito, in caso di necessità

std::string s2(std::begin(s), std::end(s));