slt tlm,
alors voila je suis pas très doué en langage c autant vous le dire tout de suite.
et la j'ai un probleme. J'ai creer une structure  
 

et je voudrais effectuer des opérations dessus en fait.
Donc voici ma fonction de calcul:
 

/*(oui j'ai mis seulement le cas +)*/
 

Moi ce que je voudrais c'est lorsque je rentre 3 4 +,
ca me retourne
7
3 + 4.
 
Voila. Je sais qu'il y a du boulot, qu'il y a des problemes de conversion de types, de concaténation de chaines, mais la ca m'enerve je ne sais plus par quel bout commencer. J'ai donc besoin d'aide.
 
Merci d'avance

En gros, tu rentres une expression postfixée, et tu veux obtenir

• son évaluation
• son écriture en infixe  

C'est ça ?

non pas forcément je peux rentrer aussi l'inverse.
En fait je veux que mon élement soit décrit par sa valeur et par l'expression qui a permi d'aboutir à la valeur. Mais je pense que j'utiliserai les expressions post fixées pour travailler

Moi je partirai sur une représentation en mémoire de ce genre pour 4 7 - 6 +
 
      +
     / \
    /   \
   -    6
  / \
 /   \
4    7
 
J'ai donc besoin de ce genre de définition :
 
// définition du type de noeud
typedef enum {valeur, operateur} t_noeud;
 
// Déclaration du data du noeud
typedef struct  
{
  t_noeud type;
  union
  {
     // l'opérateur est codé par son signe habituel '+' '-' '*' '/'  
     char operateur;
     // on se limite aux entiers
     int valeur;
  };
} data_noeud;
 
 
// déclaration d'un noeud de l'arborescence
typedef struct noeud
{
 data_noeud noeud;
 struct noeud *gauche;
 struct noeud *droite;
} noeud;
 
Le plus simple est de lire en postfixé et de construire l'arbre en utilisant une pile.
Après l'écriture de l'expression et son évaluation ne présentent pas de difficultés, c'est plus coton pour lire en infixe.
 
Il faut aussi écrire un analyseur syntaxique pour dire si on a lu un opérateur ou un nombre.

mais en fait ce que je voudrais qu'on me corrige c'est ma syntaxe. Parce que j'arrive pas a executer tout le programme. Il buggue. L'algo de postfixé je l'ai c'est pas un probleme.
Mais ma syntaxe doit etre fausse.
Comme par exemple a-t-on le  droit d'ecrire a->expression=a->valeur.??Si non comment dois je faire?

a-t-on le  droit d'ecrire a->expression=a->valeur.??
Ben non puisque a->valeur est de type int, et a->expression est de type pointeur de caractères.
 
Il faut vraiment que tu te plonges dans l'évaluation des expressions arithmétiques, sinon tu vas bricoler sans arriver à rien.

en fait ca je le sais que c'est pas du meme type. Mais comment puis je faire alors pour initialiser mon expression à sa valeur.
Car la premiere fois ma valeur et mon expression seront la meme chose.

sprintf()
 
 
et +1 Trap D, assure-toi de maîtriser les aspects du langage que tu t'apprètes à utiliser.

fais attention, les manipulations de chaines de caractères ne sont pas aussi simples que ça. Renseigne-toi sur la gestion des chaines de caractères en C. En particulier, strcat(), strlen(), strcpy(), ... pourraient t'être utiles. Toutes ces fonctions sont déclarées dans le fichier d'en-tête <string.h>
 
+1 Trap D pour l'utilisation d'arbres dans ce type de problèmes.
 
 
EDIT: prise en compte des remarques d'Emmanuel

Pas définies. Déclarées... Et c'est <string.h>.
 
http://mapage.noos.fr/emdel/notes.htm#definitions

Effectivement ; autant utiliser les termes exacts...
 
Merci pour la correction

Tu devrais essayer de nommer tes structures "s_qqchose" et tes types "t_qqchose". Ca rendra le code plus lisible, t'évitera de mettre des "_" inutiles et te permettra d'utiliser le token "Element" pour un nom de variable.

 
Par ailleurs, je sais pas si c'est bien propre de masquer l'étoile dans le nom du type (Emmanuel ?)
 

Je présume que tu voudrais concaténer dans "c->expression" une chaîne issue des deux chaînes "a->expression" et "b->expression". Bon, avant de tenter de remplir "c->expression" avec quoi que ce soit, t'es-tu rendu compte que tu vas remplir un pointeur pointant vers une zone de la mémoire que tu ne connais pas. Peut-être qu'à cet endroit tu as des variables utiles au programme... mais hop, on les écrase.
 
Soit tu définis le membre "expression" comme un tableau de caractères suffisamment grand pour contenir l'ensemble des expressions qui vont y aller (c'est pas évident vu que tu ne sais pas à l'avance ce qui va s'y accumuler); soit tu alloues de la mémoire à "expression" (malloc) avant d'y mettre quoi que ce soit.
 
Quand on manipules des pointeurs (style "type *pt" ), il ne faut jamais toucher à "*pt" sans avoir écrit auparavant "pt=<qqchose>"; le "qqchose" étant une instruction garantissant que "pt" contiendra une adresse valide pour qu'on puisse travailler avec ce qu'il y a à cette adresse ("*pt" ).

Je le déconseille...