On Oct 23, 2:47 am, Ian Collins <ian-n...@hotmail.co mwrote:
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.capacit y()" 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:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
