StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>you can pass a custom allocator to <code>std::basic_string</code> which has a max size of whatever you want. This should be sufficient. Perhaps something like this:</p> <pre><code>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; } }; </code></pre> <p>Then you can probably do this:</p> <pre><code>typedef std::basic_string<char, std::char_traits<char>, my_allocator<char> > limited_string; </code></pre> <p><strong>EDIT:</strong> I've just done a test to make sure this works as expected. The following code tests it.</p> <pre><code>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; } </code></pre> <p>That last <code>s += s</code> will put it over the top and cause a <code>std::bad_alloc</code> exception, (since my limit is just short of 64k). Unfortunately gcc's <code>std::basic_string::max_size()</code> implementation does not base its result on the allocator you use, so it will still claim to be able to allocate more. (I'm not sure if this is a bug or not...).</p> <p>But this will definitely allow you impose hard limits on the sizes of strings in a simple way. You could even make the max size a template parameter so you only have to write the code for the allocator once.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload