erreur dans le passage de pointeur à une fonction (simple)

bonjour,
voila mon code, tres simple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <iostream>   void fonct(char *r) { std::cout << r[0] << std::endl; //affiche a r[0] = 'a'; // bugge ici, segfault }   int main() { std::cout << "Hello world!" << std::endl; char *chaine; chaine = "acdcsc"; fonct(chaine);   return 0; }

---

Pourquoi une segfault sur r[0] = 'a';?

Si jamais je fais: r = "abc";
Alors il n'y a aucun problème.

Merci de votre aide.

les chaines littérales sont constantes en C++

Code:

---

1 2	char chaine[] = "acdcsc";

---

pour éviter le problème

Et surtout, en C++ les chaînes de caractères c'est std::string, surtout pas char*.

Citation:

---

Envoyé par Laurent Gomila

Et surtout, en C++ les chaînes de caractères c'est std::string, surtout pas char*.

---

+1

L'avantage d'une std::string, c'est qu'elle permet tout ce que peut permettre un char*, mais qu'elle évite de nombreux désagrément, tout en fournissant, de plus, certaines fonctions intéressantes propres à leur fonctionnement...

Si vraiment, tu dois avoir recours à un char* (pour l'utiliser comme nom de fichier à ouvrir, par exemple, ou pour le passer comme argument à une fonction de type C), tu pourras toujours l'obtenir grace à machaine.c_str() ;)

Pour répondre à ton problème de manière plus scolaire :

tu déclares un pointeur sur une chaîne de caractères.
tu ne lui alloue pas de mémoire
résultat tu fais une segmentation fault.

solution 1 : tu utilises en C++ string comme le dit laurent.
solution 2 : plus orienté C que C++, tu alloues de la mémoire avec

Code:

---

variable = (char*)malloc(sizeof(char)*Nombre de caractères voulus dans ta chaîne)

---

:lahola:
Un travail n'a d'importance que si son résultat est très attendu

Citation:

---

Envoyé par Startux

Pour répondre à ton problème de manière plus scolaire :

tu déclares un pointeur sur une chaîne de caractères.
tu ne lui alloue pas de mémoire
résultat tu fais une segmentation fault.

solution 1 : tu utilises en C++ string comme le dit laurent.
solution 2 : plus orienté C que C++, tu alloues de la mémoire avec

Code:

---

variable = (char*)malloc(sizeof(char)*Nombre de caractères voulus dans ta chaîne)

---

:lahola:
Un travail n'a d'importance que si son résultat est très attendu

---

ou, un peu mieu quand meme, car plus dans l'optique du C++, en utilisant l'operateur new pour l'allocation

Code:

---

char *variable=new char[nombre de caractères voulus];

---

avec, pour la libération, appel à delete[] variable

EDIT:Quitte à donner des trucs bancaux, autant essayer qu'ils ne le soient pas trop quand meme ;):D:P

Merci beaucoup de vos réponses!

Finalement la solution suivante me convient très bien:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream> #include <string>   int main() { std::cout << "Hello world!" << std::endl; char *chaine; chaine = new char;   strcpy(chaine, "abc"); strcat(chaine, "def"); std::cout << chaine;   return 0; }

---

Merci de m'avoir éclairé!!

edit: je n'ai même pas besoin de strcpy, strcat suffit tout seul à chaque usage avec le new

Tu n'alloues qu'un caractère pour ta chaîne, et tu en copies 6. Tu as de la chance que ça marche (ça pourrait crasher).

Pourquoi ne pas vouloir utiliser std::string ?

parceque les seuls include que j'ai sont SDL et iostream, j'ai peur de gacher trop de mémoire avec les string


Sinon je n'alloue pas qu'un caractère, avec le new ca fait un pointeur non?

Regarde bien ce qui se serait passé avec une std::string :P

Code:

---

1 2 3 4 5 6 7 8 9

#include <iostream> //pour std::cout #include <string> //pour std::string int main() { std::string chaine="abcd"; chaine+="efgh"; std::cout<<chaine<<std::endl; }

---

En trois lignes (affichage inclus) j'ai fait exactement la meme chose que toi en 5... avec une sécurité que tu n'a pas atteinte (cf new char au lieu de new char[7])

Alors, pourquoi faire simple quand on peut faire compliqué :question:

d'accord je verrais c'est promis.;)

Citation:

---

Envoyé par coyotte507

parceque les seuls include que j'ai sont SDL et iostream, j'ai peur de gacher trop de mémoire avec les string

---

Honnetement, que craint tu de "gacher comme mémoire":question:

Citation:

---

Sinon je n'alloue pas qu'un caractère, avec le new ca fait un pointeur non?

---

non...

new alloue la mémoire et fournit l'adresse de la mémoire allouée au pointeur...
un pointeur, c'est char *chaine... ca doit prendre l'adresse à laquelle trouver la valeur (ou le tableau de valeur)
chaine=new char, ca a pour résultat d'allouer l'espace pour UN caractère, et de donner l'adresse à laquelle il se trouve à chaine...

pour allouer la mémoire pour 6 caractères (et il faut encore penser au '\0' final), c'est

Code:

---

1 2 3 4

chaine=new char[6]; // et comme on veut 6 caractères utiles ce serait meme variable= new char[7];//6 caractères utiles, 1 caractères pour le '\0' final

---

Moi qui ai pris beaucoup de temps pour comprendre le principe des pointeurs et des pointeurs de pointeurs en C, j'ai un peu du mal à m'en détacher :mouarf: . Du coup cela m'amène à une question :

le new c'est pour allouer de la mémoire mais pour ce qui est de la réallocation de mémoire comme le realloc ? ca marche comment ?

:lahola:
Travail toujours Travail, et le repos c'est pour quand ? :aie:

Citation:

---

Pourquoi faire simple quand on peut faire compliqué :?:

---

Tu veux que je continue à utiliser les char* ou tu trouve que les string sont compliquées?


Sinon j'ai regardé les références sur string et notamment la fonction substr() qui me sera utile par la suite, ainsi que l'on peut en retourner une facilement, donc je vais me ranger :mrgreen:

Je trouve les char* compliqués par rapport aux std::string, et, donc, cette phrase était un joke ;)

Citation:

---

Envoyé par Startux

le new c'est pour allouer de la mémoire mais pour ce qui est de la réallocation de mémoire comme le realloc ? ca marche comment ?

---

Ca marche pas avec new[].
Soit tu restes en C (types POD uniquement), soit tu passes vraiment en C++ et utilises le container adapté à ton problème.