const char * vs char * (C ++)

Pour le programme suivant:

int DivZero(int, int, int);

int main()
{
    try {
        cout << DivZero(1,0,2) << endl;
    }
    catch(char* e)
    {
        cout << "Exception is thrown!" << endl;
        cout << e << endl;
        return 1;
    }
    return 0;
}

int DivZero(int a, int b, int c)
{
    if( a <= 0 || b <= 0 || c <= 0)
        throw "All parameters must be greater than 0.";
    return b/c + a;
}

À l'aide de char* e donnera

résilier appelé après avoir jeté un
exemple de 'const char*'

Selon Gestion Des Exceptions C++ , la solution est d'utiliser const char* à la place.

Lecture de fonction (const char *) par rapport à la fonction (char *) dit que

Le type de "Chaîne" est char*', notconst char*'

(c'est un C, je pense...)

Lecture supplémentaire sur un Débordement de Pile char* vs const char* en paramètre me dit la différence. Mais aucun d'eux adresse mes questions:

Il semble que les deux char* et chaîne* avoir de limite sur le nombre de caractères. Suis-je la corriger?
Comment ajouter le mot clé const à char* élimine cette limite? Je pensais que le seul but de const est de définir un indicateur qui dit "inmodifiable". Je comprends que const char* e signifie "le pointeur qui pointe vers inmodifiable type char".

La solution à cette erreur est d'utiliser const char* e.

Même const string* e ne fonctionne pas. (juste pour le plaisir de test...)

Quelqu'un peut-il expliquer, s'il vous plaît? Merci!!!!

Par ailleurs, je suis sur Ubuntu, compilé par GCC, sur Eclipse.

source d'informationauteur CppLearner

c++

18

Pourquoi êtes-vous lancer et attraper les cordes de toute façon?

Vous devriez vous lancer et à attraper les exceptions, par exemple std::runtime_error

La réponse à votre question est que, chaque fois que vous insérez une chaîne de caractères entre guillemets dans le code, il renvoie une valeur null const char*

La raison que votre code ne fonctionne pas comme ci-dessus, parce que c'est le mauvais type, de sorte que catch, n'est-ce pas attraper ce que vous avez à jeter. Vous êtes jeter un const char*.

Il n'y a pas de limite au nombre de caractères dans un tableau de char-delà de la taille de votre pile/tas. Si vous faites allusion à l'exemple que vous avez posté, cette personne avait créé un tableau de taille fixe, de sorte qu'ils étaient limités.
21

L'email que vous avez lié à propos de "Chaîne" est faux (et la confusion).

En gros:

char* est un pointeur vers une surabondance de tableau de caractères. Traditionnellement, nous considérons que ce sont un tableau à un C-string si il contient un ensemble de caractères valides suivie par un \0. Il n'y a pas de limite à la taille de la matrice.

const char* est un pointeur vers une surabondance de tableau de immuable caractères.

string* est un pointeur vers une std::string objet, et qui est complètement différent. C'est un objet dynamique qui encapsule une chaîne de caractères. À l'aide de std::string au lieu de C-strings peuvent vous rendre la vie bien plus facile, même si ils ont obtenu certains angles et beaucoup de méchant pièges; ils sont bien utile dans la recherche, mais ils ne sont pas pertinents pour la question.

"String" est une expression particulière qui renvoie un const char* pointant à la C-string (note: ce n'est pas vrai, mais c'est une simplification qui me permet de répondre à la question de manière concise).

Un char* peuvent être automatiquement convertis en const char*mais pas vice-versa. Notez que les anciennes compilateurs C++ a une exception spéciale pour le type de règles pour vous permettre de faire ceci:
```
char* s = "String";
```
...sans la production d'un type d'erreur; c'était pour C compatibilité. Moderne compilateurs C++ ne vous laisse pas faire (comme la récente gccs). Ils ont besoin de cette:
```
const char* s = "String";
```
. Le problème ici est que vous avez:
```
throw "All parameters must be greater than 0.";
```
...mais alors vous êtes en essayant de l'attraper avec:
```
catch(char* e)
```
Cela ne fonctionne pas, car le jet est en train de jeter un const char*qui ne peut pas être converti dans le type spécifié dans le catch, il ne s'agit donc pas de se faire prendre.

C'est pourquoi la modification de la capture:
```
catch (const char* e)
```
...).

Vous devez vous connecter pour publier un commentaire.