James Kanze
10/23/2008 8:46:00 AM
On Oct 23, 2:47 am, Ian Collins <ian-n...@hotmail.com> wrote:
> Luna Moon wrote:
> > #include "stdafx.h"
> Why?
> > #include <iostream>
> > #include <string>
> > using namespace std;
> > int main()
> > {
> > string cc(31, 'c');
> > string bb=cc.assign(3, 'dd');
> 'dd' isn't a character constant.
Yes it is:-). "A character literal is one or more characters
enclosed in single quotes[...]" (first sentence of section
2.1.3.2). But it probably won't do what he wants: "An ordinary
character literal that contains more than one c-char is a
multicharacter literal. A multicharacter literal has type int
and implementation-defined value." (A c-char is "any member of
the source character set except the single-quote ', backslash \,
or new-line character", an escape sequence or a universal
character name. Which, if I'm reading things write, means that
something like '\u20A0' only contains one c-char, and so should
have type char---even if the encoding is UTF-8:-).
As a general rule, character constants work well for single
characters in the basic execution set, but I'd avoid them for
anything else.
> > cout << bb.capacity() << endl;
> > cout << bb.size() << endl;
> > getchar();
> > }
> > And "bb.capacity()" returns "15" on my computer, which is
> > wierd, where did it come from?
> Capacity is the size of the string's buffer, size is the
> number of characters in the buffer.
> 15 does appear to be incorrect.
Why? The only requirement is that capacity() >= size(). The
post condition of the copy constructor called to initialize bb
is that bb == str, where str is the other string. The ==
operator ignores capacity, and it is usual that the copy
constructor set the capacity to no more than is needed, modulo
any internal constraints. The g++ implementation of
std::string, for example, should more or less imposes a capacity
which is a multiple of sizeof( size_t ), because of alignment
issues (it doesn't---the actual implementation seems to ignore
all alignment issues), and implementations which use the small
string optimization impose a minimum capacity corresponding to
the size of the small string. Implementations like g++ which
use reference counting will, of course, also "copy" the
capacity. Thus, while all the standard requires in the above is
that capacity() >= 3 (which is the size); with g++, I'd expect
at least 31, because no copy is actually being done. With VC++,
15 (the size of its small string optimization), etc. With Sun
CC (which also uses reference counting), I get 31 with exact
program above, but if I insert a "char& r = cc[ 0 ];" (which
inhibits sharing) before the initialization of bb, I get a
capacity of 3.
All perfectly conform.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34