This makes me slightly curious...

Why is there assembly code for the string class of C++?

page    ,132
        title   strlen - return the length of a null-terminated string
;***
;strlen.asm - contains strlen() routine
;
;       Copyright (c) Microsoft Corporation. All rights reserved.
;
;Purpose:
;       strlen returns the length of a null-terminated string,
;       not including the null byte itself.
;
;*******************************************************************************

        .xlist
        include cruntime.inc
        .list

page
;***
;strlen - return the length of a null-terminated string
;
;Purpose:
;       Finds the length in bytes of the given string, not including
;       the final null character.
;
;       Algorithm:
;       int strlen (const char * str)
;       {
;           int length = 0;
;
;           while( *str++ )
;                   ++length;
;
;           return( length );
;       }
;
;Entry:
;       const char * str - string whose length is to be computed
;
;Exit:
;       EAX = length of the string "str", exclusive of the final null byte
;
;Uses:
;       EAX, ECX, EDX
;
;Exceptions:
;
;*******************************************************************************

        CODESEG

        public  strlen

strlen  proc \
        buf:ptr byte

        OPTION PROLOGUE:NONE, EPILOGUE:NONE

        .FPO    ( 0, 1, 0, 0, 0, 0 )

string  equ     [esp + 4]

        mov     ecx,string              ; ecx -> string
        test    ecx,3                   ; test if string is aligned on 32 bits
        je      short main_loop

str_misaligned:
        ; simple byte loop until string is aligned
        mov     al,byte ptr [ecx]
        add     ecx,1
        test    al,al
        je      short byte_3
        test    ecx,3
        jne     short str_misaligned

        add     eax,dword ptr 0         ; 5 byte nop to align label below

        align   16                      ; should be redundant

main_loop:
        mov     eax,dword ptr [ecx]     ; read 4 bytes
        mov     edx,7efefeffh
        add     edx,eax
        xor     eax,-1
        xor     eax,edx
        add     ecx,4
        test    eax,81010100h
        je      short main_loop
        ; found zero byte in the loop
        mov     eax,[ecx - 4]
        test    al,al                   ; is it byte 0
        je      short byte_0
        test    ah,ah                   ; is it byte 1
        je      short byte_1
        test    eax,00ff0000h           ; is it byte 2
        je      short byte_2
        test    eax,0ff000000h          ; is it byte 3
        je      short byte_3
        jmp     short main_loop         ; taken if bits 24-30 are clear and bit
                                        ; 31 is set

byte_3:
        lea     eax,[ecx - 1]
        mov     ecx,string
        sub     eax,ecx
        ret
byte_2:
        lea     eax,[ecx - 2]
        mov     ecx,string
        sub     eax,ecx
        ret
byte_1:
        lea     eax,[ecx - 3]
        mov     ecx,string
        sub     eax,ecx
        ret
byte_0:
        lea     eax,[ecx - 4]
        mov     ecx,string
        sub     eax,ecx
        ret

strlen  endp

        end

You could write a strlen function in any language but assembly is the fastest you can get, perhaps thats why.
The only problem is the way the fastest is implemented on a microprocessor. It makes it less portable. How can you be sure the listing is how the C++ compiler designers implemented it that way?

>Why is there assembly code for the string class of C++?
On your implementation, you mean. The answer is probably optimization, especially if you read the code and understand what the algorithm is trying to achieve.

>How can you be sure the listing is how the C++ compiler designers implemented it that way?
I'd say that code is hand crafted, or it's tweaked assembly output. Either way, the implementation is extremely low level and clearly written with performance in mind.

Comments
Yes, I meant for my implementation. Thanks for the correction =)

This makes me slightly curious...

Why is there assembly code for the string class of C++?

To me that doesn't look like the std::string that seems implied by "the string class of C++", but that's silly pedantry.

Why wouldn't library implementations be written in assembly? I would imagine that the folks providing a language implementation have a pretty solid understanding of the implementation they are providing (in general, QoI issues aside).

It makes it less portable.

Notsomuch, really. A language implementation must conform to the standard, thereby providing portability. The particulars of an implementation will most likely vary from one to the next. That is to say, on almost every platform the "under the hood" stuff will look different, but the functions will still do as specified in the standard.

How can you be sure the listing is how the C++ compiler designers implemented it that way?

I'm not quite sure what you are asking, but I'd say that it's either a compliant C++ compiler or it isn't. If it doesn't do what the standard states, it's broken.

How can you be sure the listing is how the C++ compiler designers implemented it that way?

I'm not quite sure what you are asking, but I'd say that it's either a compliant C++ compiler or it isn't. If it doesn't do what the standard states, it's broken.

I was talking about how it is implemented. The outcome may be standard ISO whatever...

This article has been dead for over six months. Start a new discussion instead.