Copiez "pointeur vers const" vers "pointeur vers non const" via memcpy

Cet avertissement vient de la suppression du qualificatif const dans le cadre de l'initialisation; ajouter simplement un cast explicite éviterait également l'avertissement.

const void *a = something;
void *b = (void *)a;

La section 6.5.4 de la norme décrit les contraintes sur le cast implicite des pointeurs:

Les conversions qui impliquent des pointeurs, autres que celles autorisées par les contraintes de 6.5.16.1, doivent être spécifié au moyen d'un cast explicite.

Et la seule contrainte sur la conversion explicite des pointeurs est:

Un type pointeur ne doit pas être converti en un type flottant. Un type flottant ne doit pas être converti en tout type de pointeur.

La section pertinente de la première règle, 6.5.16.1, contient la règle suivante pour une affectation simple:

l'opérande de gauche a un type de pointeur atomique, qualifié ou non qualifié, et (compte tenu du type l'opérande de gauche aurait après la conversion de lvalue) les deux opérandes sont des pointeurs vers qualifiés ou des versions non qualifiées de types compatibles, et le type pointé par la gauche a tous les qualificatifs du type pointé par la droite;

Enfin, la section 6.7.3 sur les qualificatifs a:

Si une tentative est faite pour modifier un objet défini avec un type qualifié const en utilisant un lvalue avec un type non qualifié const, le comportement n'est pas défini.

Cette phrase ne fournit pas beaucoup de valeur si les lvalues ​​avec des types non qualifiés const avec accès aux objets définis avec des types qualifiés const sont elles-mêmes indéfinies. Cela indique que vous pouvez explicitement convertir un const void * en void * et éviter l'avertissement sans introduire de comportement indéfini, car l'avertissement concerne spécifiquement une utilisation non valide du cast implicite via une simple affectation plutôt qu'une objection générale à la suppression du qualificatif const.

Vous pouvez copier le pointeur en toute sécurité. Le problème de sécurité potentiel est lorsque vous utilisez b . Puisqu'il est déclaré comme un pointeur vers des données non constantes, vous pouvez l'assigner via le pointeur, par exemple * (int * b) = 1; Si quelque chose est une donnée constante, cela entraînera un comportement non défini.

Si vous utilisez le pointeur void * comme conduit qui finira par passer le pointeur vers une fonction qui reconvertira le pointeur dans son type d'origine (comme la façon dont qsort ( ) utilise son argument pointeur), vous devriez pouvoir ignorer cet avertissement. Vous vous attendez à ce que cette fonction la transforme en un pointeur vers const et n'essaye pas de l'assigner par son intermédiaire.

Je ne pense pas qu'il y ait un moyen de déclarer un pointeur générique qui puisse être utilisé comme conduit pour des données const ou non const. Si vous le déclarez non-const, vous recevrez un avertissement lorsque vous lui attribuerez un pointeur const; si vous le déclarez const, vous ne pourrez pas l'utiliser pour les fonctions qui veulent un pointeur non-const.

L'initialisation void * b = a; n'est pas valide C, elle viole la règle d'affectation simple C17 6.5.16.1 (l'initialisation suit les règles d'affectation), qui stipule que dans l'ordre l'expression pour être valide:

... le type pointé par la gauche a tous les qualificatifs du type pointé par la droite.

Vous voudrez peut-être compiler avec -pedantic-errors pour obtenir des erreurs au lieu d'avertissements pour les violations du langage C.

Comme pour bien défini comportement - tant que vous dé-référencez le pointeur en utilisant le type correct des données réelles, il s'agit d'un comportement bien défini et le type du pointeur lui-même n'a pas beaucoup d'importance.

Je ne comprends même pas pourquoi vous devez convertir en void * , puisque le format de votre rappel est le suivant:

void* vector_lsearch (const void* key, const void* base, int (*comp)(const void*, const void*))
{
    const struct vector* vector = CONST_VECTOR(base);
    void* result = NULL;
    unsigned char* data = (unsigned char*)base;

    for (size_t i=0; i < vector->size; i++)
    {
        if (comp(&data[i*vector->szof], key) == 0)
        {
            result = data;
            break;
        }
    }
    return result;
}

Le seul problème est donc le type de retour de la fonction externe, qui pourrait être simplifié en quelque chose comme ceci:

int (*comp)(const void *, const void *)

CONST_VECTOR est louche cependant, on dirait que vous cachez un casting derrière une macro ou quelque chose comme ça?