memcmp(3c) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨 페이지 이름
검색(S)

memcmp(3c)

memory(3C)               Standard C Library Functions               memory(3C)

NAME
       memory, memccpy, memchr, memcmp, memcpy, memmove, memset, explicit_mem‐
       set, memmem, memcpy_s, memmove_s, memset_s - memory operations

SYNOPSIS
       #include <string.h>

       void *memccpy(void *restrict s1, const void *restrict s2,
            int c, size_t n);


       void *memchr(const void *s, int c, size_t n);


       int memcmp(const void *s1, const void *s2, size_t n);


       void *memcpy(void *restrict s1, const void *restrict s2, size_t n);


       void *memmove(void *s1, const void *s2, size_t n);


       void *memset(void *s, int c, size_t n);


       void *explicit_memset(void *s, int c, size_t n);


       void *memmem(const void *haystack, size_t haystacklen,
            const void *needle, size_t needlelen);

   C11 Bounds Checking Interfaces
       #define __STDC_WANT_LIB_EXT1__ 1
       #include <string.h>

       errno_t memcpy_s(void *restrict s1, rsize_t s1max,
           const void *restrict s2, rsize_t n);


       errno_t memmove_s(void *s1, rsize_t s1max,
           const void *s2, rsize_t n);


       errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n);

   ISO C++
       #include <string.h>

       const void *memchr(const void *s, int c, size_t n);


       #include <cstring>

       void *std::memchr(void *s, int c, size_t n);

DESCRIPTION
       These functions operate as efficiently as possible on memory areas (ar‐
       rays  of bytes bounded by a count, not terminated by a null character).
       They do not check for the overflow of any receiving memory area. Except
       for the C11 Bounds Checking Interfaces, they  do  not  check  for  null
       pointers,  and  programs may crash if passing null or otherwise invalid
       pointers to these functions. Use of adi(7) may help  in  detecting  in‐
       valid pointer usage in code.


       The  memccpy() function copies bytes from memory area s2 into s1, stop‐
       ping after the first occurrence of c (converted to  an  unsigned  char)
       has  been  copied,  or  after n bytes have been copied, whichever comes
       first. It returns a pointer to the byte after the copy of c in s1, or a
       null pointer if c was not found in the first n bytes of s2. If  copying
       takes place between objects that overlap, the behavior is undefined.


       The  memchr()  function  returns a pointer to the first occurrence of c
       (converted to an unsigned char) in the first n bytes (each  interpreted
       as  an unsigned char) of memory area s, or a null pointer if c does not
       occur.


       The memcmp() function compares its arguments, looking at  the  first  n
       bytes  (each  interpreted  as an unsigned char), and returns an integer
       less than, equal to, or greater than 0, according to whether s1 is lex‐
       icographically less than, equal to, or greater than s2 when taken to be
       unsigned characters. The execution time of the  memcmp()  function  may
       depend  on  the sequences being compared. For uses such as cryptography
       where invariant timing is desired, see timingsafe_memcmp(3C) instead.


       The memcpy() function copies n bytes from memory area s2 to s1. It  re‐
       turns  s1. If copying takes place between objects that overlap, the be‐
       havior is undefined - the memmove() function should be used instead for
       overlapping copies.


       The memmove() function copies n bytes from memory  area  s2  to  memory
       area  s1.  Copying  between  objects  that overlap will take place cor‐
       rectly. It returns s1.


       The memset() function sets the first n bytes in memory area  s  to  the
       value of c (converted to an unsigned char). It returns s.


       The explicit_memset() function performs the same operation as memset().
       It  differs  from  memset()  in that it will not be removed by compiler
       dead store analysis.  The  explicit_memset()  function  is  useful  for
       clearing no longer needed sensitive data to ensure that it does not re‐
       main accessible in process memory.


       The  memmem() function locates the start of the first occurrence of the
       substring needle of length needlelen in the  memory  area  haystack  of
       length haystacklen. It returns a pointer to the start of the substring,
       or  NULL  if the substring is not found. If needlelen is zero, haystack
       is returned. If haystacklen is less than needlelen, NULL is returned.

   C11 Bounds Checking Interfaces
       The memcpy_s(), memmove_s(), and memset_s() functions are part  of  the
       C11  bounds checking interfaces specified in the C11 standard, Annex K.
       Each provide equivalent functionality to the respective memcpy(),  mem‐
       move(),  and  memset()  functions, except with differing parameters and
       return type in order to provide explicit runtime-constraints as defined
       in  the  C11  standard.  See  runtime_constraint_handler(3C)  and   IN‐
       CITS/ISO/IEC 9899:2011.


       If  no  runtime-constraint  violation is detected, the memcpy_s(), mem‐
       move_s(), and memset_s() functions return zero. If a runtime constraint
       violation is detected and the handler returns, they return  a  non-zero
       value.

ERRORS
       No  errors are defined for the memccpy(), memchr(), memcmp(), memcpy(),
       memmove(), memset(), explicit_memset(), or memmem() functions. The  be‐
       havior  of these functions is undefined if null or invalid pointers are
       passed for any of their pointer arguments.


       The memcpy_s() function will fail if:

       EINVAL    NULL pointer passed or source and destination overlap.


       ERANGE    size argument is invalid, that is, s1max or n is greater than
                 RSIZE_MAX or n is greater than s1max.



       The memmove_s() function will fail if:

       EINVAL    NULL pointer passed.


       ERANGE    size argument is invalid, that is, s1max or n is greater than
                 RSIZE_MAX or n is greater than s1max.



       The memset_s() function will fail if:

       EINVAL    NULL pointer passed.


       ERANGE    size argument is invalid, that is, smax or n is greater  than
                 RSIZE_MAX or n is greater than smax.


USAGE
       Using  memcpy() might be faster than using memmove() if the application
       knows that the objects being copied do not overlap.

ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:

       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE  VALUE  _  Interface  StabilityCommitted  _ MT-LevelSee below _
       StandardSee below


   MT-Level
       The memccpy(), memchr(), memcmp(), memcpy(), memmove(),  memset(),  ex‐
       plicit_memset(), and memmem() functions are Async-Signal-Safe.


       The  memcpy_s(),  memmove_s(),  and memset_s() functions cannot be used
       safely in a multithreaded application due  to  the  runtime  constraint
       handler.  For  more information, see the runtime_constraint_handler(3C)
       man page.

   Standard
       See standards(7) for descriptions of the following standards:

       tab() box; cw(2.2i) |cw(3.3i) lw(2.2i)  |lw(3.3i)  INTERFACESAPPLICABLE
       STANDARDS _ T{ memchr(), memcmp(), memcpy(), memset() T}T{
         C89 through C11,
         POSIX.1-1990 through 2008,
         SUS through SUSv4,
         XPG1 through XPG7

       T} _ memmove()T{
         C89 through C11,
         POSIX.1-1990 through 2008,
         SUS through SUSv4,
         XPG4 through XPG7

       T} _ memccpy()T{
         POSIX.1-2001 through 2008,
         SUS through SUSv4,
         XPG1 through XPG7

       T}   _   T{   memcpy_s(),  memmove_s(),  memset_s()  T}C11  Annex  K  _
       explicit_memset(), memmem()None


SEE ALSO
       freezero(3C),  string(3C),  timingsafe_memcmp(3C),  wmemchr(3C),  wmem‐
       cmp(3C),  wmemcpy(3C),  wmemmove(3C), wmemset(3C), attributes(7), stan‐
       dards(7), runtime_constraint_handler(3C)

NOTES
       Overlap between objects being copied can arise even  when  their  (vir‐
       tual) address ranges appear to be disjoint; for example, as a result of
       memory-mapping  overlapping portions of the same underlying file, or of
       attaching the same shared memory segment more than once.

HISTORY
       The explicit_memset() function was added to Oracle Solaris in  the  So‐
       laris 11.4.12 release.


       The memcpy_s(), memmove_s(), and memset_s() functions were added to Or‐
       acle Solaris in the Solaris 11.4.0 release.


       The memmem() function was added to Oracle Solaris in the Solaris 11.0.0
       release.


       The  memccpy(),  memchr(), memcmp(), memcpy(), memmove(), annd memset()
       functions have been included in Solaris since the Solaris 2.0 release.

Oracle Solaris 11.4               2 Jun 2022                        memory(3C)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 5 CSS3