memccpy

Copie les octets de l'objet pointé par src vers l'objet pointé par dest , en s'arrêtant dès que l'une des deux conditions suivantes est satisfaite :

• count octets sont copiés
• l'octet ( unsigned char ) c est trouvé (et copié).

Les objets src et dest sont interprétés comme des tableaux de unsigned char .

Le comportement est indéfini si une condition est remplie :

• l'accès se produit au-delà de la fin du tableau dest ;
• les objets se chevauchent (ce qui constitue une violation du contrat restrict )
• soit dest soit src est un pointeur invalide ou nul

Paramètres

Valeur de retour

Si l'octet ( unsigned char ) c est trouvé, memccpy retourne un pointeur vers l'octet suivant dans dest après ( unsigned char ) c . Sinon, il retourne un pointeur nul.

Notes

La fonction est identique à la POSIX memccpy .

memccpy ( dest, src, 0 , count ) se comporte de manière similaire à strncpy ( dest, src, count ) , sauf que la première renvoie un pointeur vers la fin du tampon écrit, et ne remplit pas de zéros le tableau de destination. Ainsi, memccpy est utile pour concaténer efficacement plusieurs chaînes de caractères.

char bigString[1000];
char* end = bigString + sizeof bigString;
char* p = memccpy(bigString, "John, ", '\0', sizeof bigString - 1);
if (p)
    p = memccpy(p - 1, "Paul, ", '\0', end - p);
if (p)
    p = memccpy(p - 1, "George, ", '\0', end - p);
if (p)
    p = memccpy(p - 1, "Joel ", '\0', end - p);
if (!p)
    end[-1] = '\0';
puts(bigString); // John, Paul, George, Joel

` et contient des termes spécifiques au C++. Seul le texte en dehors de ces balises aurait été traduit, mais dans ce cas, il n'y a pas de texte supplémentaire à traduire.

Exemple

#include <ctype.h>
#include <stdio.h>
#include <string.h>
int main(void)
{
    const char src[] = "Stars: Altair, Sun, Vega.";
    const char terminal[] = {':', ' ', ',', '.', '!'};
    char dest[sizeof src];
    const char alt = '@';
    for (size_t i = 0; i != sizeof terminal; ++i)
    {
        void* to = memccpy(dest, src, terminal[i], sizeof dest);
        printf("Terminal '%c' (%s):\t\"", terminal[i], to ? "found" : "absent");
        // if `terminal` character was not found - print the whole `dest`
        to = to ? to : dest + sizeof dest;
        for (char* from = dest; from != to; ++from)
            putchar(isprint(*from) ? *from : alt);
        puts("\"");
    }
    puts("\n" "Separate star names from distances (ly):");
    const char *star_distance[] = {
        "Arcturus : 37", "Vega : 25", "Capella : 43", "Rigel : 860", "Procyon : 11"
    };
    char names_only[64];
    char *first = names_only;
    char *last = names_only + sizeof names_only;
    for (size_t t = 0; t != (sizeof star_distance) / (sizeof star_distance[0]); ++t)
    {
        if (first)
            first = memccpy(first, star_distance[t], ' ', last - first);
        else
            break;
    }
    if (first)
    {
        *first = '\0';
        puts(names_only);
    }
    else
        puts("Buffer is too small.");
}

Terminal ':' (found):   "Stars:"
Terminal ' ' (found):   "Stars: "
Terminal ',' (found):   "Stars: Altair,"
Terminal '.' (found):   "Stars: Altair, Sun, Vega."
Terminal '!' (absent):  "Stars: Altair, Sun, Vega.@"
Separate star names from distances (ly):
Arcturus Vega Capella Rigel Procyon

Voir aussi