Pourquoi je reçois; initialisation 'char ' avec une expression de type "const char " rejets qualificatifs?

Je ne peux pas comprendre pourquoi je reçois ce message d'avertissement de clang par moi-même:

function_prototype_const_modifier.c:13:8: warning: initializing 'char *' with an
      expression of type 'const char *' discards qualifiers
      [-Wincompatible-pointer-types]
        char *ptr1 = source;
              ^      ~~~~~~
1 warning generated.

Le code est très simple

#include<stdio.h>

char *my_strcpy(char *destination, const char *source);

int main(void) {
    char str1[] = "this is something";  
    char str2[] = "123456789123456789";
    my_strcpy(str2, str1);
    puts(str2);
    return 0;
}
char *my_strcpy(char *destination, const char *source) {
    char *ptr1 = source;
    char *ptr2 = destination;
    while(*ptr1 != '#include<stdio.h>
char *my_strcpy(char *destination, const char *source);
int main(void) {
char str1[] = "this is something";  
char str2[] = "123456789123456789";
my_strcpy(str2, str1);
puts(str2);
return 0;
}
char *my_strcpy(char *destination, const char *source) {
char *ptr1 = source;
char *ptr2 = destination;
while(*ptr1 != '\0') {
*ptr2++ = *ptr1++;
}
*ptr2 = '\0';
return destination;
}
') {
        *ptr2++ = *ptr1++;
    }
    *ptr2 = '#include<stdio.h>
char *my_strcpy(char *destination, const char *source);
int main(void) {
char str1[] = "this is something";  
char str2[] = "123456789123456789";
my_strcpy(str2, str1);
puts(str2);
return 0;
}
char *my_strcpy(char *destination, const char *source) {
char *ptr1 = source;
char *ptr2 = destination;
while(*ptr1 != '\0') {
*ptr2++ = *ptr1++;
}
*ptr2 = '\0';
return destination;
}
';
    return destination;
}

une idée?

OriginalL'auteur mko | 2012-10-22

13

source est un const char *, un pointeur const caractères, les caractères ne peut pas être changé par un déréférencement du pointeur (j'. e. source[0] = 'A'; est une violation de contrainte).

Toutefois, en l'assignant à un char * rejets cette contrainte; un simple char * suggère que les caractères pointée par le ptr1 pointeur ne sont pas constants, et vous pouvez maintenant écrire librement ptr1[0] = 'A'; sans se faire d'erreurs du compilateur (un "message de diagnostic").

Considérer ce que cela signifie quand vous passez une chaîne littérale. Depuis une chaîne de caractères littérale est "readonly" (c'est un const char []), en essayant de modifier son contenu est un comportement indéfini. Donc, si vous appelez
```
my_strcpy(destination, "Constant String");
```
mais dans le code, pour quelque raison que vous écrivez
```
ptr1[0] = 'A';
```
vous ne serez pas obtenir un compilateur message de diagnostic parce que ptr1 est un pointeur non-const caractères, mais votre programme continue à invoquer un comportement indéfini (et dans la pratique, le plus probable crash, depuis les littéraux de chaîne sont placés dans readonly régions de mémoire).

OriginalL'auteur
4

Vous avez juste besoin de changer:
```
char *ptr1 = source;
```
:
```
const char *ptr1 = source;
```
OriginalL'auteur Paul R
1

Parce que le type de L. H. S est char * et le type de R. H. S est const char *.

La raison est que ce message d'erreur indique:

function_prototype_const_modifier.c:13:8: avertissement: l'initialisation de 'char *' avec une expression de type "const char *" rejets qualificatifs

L'instruction permet de jeter les const qualificatif et il permet de modifier le relevé de la chaîne à travers ptr1 et ptr2 et donc le compilateur se plaint.

Je pense que const signifiait le pointeur a été constante, et non pas le pointee. Je serait une erreur.
Jan de le lire de droite à gauche (permet moi de toute façon). pointeur vers un caractère constant. char const * est un pointeur constant sur un caractère.
le const mot clé s'applique à l'expression à sa droite, si il n'y a pas de terme à sa droite, puis applique la const mot-clé à terme sur sa gauche.
d'accord. Et le terme de droite est char *, un pointeur de char.

OriginalL'auteur Alok Save
1

Vous êtes pointant vers la même zone dans la mémoire, mais pas en la qualifiant const ainsi, l'argument est.

Vous permettre ensuite le corps de la fonction à modifier cette partie de la mémoire qui est étiqueté const.

OriginalL'auteur alex
1

De l'affectation d'un pointeur vers un caractère constant à un pointeur sur un char.
En faisant cela, vous risquez de la modification de la caractère(s).

OriginalL'auteur Lews Therin

Dans ce cas, il suffit de parler de ce que nous pouvons faire.

Merci de la clarté de l'information pour @user529758.

Juste plus d'une réponse.

Modifié:

#include<stdio.h>

char *my_strcpy(char *destination, const char *source);

int main(void) {
    char str1[] = "this is something";  
    char str2[] = "123456789123456789";
    my_strcpy(str2, str1);
    puts(str2);
    return 0;
}
char *my_strcpy(char *destination, const char *source) {
    char *ptr1 = (char*)source;
    char *ptr2 = destination;
    while(*ptr1 != '#include<stdio.h>
char *my_strcpy(char *destination, const char *source);
int main(void) {
char str1[] = "this is something";  
char str2[] = "123456789123456789";
my_strcpy(str2, str1);
puts(str2);
return 0;
}
char *my_strcpy(char *destination, const char *source) {
char *ptr1 = (char*)source;
char *ptr2 = destination;
while(*ptr1 != '\0') {
*ptr2++ = *ptr1++;
}
*ptr2 = '\0';
return destination;
}
') {
        *ptr2++ = *ptr1++;
    }
    *ptr2 = '#include<stdio.h>
char *my_strcpy(char *destination, const char *source);
int main(void) {
char str1[] = "this is something";  
char str2[] = "123456789123456789";
my_strcpy(str2, str1);
puts(str2);
return 0;
}
char *my_strcpy(char *destination, const char *source) {
char *ptr1 = (char*)source;
char *ptr2 = destination;
while(*ptr1 != '\0') {
*ptr2++ = *ptr1++;
}
*ptr2 = '\0';
return destination;
}
';
    return destination;
}

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.