CODEWITHSUNDEEP
clinux
Iosif Murariu
Iosif Murariu

Reputation: 2054

bzero() & bcopy() versus memset() & memcpy()

Is there any reason to use the non-standard bzero() and bcopy() instead of memset() and memcpy() in a Linux environment? I've heard many say that they're better for Linux compilers, but haven't seen any advantages over the standard functions.

Are they more optimized than the standard ones, or do they have any behavioral particularity for which they're preferred?

Upvotes: 42

Views: 29972

Answers (3)

the kamilz
the kamilz

Reputation: 1988

#include <strings.h>
void bcopy(const void *src, void *dest, size_t n);

Description The bcopy() function copies n bytes from src to dest. The result is correct, even when both areas overlap.

Conforming to: 4.3BSD, it seems b comes from BSD and it seems deprecated.

Which means bcopy is analogous to memmove() not memcpy() as R.. said at his comment.

Note: strings.h is also distinct from string.h.

Upvotes: 4

paxdiablo
paxdiablo

Reputation: 882596

While bzero and bcopy functions aren't ISO C (the actual standard that I assume you're talking about when referring to them as non-standard), they were a POSIX standard thing, although they pre-dated both ISO and POSIX.

And note that use of the word "were" - these functions were deprecated in POSIX.1-2001 and fianally removed in POSIX.1-2008, in deference to memset, memcpy and memmove. So you're better off using the standard C functions where possible.

If you have a lot of code that uses them and you don't want to have to go and change it all (though you probably should at some point), you can use the following quick substitutions:

// void bzero(void *s, size_t n);
#define bzero(s, n) memset((s), 0, (n))

// void bcopy(const void *s1, void *s2, size_t n);
#define bcopy(s1, s2, n) memmove((s2), (s1), (n))

Upvotes: 61

skyking
skyking

Reputation: 14400

Actually nowdays it could be the other way around. You see that because memcpy and memset is included in the standard the compiler will be allowed to assume that function called so does exactly what the standard prescribes. This means that the compiler can replace them with the most efficient way of performing the operation it can figure out. With bcopy and bzero on the other hand the standard does not prescribe any behavior on those so the compiler can't assume anything - which means that the compiler would need to issue an actual function call.

However GCC for example knows about bcopy and bzero if it's built for an OS that have them.

Upvotes: 3

Related Questions