J'ai vu la nouvelle ligne Je comprends le \ n code> utilisé 2 façons différentes dans quelques exemples de code que j'ai consultés. Le premier étant
'\ n' code> et le second étant
"\ n" code>. Quelle est la différence et pourquoi utiliseriez-vous le
'\ n' code>? P>
'\ n' code> représente un caractère et
"\ n" code> représente une chaîne mais cela est-il? P>
5 Réponses :
Je me rends compte que j'ai expliqué la différence, mais je n'ai pas répondu à la question. P>
lequel que vous utilisez dépend du contexte. Vous utilisez '\ n' code> est une constante de caractère. p>
"\ n" code> est un pointeur sur le tableau de caractères équivalent à
{'\ n', '\ 0'} code> (
\ n code> plus le terminateur null) p>
'\ n' code> si vous appelez une fonction qui attend un caractère, et
"\ n" code>, s'il s'attend à une chaîne. P>
Les guillemets simples désignent un caractère et des devis doubles désignent une chaîne. Selon le contexte, vous pouvez choisir le type de données avec lequel travailler. P>
donc l'utilisation est quelque chose comme ceci: p> donc en bref: l'un est un pointeur sur un tableau de caractères, l'autre est un seul caractère. P> p> '\ n' code> est un
char code> constante.
"\ n" code> est un
const char [2] code>. p>
"\ n" code> est un
Const caractère [2] code>, pas un
const char * code>. Le premier est implicitement convertible à ce dernier, cependant.
La différence n'a pas d'importance si vous l'écrivez dans un flux ordinaire. Dans presque tous les autres contextes, la différence compte. Un caractère n'est pas en général interchangeable avec une gamme de caractères ou avec une chaîne. P>
donc par exemple Toute fonction ou une opération que vous utilisez vous indiquera s'il est défini pour un char, pour une chaîne de style C, pour la surcharge, ou pour ni ni. p> '\ n' code> est un charme littéral.
"\ n" code> est un littéral à chaîne (une gamme de caractères, fondamentalement). P>
std :: COUT << "\ N"; code> a le même effet que
std :: COUT << '\ N'; P>.
std :: string code> a un constructeur qui prend un
const char * code>, mais il n'a pas de constructeur qui prend un
char < / code>. Vous pouvez écrire
std :: string ("\ n"); code>, mais
std :: string ('\ n'); code> ne compile pas. P>
std :: string code> a également un constructeur qui prend un
char code> et le nombre de fois pour le dupliquer. Il n'entre pas qui prend un
const char * code> et le nombre de fois pour le dupliquer. Vous pouvez donc écrire
std :: string (5, '\ n') code> et obtenir une chaîne composée de 5 caractères newline d'affilée. Vous ne pouvez pas écrire
std :: string (5, "\ n"); code>. P>
faute de frappe! J'ai oublié la barre oblique dans le second cas: std :: COUT << '\ N'; code>.
Je comprends que le "\ n" représente un char et "/ n" représente une chaîne mais fait cela? P> blockQuote>
Si vous comprenez cela, alors il devrait être clair que cela comporte bien. Les fonctions surchargées dans la bibliothèque standard C ++ cachent souvent ce fait, alors peut-être qu'un exemple de C sera plus utile:
puchar code> prend un seul caractère, alors seul
'\ n' code> est Correct, alors que
met code> et
printf code> Prenez une chaîne, et dans ce cas, seul
"\ n" code> est correct. P>