Quelle est la différence entre char a[] = ?chaîne?; et char *p = ?chaîne?;?

Comme le titre le dit, Quelle est la différence entre

char a[] = ?string?; and 
char *p = ?string?;

Cette question a été posée à moi en interview.
J'ai même pas de comprendre l'énoncé.

char a[] = ?string?

Ici ce qui est ? opérateur? Est-ce une partie d'une chaîne ou il a une certaine signification particulière?

Ne compile pas sur MSVC...
Le pari de l'interviewer signifiait " au lieu de ?. L' ? le symbole est utilisé pour le tertiaire de l'opérateur, mais ce n'est pas la bonne syntaxe pour elle.
C'est probablement un cas de mojibake. Ce n'est pas du C++.
Certainement n'est pas de compilateur sur C ou C++ compilateur.
return blah ? doFoo() : doOtherFoo(); est un exemple de l' ? de l'opérateur. Il est fonctionnellement équivalent à if (blah) return doFoo(); else return doOtherFoo();.
Il est possible que la question a été à l'aide de la début/fin de citations et de la police pour une raison quelconque ne pouvait pas trouver, donc rendu comme ?s.
Ma conjecture: le Code a été copié dans MS Word, des devis ont été convertis, et puis en quelque sorte de nouveau converti. Ou il manque une #define ? ". Ne sais pas si ça compile, mais.
difference-between-char-str-string-and-char-str-string
la question a été modifié (les points d'interrogation ont été remplacés par des guillemets doubles, le cas échéant) afin d'améliorer la visibilité sur Google et il a été explicitement demandé de ne pas reculer. Pourquoi avez-vous fait? Totalement imprudent de se déplacer.
La question a été modifié au point d'être unintelligble! J'ai eu à lire la question d'origine à même de comprendre ce qui était demandé.
Plus précisément, les points d'interrogation ont été une partie de l'OP question, donc le retrait de ces faits, il est impossible de comprendre ce qui était demandé.

InformationsquelleAutor Sachin Mhetre | 2012-02-27

c++pointers

La première est la matrice de l'autre pointeur.

La déclaration de tableau char a[6]; demandes que de l'espace pour six personnages de être mis de côté, d'être connu par le nom a. C'est, il y a un endroit nommé a au cours de laquelle six personnes peuvent s'asseoir. La déclaration de pointeur char *p; d'autre part, les demandes d'un endroit qui est titulaire d'un pointeur. Le pointeur est d'être connu par le nom p, et peut pointer vers n'importe quel char (contiguës ou tableau de caractères) n'importe où.

Les déclarations
 char a[] = "string";
 char *p = "string"; 
entraînerait des structures de données qui pourrait être représenté comme ceci:
     +---+---+---+---+---+---+----+
  a: | s | t | r | i | n | g |      +---+---+---+---+---+---+----+
a: | s | t | r | i | n | g | \0 |
+---+---+---+---+---+---+----+
+-----+     +---+---+---+---+---+---+---+ 
p: |  *======> | s | t | r | i | n | g |\0 |    
+-----+     +---+---+---+---+---+---+---+ 
 |
     +---+---+---+---+---+---+----+
     +-----+     +---+---+---+---+---+---+---+ 
  p: |  *======> | s | t | r | i | n | g |     +---+---+---+---+---+---+----+
a: | s | t | r | i | n | g | \0 |
+---+---+---+---+---+---+----+
+-----+     +---+---+---+---+---+---+---+ 
p: |  *======> | s | t | r | i | n | g |\0 |    
+-----+     +---+---+---+---+---+---+---+ 
 |    
     +-----+     +---+---+---+---+---+---+---+ 
Il est important de réaliser qu'une référence comme x[3] génère un code différent selon que x est un tableau ou un pointeur. Étant donné les déclarations ci-dessus, lorsque le compilateur voit l'expression a[3], il émet le code pour démarrer à l'emplacement a, déplacer trois éléments au-delà, et de récupérer le personnage il. Lorsqu'il voit l'expression p[3], il émet le code pour démarrer à l'emplacement p, de récupérer la valeur du pointeur, ajoutez les trois tailles de l'élément à l'aide du pointeur, et enfin de récupérer le caractère souligné. Dans l'exemple ci-dessus, les deux a[3] et p[3] arriver à être le personnage l, mais le compilateur n'y arrive différemment.

Source: comp.lang.c liste des questions-réponses · Question 6.2

Je parie @Sachin considérés comme des cas comme const char *p = "string"; p = "another string"; printf("%c", p[3]); (Oui, char *p = "string"; sera une erreur de compilation)
+1 pour le représentant de l'allocation de mémoire

InformationsquelleAutor

91

La ? semble être une faute de frappe, il n'est pas sémantiquement valide. Donc la réponse suppose la ? est une faute de frappe et ce qui explique probablement l'interviewer en fait destiné à le demander.

Les deux sont très différents, pour commencer:
1. La première crée un pointeur.
2. La seconde crée un tableau.
Lire sur pour des explications plus détaillées:

Le Tableau version:
```
char a[] = "string";  
```
Crée un tableau qui est assez grand pour contenir la chaîne de caractères littérale de "chaîne", y compris ses NULL terminator. Le tableau string est initialisé avec le littéral de chaîne "string". Le tableau peut être modifié à une date ultérieure. Aussi, la taille du tableau est connu, même au moment de la compilation, sizeof opérateur peut être utilisé pour déterminer sa taille.

Le pointeur de la version:
```
char *p  = "string"; 
```
Crée un pointeur sur une chaîne littérale "chaîne". C'est plus rapide que la matrice de version, mais la chaîne de caractères pointée par le pointeur ne doit pas être modifié, car il est situé dans une lecture que définis par l'implémentation de la mémoire. La modification d'une chaîne de caractères littérale résultats dans Comportement Indéfini.

En fait C++03 dénonçait^{[Ref 1]} utilisation de la chaîne de caractères littérale sans const mot-clé. Ainsi, la déclaration doit être:
```
const char *p = "string";
```
Aussi,vous besoin d'utiliser le strlen() fonction, et pas sizeof pour trouver la taille de la chaîne depuis le sizeof opérateur va vous donner la taille du pointeur de variable.

Quelle version est mieux et lequel dois-je utiliser?

Dépend de l'Usage.
- Si vous n'avez pas besoin de faire des changements à la chaîne, utilisez le pointeur de la version.
- Si vous avez l'intention de modifier les données, utilisez le tableau de la version.
_{Remarque: C'est un pas de C++, mais c'est C spécifique.}

Noter que, l'utilisation de la chaîne de caractères littérale sans const mot-clé est parfaitement valide en C.
Toutefois, la modification d'un littéral de chaîne est encore un Comportement Indéfini en C^{[Ref 2]}.

Cela soulève une question intéressante,

Quelle est la différence entre char* et const char* lorsqu'il est utilisé avec des littéraux de chaîne en C?

Pour Standerdese Fans:

^{[Ref 1]}C++03 Standard: §4.2/2

Un littéral de chaîne (2.13.4) qui n'est pas d'une grande chaîne littérale peut être convertie en une valeur r de type “pointeur vers char”; une grande chaîne littérale peut être convertie en une valeur r de type “pointeur vers wchar_t”. Dans les deux cas, le résultat est un pointeur vers le premier élément du tableau. Cette conversion est pris en compte uniquement si il y a un explicite approprié pointeur de type de cible, et pas quand il y a besoin de convertir une lvalue à une rvalue. [Remarque: cette conversion est obsolète. Voir l'Annexe D. ] aux fins de classement dans la résolution de surcharge (13.3.3.1.1), cette conversion est considérée comme un tableau de pointeur de conversion suivie par une qualification de conversion (4.4). [Exemple: "abc" est converti en “pointeur const char” comme un tableau de pointeur de la conversion, puis de “pointeur vers char” comme une qualification de conversion. ]

C++11 supprime simplement la citation ci-dessus, ce qui implique qu'il est illégal de code en C++11.

^{[Ref 2]}standard C99 6.4.5/5 "Littéraux de Chaîne - Sémantique":

Dans la traduction de la phase 7, un octet ou d'un code de valeur zéro est ajouté à chacun des caractères codés sur plusieurs octets de la séquence obtenue à partir d'une chaîne de caractères littérale ou des littéraux. Les caractères codés sur plusieurs octets de la séquence est ensuite utilisée pour initialiser un tableau de stockage statique de la durée et de longueur suffisante pour contenir la séquence. Pour la chaîne de caractères littéraux, les éléments du tableau sont de type char, et sont initialisées à chaque octet de la séquence de caractères multi-octets, pour le wide littéraux de chaîne, les éléments du tableau sont de type wchar_t, et sont initialisées avec la séquence de caractères larges...

Il n'est pas précisé si ces tableaux sont distinctes, à condition que leur éléments ont les valeurs appropriées. Si le programme tente de modifier un tel tableau, le comportement est indéfini.
- Toutes les techniques de raisonnement pour le downvote est très apprécié.
- +1 pour la mention littérale.
- Qu'entend-on par "C'est plus rapide"?
- Je suis en désaccord avec If you do not need to make any changes to the string, use the pointer version. - si vous n'avez pas besoin de faire des changements à la chaîne, vous voudrez probablement utiliser const char a[] = "string";, c'est à dire juste ajouter un const. Elle permet d'éviter la réinstallation, lorsque l'éditeur de liens dynamique fait son travail pendant le démarrage (sur Linux, au moins). Voir Comment écrire des bibliothèques partagées la section 2.4.1 pour une plus longue discussion.
InformationsquelleAutor Alok Save
12
```
char a[] = "string";
```
Ce alloue de la chaîne sur la pile.
```
char *p = "string";
```
Cela crée un pointeur sur la pile qui pointe vers le littéral dans le segment de données du processus.

? est celui qui l'a écrit ne sachant pas ce qu'ils faisaient.
- Je le pense aussi. Il doit être ajouté à tort.. de toute façon merci pour la réponse..
- La question étant de savoir est de demander pour plus de détails sur quelque chose de trivial, je pense que la réponse devrait explorer les possibilités dans plus de profondeur. Plus précisément, "char a[]... alloue...sur la pile" suppose qu'il y a à l'intérieur d'une fonction et pas global, et se réfère davantage à l' a[] tout en ne mentionnant que l'intérieur d'une fonction il y a en fait une copie de l'intégralité du texte de la constante de segment de données de la pile. char* utilisation qui crée un non-const pointeur sur la pile ou mondial dans le segment de données et initialise lors de l'exécution ou de (probablement) au moment de la compilation, respectivement, à l'adresse de la const texte.
- Cette réponse est fausse. Le 2ème extrait de code crée une erreur de compilation 😛
- En effet il est.Déclaration d'un pointeur vers un littéral de chaîne sans const qualificatif est déprécié en C++03, de Sorte que le deuxième extrait n'est pas légal de code C++.
- Il compile avec certains compilateurs (par exemple Microsoft Visual C++ 2010), alors quand en disant qu'il crée erreur de compilation, vous devriez être plus précis, écrivez version de compilateur, ou (comme il est fait mention dans d'autres réponse) que c'est contre le standard c++ (C++03 C++11).
InformationsquelleAutor Ignacio Vazquez-Abrams
7

Pile, tas, datasegment(et BSS) et un segment de texte sont les quatre segments de la mémoire des processus. Toutes les variables locales définies seront dans la pile. Dynmically mémoire allouée à l'aide de malloc et calloc sera dans le tas. L'ensemble de ces et variables statiques seront dans le segment de données. Segment de texte aura le code assembleur du programme et certaines constantes.

Dans ces 4 segements, segment de texte est le READ ONLY segment et dans l'ensemble des trois autres est pour READ et WRITE.

char a[] = "string"; - Cette proclamation va allouer de la mémoire pour les 7 octets dans la pile(car la variable locale) et elle permet de conserver tous les 6 caractères(s, t, r, i, n, g) plus le caractère NULL (\0) à la fin.

char *p = "string"; - Cette déclaration va allouer de la mémoire pour les 4 octets(si il est en 32 bits machine) dans la pile(parce que c'est aussi une variable locale) et maintenez le pointeur de la chaîne constante dont la valeur est "string". Ce 6 octet de la chaîne constante sera dans le segment de texte. C'est une valeur constante. Pointeur de variable p juste points de cette chaîne.

Maintenant a[0] (indice de 0 à 5) est-à-dire l'accès premier caractère de cette chaîne qui est dans la pile. Donc, nous pouvons faire écrire également à cette position. a[0] = 'x'. Cette opération est autorisée, car nous avons READ WRITE l'accès à la pile.

Mais p[0] = 'x' sera conduit à l'accident, parce que nous avons seulement READ l'accès à un segment de texte. Erreur de Segmentation se fera si nous ne tout écrire sur le segment de texte.

Mais vous pouvez changer la valeur de la variable p, parce que ses variables locales dans la pile. comme ci-dessous
```
char *p = "string";
printf("%s", p);
p = "start";
printf("%s", p);
```
Cela est autorisé. Ici, nous sommes à la modification de l'adresse stockée dans la variable d'indicateur p à l'adresse de la chaîne start(nouveau start est aussi un lire uniquement les données dans un segment de texte). Si vous souhaitez modifier les valeurs présentes dans *p les moyens allez-mémoire allouée dynamiquement.
```
char *p = NULL;
p = malloc(sizeof(char)*7);
strcpy(p, "string");
```
Maintenant p[0] = 'x' opération est autorisée, parce que maintenant nous avons écrit dans le tas.
- bonne explication, la seule chose que je ne suis pas sûr à ce sujet, sera littéral de chaîne d'être stockées dans le segment de texte ou dans le segment de données?
- Les littéraux de chaîne sont en lecture seule des données, de sorte que la plupart du compilateur utiliser pour stor en segment de texte.
- Ainsi, les octets de la chaîne de caractères littérale sont stockées dans le segment de texte, et cela est vrai pour chaque compilateur C?, et pour le C++?
InformationsquelleAutor rashok
6

char *p = "string"; crée un pointeur vers la mémoire où la chaîne de caractères littérale "string" est stocké. En essayant de modifier la chaine que p points à conduit à un comportement indéterminé.

char a[] = "string"; crée et initialise un tableau de son contenu, par l'aide de la chaîne littérale "string".

InformationsquelleAutor LihO
3

Ils diffèrent quant à l'endroit où la mémoire est stockée. Idéalement, le second doit utiliser const char *.

La première
```
char buf[] = "hello";
```
crée automatiquement un tampon assez grand pour contenir les caractères et les copies (y compris le terminateur null).

La seconde
```
const char * buf = "hello";
```
doit utiliser const et crée simplement un pointeur qui pointe à la mémoire stockée dans des statique de l'espace où il est illégal de le modifier.

L'inverse (du fait, vous pouvez modifier le premier en toute sécurité et de ne pas la deuxième), c'est qu'il est sûr de retourner le deuxième pointeur de fonction, mais pas la première. C'est parce que la deuxième restera valide pointeur de la mémoire en dehors de la portée de la fonction, la première ne sera pas.
```
const char * sayHello()
{
     const char * buf = "hello";
     return buf; //valid
}

const char * sayHelloBroken()
{
     char buf[] = "hello";
     return buf; //invalid
}
```
InformationsquelleAutor CashCow
1

a déclare un tableau de char valeurs -- un tableau de chars qui se termine.

p déclare un pointeur, qui se réfère à une immuable, résilié, chaîne C, dont l'exact emplacement de stockage est mise en œuvre définies. Notez que cela devrait être const-qualifiés (par exemple,const char *p = "string";).

Si vous l'imprimer à l'aide de std::cout << "a: " << sizeof(a) << "\np: " << sizeof(p) << std::endl;, vous verrez les différences de leurs tailles (remarque: les valeurs peuvent varier en fonction du système):
```
a: 7
p: 8
```
Ici, c'est quoi ? opérateur? Est-ce une partie d'une chaîne ou il a une certaine signification particulière?
char a[] = ?string?
Je suppose qu'ils ont été une fois guillemets "string", qui potentiellement ont été convertis en "guillemets", ne pouvait pas être représentée en tant que telle, le long de la voie, et ont été convertis en ?.
- Que rarement (par exemple, lorsque vous devez muter le char tampon).
- Si vous n'avez pas besoin de muter le char tampon, alors il devrait être un [static] const char a[] = "xyz";, pas const char* p = "xyz"; ni const char* const p = "xyz"; - l'ancien implique p peut être déplacée au point d'ailleurs, et si ce n'est pas prévu alors il est préférable de ne pas laisser la possibilité, et à la fois demander au compilateur de l'espace pour le pointeur de texte et à mon humble avis - montre juste un manque de précision du modèle mental de ce qui est demandé de le compilateur, et les déchets de l'espace et du temps dans un unoptimised construire.
- Je n'ai pas l'intention ou de l'intérêt dans le fait d'être insultant. Vous dites que je suis mal dans de nombreux contextes - je seulement parlé du "n'ont pas besoin de muter contexte", donc veuillez expliquer les nombreux scénarios dans lesquels je me trompe, et comment [static] const char[] résultats dans "le gaspillage d'espace et de temps".
- FYI glandium.org/blog/?p=2361
InformationsquelleAutor justin
0

Le C et le C++ sont très similaires Pointeur vers Tableau des relations...

Je ne peux pas parler pour l'exacte des emplacements de mémoire des deux déclarations que vous posez sur, mais j'ai trouvé qu'ils articles intéressants et utiles pour la compréhension de certaines différences entre la déclaration de Pointeur de char, et un char déclaration de Tableau.

Pour plus de clarté:

C Pointeur et un Tableau de la relation

C++ Pointeur vers un Tableau

Je pense qu'il est important de se rappeler qu'un tableau, dans le C et le C++, est un pointeur constant pour le premier élément du tableau. Et, par conséquent, vous pouvez effectuer l'arithmétique des pointeurs sur le tableau.

char *p = "chaîne de caractères"; <--- C'est un pointeur qui pointe vers la première adresse d'une chaîne de caractères.

la suite est également possible:
```
char *p;
char a[] = "string";

p = a; 
```
À ce point p maintenant référence à la première adresse de la mémoire de l'un (l'adresse du premier élément)

et ainsi de *p == 's'

*(p++) == 't' et ainsi de suite. (ou *(p+1) == 't')

et la même chose pourrait fonctionner pour un: *(a++) ou *(un+1) serait également l'égalité de 't'

InformationsquelleAutor meltdownmonk

Vous devez vous connecter pour publier un commentaire.

Le Tableau version:

Le pointeur de la version:

Quelle version est mieux et lequel dois-je utiliser?