Badly designed n string functions?

Can anyone tell me why the n string functions are seemingly so poorly designed?

strncpy, wcsncpy.

These do not guarantee a terminating null if the source string is longer than the destination, and if the destination is longer than the source they will pad with null bytes.

Who wants this behaviour? The first is dangerous and leads to extra code and the second is totally inefficient. Both are not generally needed.

For example, if I have a function that takes a string and I want to make a copy to modify I can do this:

Code:

char szCopy[512];

if (strlen(szInput) >= 512) return E_INVALIDARG;
strcpy(szCopy, szInput);

OR:

strncpy(szCopy, szInput, 512);
if (szCopy[511] != '\0') return E_INVALIDARG;

So to perform this common simple operation with the std
functions is quite inefficient.

I have to turn to the MS string library or write my own function to perform this extremely simple operation efficiently:

Code:

if (FAILED(StringCchCopy(szCopy, 512, szInput))) return E_INVALIDARG;

Am I missing something?

True, but all that you need to do to guarantee the NULL is to pass your maxlen-1 as the parameter. But yes, I'll agree with you there. Should've been the default behaviour in the first place.

I think I saw this on BWK's home page somewhere, but I can't find it at the moment.

strncpy() was originally designed for certain unix data structures which contained fixed length strings with an optional \0 (eg filenames in inodes).
Since everyone knew the size of the string, the lack of a \0 was not a particular problem.

The problems arise when trying to use strncpy() to always guarantee a \0 terminated string, and then people remark on the lack of a guaranteed \0.

Basically, it's a relic of the past - like gets() - which has little or no use in todays programming environments.

If you don't care about whether the string is too long, then something like

Code:

char *strlcpy ( char *dest, const char *src, size_t len ) {
    strncpy( dest, src, len );
    dest[len-1] = '\0';
    return dest;
}

Returns dest, in keeping with the other str functions

Or perhaps

Code:

int strlcpy ( char *dest, const char *src, size_t len ) {
    int res;
    strncpy( dest, src, len );
    res = dest[len-1];
    dest[len-1] = '\0';
    return res;
}

This returns 0 if the string fitted in the buffer, or non-zero if the source string was too big.

Thanks for the info.

I figured they must have been designed for some specific purpose and then leaked into general use.

The function strlcpy function, if not already, should be in the faq under 'How do I use strncpy?'

True, but all that you need to do to guarantee the NULL is to pass your maxlen-1 as the parameter.

This assumes that the string is zeroed out. I use this trick for global strings or when part of a structure that has been zeroed out.

I could just avoid the mess and use strdup but this incurs the cost of a heap alloc.

EDIT: I've just noticed that strdup is non-standard. It seems to be pretty wide spread though.