Différence entre char* et const char*?

Quelle est la différence entre

char* name

qui pointe vers une chaîne constante littérale, et

const char* name

qu'entendez-vous par "constant la chaîne littérale" en C (pas C++)
... char *nom peut être fait le point d'une constante chaîne de caractères littérale
la constante dans la "constante de chaîne littérale" est redondante, puisque tous les littéraux de chaîne sont en théorie constante des entités. C'est le contenu de la variable qui peut être constante ou mutables. Le "const" déclaration de simplement jeter une erreur de compilation si vous essayez de modifier le contenu du caractère pointé par "nom"
Simple: "char *name" le nom est un pointeur sur char, c'est à dire à la fois peut être changer d'ici. "const char *name" le nom est un pointeur const char c'est à dire pointeur peut changer, mais pas de char.

InformationsquelleAutor Iceman | 2012-03-23

c const pointers

337

char* est un mutable pointeur vers un mutable caractère ou chaîne de caractères.

const char* est un mutable pointeur vers un immuable caractère ou chaîne de caractères. Vous ne pouvez pas modifier le contenu de l'emplacement(s) de ce pointeur pointe. Aussi, les compilateurs sont tenus de donner des messages d'erreur lorsque vous essayez de le faire. Pour la même raison, la conversion de const char * à char* est obsolète.

char* const est un immuable pointeur (il ne peut pas pointer vers un autre emplacement) mais le contenu de l'endroit où il points sont mutable.

const char* const est un immuable pointeur vers un immuable caractère ou chaîne de caractères.
- La Confusion peut obtenir éclairci avec l'utilisation d'une variable après les déclarations mentionnées ci-dessus et en donnant la référence à cette variable.
- Wow, il est const char* const, cool!
- Vous avez manqué un de plus: char const *
- Je supose deux options avec mutable caractère/string sont très dangereux, car vous pourriez faire un segmetation faute de mémoire, et si vous êtes vraiment intelligent, vous pourrait pirater l'ordinateur. C'est pourquoi les compilateurs toujours montré mises en garde dans ces implémentations je pense
- Ne pas la mutation char * donner de l'erreur de segmentation lors de l'exécution?
- J'ai donc utiliser const si je veux le compilateur à donner d'erreur si j'ai oublié et changé les données par erreur, non ?
- Est-il possible d'en attribuer un à l'autre et vice-versa?
InformationsquelleAutor ankit.karwasra
41
```
char *name
```
Vous pouvez modifier le char qui name points, et aussi le char sur lequel il pointe.
```
const char* name
```
~~Vous pouvez changer le char qui name points, mais vous ne pouvez pas modifier le char sur lequel il pointe.~~

correction: Vous pouvez modifier le pointeur, mais pas le char qui name points (https://msdn.microsoft.com/en-us/library/vstudio/whkd4k6a(v=vs. 100).aspx, voir la section "Exemples"). Dans ce cas, le const spécificateur s'applique à char, pas l'astérisque.

Selon la page MSDN et http://en.cppreference.com/w/cpp/language/declarations, le const avant la * fait partie de la decl-spécificateur de séquence, tandis que le const après * est la partie de la déclaration.

Une déclaration spécificateur de séquence peut être suivi par plusieurs declarators, c'est pourquoi const char * c1, c2 déclare c1 comme const char * et c2 comme const char.

EDIT:

Les commentaires, votre question semble se poser à propos de la différence entre les deux déclarations lorsque le pointeur pointe vers une chaîne littérale.

Dans ce cas, vous ne devrait pas modifier le char qui name points, car il pourrait Comportement Indéfini.
Les littéraux de chaîne peut être attribuée dans la mémoire en lecture seule des régions (définie par l'implémentation) et un programme utilisateur ne doit pas modifier de toute façon. Toute tentative de le faire entraîne un Comportement non défini.

De sorte que la seule différence dans ce cas (d'utilisation avec des littéraux de chaîne), c'est que la deuxième déclaration vous donne un léger avantage. Les compilateurs seront généralement vous donner un avertissement dans le cas où vous essayez de modifier la chaîne de caractères littérale dans le second cas.

En Ligne, Échantillon De Exemple:
```
#include <string.h>
int main()
{
    char *str1 = "string Literal";
    const char *str2 = "string Literal";
    char source[] = "Sample string";

    strcpy(str1,source);    //No warning or error, just Undefined Behavior
    strcpy(str2,source);    //Compiler issues a warning

    return 0;
}
```
De sortie:

cc1: les mises en garde d'être traitées comme des erreurs

prog.c: In function ‘main’:

prog.c:9: erreur: passing argument 1 of ‘strcpy’ ignore qualificatifs de pointeur de type de cible

Avis le compilateur indique le second cas, mais pas pour le premier.
- Merci.. j'ai mixé avec la constante chaîne de caractères littérale, qui est définie ainsi: char* nom = "Chaîne de caractères Littérale"; "changent la Chaîne Littérale" n'est pas définie..
- Euh, Attendez! Parlez-vous des pointes de pointage pour les littéraux de chaîne ici? Dans ce cas, Vous ne devrait pas modifier le char qui le name points dans les deux cas.Il pourrait en résulter en UB.
- Oui, qui était le point. Donc, dans ce cas char* nom et const char* nom se comportent de manière semblable, non?
- J'ai mis à jour la réponse à l'adresse de votre requête. Hth.
- Cette réponse est très ambigu ou tout simplement faux. Je interpréter "Vous ne pouvez pas modifier le char à qui le nom des points, mais Vous pouvez modifier le char sur lequel il pointe." De ne pas être en mesure de modifier le pointeur lui-même, mais être en mesure de modifier l'emplacement de la mémoire qu'il points de, ce qui est incorrect: ideone.com/6lUY9s sinon, pour le pur C: ideone.com/x3PcTP
- Vous avez besoin d'en apprendre un peu plus sur les comportements Indéfinis, et de la nécessité de faire une distinction entre: permis et ne devrait pas être fait. 🙂
- Merci de faire la correction strcpy(str1,source); //le Compilateur émet un avertissement ici. et le Comportement est indéfini. strcpy(str2,source); //le Compilateur émet une erreur
InformationsquelleAutor Alok Save

char mystring[101] = "My sample string";
const char * constcharp = mystring; //(1)
char const * charconstp = mystring; //(2) the same as (1)
char * const charpconst = mystring; //(3)

constcharp++; //ok
charconstp++; //ok
charpconst++; //compile error

constcharp[3] = 'char mystring[101] = "My sample string";
const char * constcharp = mystring; //(1)
char const * charconstp = mystring; //(2) the same as (1)
char * const charpconst = mystring; //(3)
constcharp++; //ok
charconstp++; //ok
charpconst++; //compile error
constcharp[3] = '\0'; //compile error
charconstp[3] = '\0'; //compile error
charpconst[3] = '\0'; //ok
//String literals
char * lcharp = "My string literal";
const char * lconstcharp = "My string literal";
lcharp[0] = 'X';      //Segmentation fault (crash) during run-time
lconstcharp[0] = 'X'; //compile error
//*not* a string literal
const char astr[101] = "My mutable string";
astr[0] = 'X';          //compile error
((char*)astr)[0] = 'X'; //ok
'; //compile error
charconstp[3] = 'char mystring[101] = "My sample string";
const char * constcharp = mystring; //(1)
char const * charconstp = mystring; //(2) the same as (1)
char * const charpconst = mystring; //(3)
constcharp++; //ok
charconstp++; //ok
charpconst++; //compile error
constcharp[3] = '\0'; //compile error
charconstp[3] = '\0'; //compile error
charpconst[3] = '\0'; //ok
//String literals
char * lcharp = "My string literal";
const char * lconstcharp = "My string literal";
lcharp[0] = 'X';      //Segmentation fault (crash) during run-time
lconstcharp[0] = 'X'; //compile error
//*not* a string literal
const char astr[101] = "My mutable string";
astr[0] = 'X';          //compile error
((char*)astr)[0] = 'X'; //ok
'; //compile error
charpconst[3] = 'char mystring[101] = "My sample string";
const char * constcharp = mystring; //(1)
char const * charconstp = mystring; //(2) the same as (1)
char * const charpconst = mystring; //(3)
constcharp++; //ok
charconstp++; //ok
charpconst++; //compile error
constcharp[3] = '\0'; //compile error
charconstp[3] = '\0'; //compile error
charpconst[3] = '\0'; //ok
//String literals
char * lcharp = "My string literal";
const char * lconstcharp = "My string literal";
lcharp[0] = 'X';      //Segmentation fault (crash) during run-time
lconstcharp[0] = 'X'; //compile error
//*not* a string literal
const char astr[101] = "My mutable string";
astr[0] = 'X';          //compile error
((char*)astr)[0] = 'X'; //ok
'; //ok

//String literals
char * lcharp = "My string literal";
const char * lconstcharp = "My string literal";

lcharp[0] = 'X';      //Segmentation fault (crash) during run-time
lconstcharp[0] = 'X'; //compile error

//*not* a string literal
const char astr[101] = "My mutable string";
astr[0] = 'X';          //compile error
((char*)astr)[0] = 'X'; //ok

Aucun de vos pointeurs point de "constante de littéraux de chaîne", comme dans la question.
Il est intéressant de noter que la modification de la char * valeur donne une segmentation fault depuis que nous essayons de modifier une chaîne littérale (qui est présent dans la mémoire en lecture seule)

InformationsquelleAutor Afriza N. Arief

9

Dans les deux cas, pouvez-vous modifier une chaîne littérale, indépendamment de si le pointeur vers une chaîne littérale est déclarée comme char * ou const char *.

Cependant, la différence est que si le pointeur est const char * alors le compilateur doit donner un diagnostic, si vous essayez de modifier le pointu de valeur, mais si le pointeur est char * alors il n'a pas.
- "Dans les deux cas, pouvez-vous modifier une chaîne littérale, indépendamment de si ... [il] s'est déclaré en tant que char * ou const char *" je suis d'accord que le programmeur ne doit pas essayer, mais dites-vous que chaque compilateur C, sur chaque plate-forme de rejeter le code, les dispositions nécessaires pour le code d'échouer au moment de l'exécution, ou quelque chose d'autre? Je crois, un fichier peut avoir la définition et initialisation, et un autre fichier peut contenir des extern ... name et ont *name = 'X';. Sur le bon système d'exploitation", qui peut échouer, mais sur des systèmes embarqués, je m'attends à faire quelque chose de plate-forme/compilateur spécifique.
- Vous ne pouvez pas modifier une chaîne de caractères littérale correcte C programme. Ce qui est incorrect programme C qui essaie peut résultat en est ni ici ni là.
- caf - quelle est la définition d'un bon programme C?
- Une définition utile est un programme qui ne se casse pas les contraintes spécifiées par la norme du langage C. En d'autres termes, un programme qui modifie un littéral de chaîne est incorrect de la même manière que celui qui déréférence un pointeur null ou effectue une division par 0 est incorrect.
- caf - j'ai pensé que peut-être ce que vous vouliez dire. Puis "Dans les deux cas, le peut vous modifiez une chaîne littérale" semble être sur l'énonçant. Il serait plus exact de dire "Dans les deux cas, les contraintes spécifiées par la norme du langage C qui ont été cassés, peu importe.... Il n'est pas possible pour le compilateur ou de l'exécution du système à détecter les manquements à la norme dans tous les cas." Je suppose que le standard prend la position que l'effet n'est pas défini?
- Oui, le comportement est indéfini. Je dirais aussi que vous ne pouvez pas déréférencer un pointeur null dans un bon programme C (indépendamment du fait qu'il pourrait ne pas produire un dangereux sur certaines implémentations spécifiques), et je ne pense pas que cela serait considéré comme une position controversée.
- Lorsqu'une norme ne peut pas dire quoi que ce soit de toute façon, je pense que de définir le comportement comme étant 'undefined' semble être exactement la limite droite et utile. Pour affirmer la relation d'une "correction de programme C' 'pas déréférencement d'un pointeur null' sons équivalente à démontrer le problème de l'arrêt. Mais je ne me dérange pas. Je ne voudrais pas le faire et de s'attendre à sortir avec elle "scott free": -)
InformationsquelleAutor caf
2

La première vous pouvez réellement changer si vous le souhaitez, le deuxième vous ne pouvez pas. Lire const justesse (il y a quelques belles guides à propos de la différence). Il est également char const * name où vous ne pouvez pas peretochki il.
- Qu'est-ce exactement peut changer?
InformationsquelleAutor chikuba
2

CAS 1:
```
char *str = "Hello";
str[0] = 'M'  //No warning or error, just Undefined Behavior
```
Ci-dessus jeux de str à point à la valeur littérale "Bonjour", qui est codé en dur dans le programme de l'image binaire, qui est marqué en lecture seule dans la mémoire, les moyens de tout changer dans cette Chaîne littérale est illégal et que jeter de la segmentation des défauts.

CAS 2:
```
const char *str = "Hello";
str[0] = 'M'  //Compiler issues a warning
```
CAS 3:
```
char str[] = "Hello";
str[0] = 'M'; //legal and change the str = "Mello".
```
InformationsquelleAutor Mohit
1

En fait, char* name n'est pas un pointeur vers une constante, mais un pointeur vers une variable. Vous pouvez parler au sujet de cette question.

Quelle est la différence entre char * const et const char *?

InformationsquelleAutor Jeff Wolski
1

La question est de savoir quelle est la différence entre
```
char *name
```
qui pointe vers une chaîne constante littérale, et
```
const char *cname
```
I. e. compte tenu de
```
char *name = "foo";
```
et
```
const char *cname = "foo";
```
Il n'y a pas beaucoup de différence entre les 2 et les deux peuvent être considérées comme correctes. En raison de la longue tradition de code en C, les chaînes de caractères littérales ont eu un type de char[], pas const char[], et il y a beaucoup de vieux code que, de même accepter char * au lieu de const char *, même quand elles n'altèrent pas les arguments.

La principale différence entre les 2 est que *cname ou cname[n] donnera des lvalues de type const char, alors que *name ou name[n] donnera des lvalues de type char, qui sont modifiable lvalues. Conforme compilateur est nécessaire pour produire un diagnostic message si objectif de la mission n'est pas une lvalue modifiable; il n'a pas besoin de produire un avertissement sur l'affectation à lvalues de type char:
```
name[0] = 'x'; //no diagnostics *needed*
cname[0] = 'x'; //a conforming compiler *must* produce a diagnostics message
```
Le compilateur n'est pas nécessaire pour arrêter la compilation dans les deux cas; c'est assez qu'il produit un avertissement pour que la cession cname[0]. Le programme qui en résulte n'est pas un corriger programme. Le comportement de la construction est undefined. Il peut tomber en panne, ou pire encore, il pourrait ne pas se bloquer, et peut-être changer de chaîne littérale dans la mémoire.

InformationsquelleAutor Antti Haapala

Juste pour donner un exemple supplémentaire:

    std::cout << typeid(2.3).name() << '\n'; //-----> prints "double" simply because
    //2.3 is a double
    //But the "double" returned by typeid(2.3).name() is indeed a 
    //const char * which consists of 'd','o','u','b','l','e'and'    std::cout << typeid(2.3).name() << '\n'; //-----> prints "double" simply because
//2.3 is a double
//But the "double" returned by typeid(2.3).name() is indeed a 
//const char * which consists of 'd','o','u','b','l','e'and'\0'.
//Here's a simple proof to this:
std::cout << typeid(typeid(2.3).name()).name() << '\n'; //prints: "const char *"
const char* charptr
charptr = typeid(2.3).name();
std::cout << charptr[3]; //--------->  prints: "b"
'.
    //Here's a simple proof to this:
    std::cout << typeid(typeid(2.3).name()).name() << '\n'; //prints: "const char *"
    const char* charptr
    charptr = typeid(2.3).name();
    std::cout << charptr[3]; //--------->  prints: "b"

(Je suis en utilisant le typeinfo bibliothèque: http://www.cplusplus.com/reference/typeinfo/type_info/name)

    //Now let's do something more interesting:
    char* charptr2="hubble";
    strcpy(charptr, charptr2);  //--------> Oops! Sorry, this is not valid!

Vous pouvez l'exécuter et de voir les choses mieux pour vous-même.

la question est sur C, et pourtant vous répondez avec du code C++.

InformationsquelleAutor M-J

Vous devez vous connecter pour publier un commentaire.