C++ chaîne de longueur fixe de la classe?

L'approximation la plus proche aujourd'hui est boost::array<char, 10>

OriginalL'auteur

J'ai été en utilisant quelque chose comme cela pour les chaînes alloué sur la pile ou comme partie d'un autre objet. Qui en sortie devient 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];
};

OriginalL'auteur

Pourquoi ne pas utiliser std::basic_string de STL comme une chaîne de caractères fixe de classe?

Vous pouvez utiliser le constructeur

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

comme initialiseur.

Plus tard edit:
Exemple:

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

OriginalL'auteur

Il y a probablement quelque chose dans boost qui fournit (ce qui est le plus proche que j'ai personnellement vu, c'est coup de pouce.Tableau, ce qui est insuffisant). Toutefois, si vous êtes simplement à la recherche de modèle de la "sous-ensemble" de std::string, il n'est pas très difficile de faire une longueur fixe équivalent:

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

Pour toute personne demandant pourquoi s'embêter à faire tout cela, le principal avantage est d'éviter l'allocation de la mémoire sans perdre la plupart de la durée de std::string API. Si il y a une autre façon de le faire avec std::allocator, je serais curieux de savoir.

OriginalL'auteur

Si je vous comprends bien, vous ne voulez pas utiliser std::string parce que vous êtes inquiet qu'il pourrait en silence étendre sur vous. Je vois deux options:

1. Utiliser un brut, C-chaîne de style et les fonctions de cstdio qui prennent un argument de longueur (par exemple, fgets).

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

OriginalL'auteur