C Style Strings

[scroopy]

Hi,

I've always used std::string but I'm having to use a 3rd party library
that returns const char*s. Given:

char* pString1 = "Blah ";
const char* pString2 = "Blah Blah";

How do I append the contents of pString2 to pString? (giving "Blah
Blah Blah")

I looked at strcat but that crashes with an unhandled exception.

Thanks

[Alex Buell]

On 4 Jun 2006 02:48:22 -0700, I waved a wand and this message magically
appeared from persenaama:

If you want this even faster, and the architecture can support it,
copy the largest size per loop, i.e. 32 bits at a time. Or even 64
bits.

Problem with that is that both source and destination have to be
aligned (for correctness, performance or both depending on the
architechture). Strings are commonly short so the overhead of
detecting this situation might degrade the performance on average use
case.

Somewhere I have a routine written in assembler that copies strings
very quickly. It's intelligent enough to know about these special cases.
--
http://www.munted.org.uk

Take a nap, it saves lives.

[Ian Collins]

Alex Buell wrote:

On 4 Jun 2006 02:48:22 -0700, I waved a wand and this message magically
appeared from persenaama:

If you want this even faster, and the architecture can support it,
copy the largest size per loop, i.e. 32 bits at a time. Or even 64
bits.

Problem with that is that both source and destination have to be
aligned (for correctness, performance or both depending on the
architechture ). Strings are commonly short so the overhead of
detecting this situation might degrade the performance on average use
case.

Somewhere I have a routine written in assembler that copies strings
very quickly. It's intelligent enough to know about these special cases.

For a good example, have a look at

http://cvs.opensolaris.org/source/xr...en/memcpy.s#27

--
Ian Collins.

[persenaama]

> Somewhere I have a routine written in assembler that copies strings

very quickly. It's intelligent enough to know about these special cases.

Can we take a look at the code and do somekind of estimate where the
tie-breaker case is concerning the string length?

[persenaama]

> For a good example, have a look at

http://cvs.opensolaris.org/source/xr...en/memcpy.s#27

Basicly it does count/4 "rep movsd" followed by count%4 "rep movsb" for
the leftover bytes, this is not very useful for asciiz strings as the
trailing zero must be detected and correctly handled. The code does not
align the source or destination address either.

The case which was being discussed was somekind of optimized strcat()
variant, using asciiz style strings as input.

This might be of help, for dealing multiple chars at a time:

void example(unsigne d int* p)
{
unsigned int v = 0;
for ( ; !v; )
{
unsigned int u = *p++;
v = (u - 0x01010101) & ~u & 0x80808080;
}
// ...
}

Assuming the sizeof(unsigned int) == 4 on a particular platform and
that char is 8 bits, the above snip of code would scan four characters
at a time for trailing zero. The code can be easily modified to handle
strcat(), strcpy(), strlen() .. what is missing is handling alignment,
which is trivial this is just demonstrating a concept.

[Alex Buell]

On 4 Jun 2006 07:21:33 -0700, I waved a wand and this message magically
appeared from persenaama:

Somewhere I have a routine written in assembler that copies strings
very quickly. It's intelligent enough to know about these special
cases.

Can we take a look at the code and do somekind of estimate where the
tie-breaker case is concerning the string length?

Seems I was incorrect, the routine is strlen() which actually counts 4
bytes at a time and returns the total asciiz string length.
--
http://www.munted.org.uk

Take a nap, it saves lives.

[websnarf]

Noah Roberts wrote:

we******@gmail. com wrote:

/* In C: */

int catHi (bstring b) {
static struct tagbstring hi = bsStatic ("hi"); /* init-time */
bconcat (b, &hi); /* Essentially an addition and a memcpy */
}

// in C++:

void catHi (CBString &b) {
b += "hi"; // Requires implicit construction of CBString("hi") or
some
// sort of strlen() being called on "hi" before
appending.
}
The only difference between the two code slices is syntax; they mean
the same thing.

They have the same end effect -- however they are not the same in
implementation.
[...] Of course, to be truely certain of that we would have
to know what bsStatic() does,
Its a macro that uses sizeof() and "" inline concatenation to deduce
the length of the string and enforce the fact that it is a string
literal. It forms a special kind of bstring compatible structure using
pure stack or static memory. The resources are managed implicitely by
the state of the call stack.
[...] what bconcat does,
It concatenates to a dynamic bstring (which, in this case, we assume is
passed in).
[...] what CBString(const
char*)
Constructs a CBString with constant equivalent to the const char *
initializer.
[...] does and what CBString::opera tor += does.
Its like bconcat for CBStrings.
[...] What I think they all
mean just looking at the above would result in exactly the same
operations.
Conceptually, they are, but by implementation they are not. In
particular there is no way to trick the C++ part into constructing the
contents of the string form purely stack or static memory unless you
actually use the C syntax.
[...] Of course there is nothing requiring that CBString be
implemented so that += does not accept a const char* directly.
Right, but it doesn't help, because you still need to call an extra
strlen(). (Or iterate character by character but you don't get to
leverage the compiler's highly optimized memcpy().)
Even at that.... your code example does not prove your point at all.
It does not illustrate any difference between C and C++ with regard to
stack variables.

Ok -- using syntax and concepts from C++ that are not just directly
lifted from C, how does one make a static CBString such as I have
shown? (You can drop the static decorator in the front, to make this
all just about the stack, and not static memory.)

--
Paul Hsieh
http://www.pobox.com/~qed/
http://bstring.sf.net/

[Noah Roberts]

we******@gmail. com wrote:

Even at that.... your code example does not prove your point at all.
It does not illustrate any difference between C and C++ with regard to
stack variables.

Ok -- using syntax and concepts from C++ that are not just directly
lifted from C, how does one make a static CBString such as I have
shown?

Ok, I see where the difference is in the two code segments. You are
mistaking the stack for static variables apparently. Nothing keeps you
from doing this:

void f(CBString & str)
{
static CBString hi = "hi";

str += hi;
}

Besides that I fail to understand what exactly it is you think is
different. I have no idea what your functions do beyond your poor
attempt to describe them so there is no way to tell what you are
talking about. Simply put, you are completely mistaken about there
being no way to put a variable of any kind on the "stack" in C++. I
don't know how else to put it if you don't understand that. I still
can't figure out why you think otherwise.

[Keith Thompson]

"persenaama " <ju***@liimatta .org> writes:

Somewhere I have a routine written in assembler that copies strings
very quickly. It's intelligent enough to know about these special cases.

Can we take a look at the code and do somekind of estimate where the
tie-breaker case is concerning the string length?

The text starting with "Somewhere I have" was written by Alex Buell.

persenaama, the lines that look like

"persenaama " <ju***@liimatta .org> writes:

are called attribution lines. Don't delete them *unless* you've
trimmed everything that person wrote from your followup. They make it
significantly easier to follow the discussion.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[persenaama]

we******@gmail. com wrote:

Ok -- using syntax and concepts from C++ that are not just directly
lifted from C, how does one make a static CBString such as I have
shown? (You can drop the static decorator in the front, to make this
all just about the stack, and not static memory.)

void foo()
{
static const char * x = "hi";
}

void bar()
{
const char * y = "hi";
}

The difference between foo() and bar() is that the pointer object y is
in the stack while the pointer object x isn't. The string literal isn't
in the stack in either case.

However, in C++, you cannot really say that as there is no concept of
stack in C++ it is just commonly understood that a stack is a very
practical and common implementation of local scoped objects with auto
storage within a function.

I think I have to re-read what this was really about as I seem to miss
the point what stack has to do with the string literal. :)

[Ian Collins]

Alex Buell wrote:

On 4 Jun 2006 07:21:33 -0700, I waved a wand and this message magically
appeared from persenaama:

Somewhere I have a routine written in assembler that copies strings
very quickly. It's intelligent enough to know about these special
cases.

Can we take a look at the code and do somekind of estimate where the
tie-breaker case is concerning the string length?

Seems I was incorrect, the routine is strlen() which actually counts 4
bytes at a time and returns the total asciiz string length.

Something like:

http://cvs.opensolaris.org/source/xr...en/strlen.s#27

?

--
Ian Collins.