# strcpy

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           stpcpy, strcpy — copy a string and return a pointer to the end of
           the result
    


## SYNOPSIS



           #include <string.h>
    
           char *stpcpy(char *restrict _s1_ , const char *restrict _s2_);
           char *strcpy(char *restrict _s1_ , const char *restrict _s2_);
    


## DESCRIPTION



           For _strcpy_(): The functionality described on this reference page
           is aligned with the ISO C standard. Any conflict between the
           requirements described here and the ISO C standard is
           unintentional. This volume of POSIX.1‐2017 defers to the ISO C
           standard.
    
           The _stpcpy_() and _strcpy_() functions shall copy the string pointed
           to by _s2_ (including the terminating NUL character) into the array
           pointed to by _s1_.
    
           If copying takes place between objects that overlap, the behavior
           is undefined.
    


## RETURN VALUE



           The _stpcpy_() function shall return a pointer to the terminating
           NUL character copied into the _s1_ buffer.
    
           The _strcpy_() function shall return _s1_.
    
           No return values are reserved to indicate an error.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



       **Construction of a Multi-Part Message in a Single Buffer**
               #include <string.h>
               #include <stdio.h>
    
               int
               main (void)
               {
                   char buffer [10];
                   char *name = buffer;
    
                   name = stpcpy (stpcpy (stpcpy (name, "ice"),"-"), "cream");
                   puts (buffer);
                   return 0;
               }
    
       **Initializing a String**
           The following example copies the string **"----------"** into the
           _permstring_ variable.
    
               #include <string.h>
               ...
               static char permstring[11];
               ...
               strcpy(permstring, "----------");
               ...
    
       **Storing a Key and Data**
           The following example allocates space for a key using _malloc_()
           then uses _strcpy_() to place the key there. Then it allocates space
           for data using _malloc_(), and uses _strcpy_() to place data there.
           (The user-defined function _dbfree_() frees memory previously
           allocated to an array of type **struct element ***.)
    
               #include <string.h>
               #include <stdlib.h>
               #include <stdio.h>
               ...
               /* Structure used to read data and store it. */
               struct element {
                   char *key;
                   char *data;
               };
    
               struct element *tbl, *curtbl;
               char *key, *data;
               int count;
               ...
               void dbfree(struct element *, int);
               ...
               if ((curtbl->key = malloc(strlen(key) + 1)) == NULL) {
                   perror("malloc"); dbfree(tbl, count); return NULL;
               }
               strcpy(curtbl->key, key);
    
               if ((curtbl->data = malloc(strlen(data) + 1)) == NULL) {
                   perror("malloc"); free(curtbl->key); dbfree(tbl, count); return NULL;
               }
               strcpy(curtbl->data, data);
               ...
    


## APPLICATION USAGE



           Character movement is performed differently in different
           implementations. Thus, overlapping moves may yield surprises.
    
           This version is aligned with the ISO C standard; this does not
           affect compatibility with XPG3 applications. Reliable error
           detection by this function was never guaranteed.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *