Може ли да се използва std::basic_string за прилагане на низ с ограничение на дължината?

можете да подадете персонализиран разпределител на std::basic_string, който има максимален размер, какъвто искате. Това трябва да е достатъчно. Може би нещо подобно:

template <class T>
class my_allocator {
public:
    typedef T              value_type;

    typedef std::size_t    size_type;
    typedef std::ptrdiff_t difference_type;
    typedef T*             pointer;
    typedef const T*       const_pointer;
    typedef T&             reference;
    typedef const T&       const_reference;

    pointer address(reference r) const             { return &r; }
    const_pointer address(const_reference r) const { return &r; }

    my_allocator() throw() {}

    template <class U>
    my_allocator(const my_allocator<U>&) throw() {}

    ~my_allocator() throw() {}

    pointer allocate(size_type n, void * = 0) {
        // fail if we try to allocate too much
        if((n * sizeof(T))> max_size()) { throw std::bad_alloc(); }
        return static_cast<T *>(::operator new(n * sizeof(T)));
    }

    void deallocate(pointer p, size_type) {
        return ::operator delete(p);
    }

    void construct(pointer p, const T& val) { new(p) T(val); }
    void destroy(pointer p)                 { p->~T(); }

    // max out at about 64k
    size_type max_size() const throw() { return 0xffff; }

    template <class U>
    struct rebind { typedef my_allocator<U> other; };

    template <class U>
    my_allocator& operator=(const my_allocator<U> &rhs) {
        (void)rhs;
        return *this;
    }
};

Тогава вероятно можете да направите това:

typedef std::basic_string<char, std::char_traits<char>, my_allocator<char> > limited_string;

РЕДАКТИРАНЕ: Току-що направих тест, за да се уверя, че това работи според очакванията. Следният код го тества.

int main() {
    limited_string s;
    s = "AAAA";
    s += s;
    s += s;
    s += s;
    s += s;
    s += s;
    s += s;
    s += s; // 512 chars...
    s += s;
    s += s;
    s += s;
    s += s;
    s += s;
    s += s; // 32768 chars...
    s += s; // this will throw std::bad_alloc

    std::cout << s.max_size() << std::endl;
    std::cout << s.size() << std::endl;
}

Това последно s += s ще го постави отгоре и ще предизвика std::bad_alloc изключение (тъй като лимитът ми е малко под 64k). За съжаление имплементацията std::basic_string::max_size() на gcc не базира резултата си на разпределителя, който използвате, така че пак ще твърди, че може да разпредели повече. (Не съм сигурен дали това е грешка или не...).

Но това определено ще ви позволи да наложите твърди ограничения върху размерите на низовете по прост начин. Можете дори да направите максималния размер параметър на шаблон, така че да трябва да напишете кода за разпределителя само веднъж.

Съгласен съм с Evan Teran за неговото решение. Това вече не е просто модификация на неговото решение:

template <typename Type, typename std::allocator<Type>::size_type maxSize>
struct myalloc : std::allocator<Type>
{
    // hide std::allocator[ max_size() & allocate(...) ]

    std::allocator<Type>::size_type max_size() const throw()
    {
        return maxSize;
    }
    std::allocator<Type>::pointer allocate
        (std::allocator<Type>::size_type n, void * = 0)
    {
        // fail if we try to allocate too much
        if((n * sizeof(Type))> max_size()) { throw std::bad_alloc(); }
        return static_cast<Type *>(::operator new(n * sizeof(Type)));
    }
};

Имайте предвид, че изобщо не трябва да използвате полиморфизъм с myalloc. Така че това е пагубно:

// std::allocator doesn't have a virtual destructor
std::allocator<char>* alloc = new myalloc<char>;

Просто го използвате, сякаш е отделен тип, безопасно е в следния случай:

myalloc<char, 1024> alloc; // max size == 1024

Не можете ли да създадете клас със std::string като родител и да замените c_str()? Или дефинирайте свой собствен c_str16(), c_str32() и т.н. и имплементирайте превод там?