Association entre deux classes (partager les methodes)

**shaiton** · 17/02/2009, 23h02

Bonjour,
ca fait un moment que je cherche, mais je n'ai pas reussi a implementer mon bonheur :p

J'ai deux classes, Process qui gere le systeme, et User qui gere l'interface utilisateur.
User demande des saisies au clavier, et les envois a Process pour les gerer. Et Process, lance une methode User puis test l'etat dans lequel est User.
Donc User a besoin de Process.
Je veux pouvoir utiliser les methodes de Process avec User, mais egalement les objets qui composent Process. En gros, j'aimerai
que les deux classes soient "friend".
D'ou l'association.

Voici ce que j'aia vous montrer. J'ai simplifie au maximum (tout public, pas de test ...)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#ifndef USER_H
#define USER_H
 
class Process;
 
class User{
public:
	int x;
	Process* process;
 
	User() {
    	x = 0;
	}
 
	void attach(Process* proc){
		process = proc;
	}
  	void ad(void){
  		x = 2;
  		//process->add();
  	}
  	void substract(void){
  		x--;	
  	}
};
 
 
class Process{
public:
	int angle;
	User *user;
 
	Process(){
    	angle = 0;
	}
	void attach(User* usr){
  		user = usr;
  	}
  	void add(void){
  		angle++;	
  	}
  	void sub(void){
  		user->substract();;	
  	}
};
 
 
#endif

Voila le main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "User.h"
 
#include <stdio.h>
#include <unistd.h>
#include <iostream>
using namespace std;
// Test/example usage 'main' for simple associations.
int main () 
{
  User user1;
  Process process1;
 
  // Associate 
  user1.attach(&process1);
  process1.attach(&user1);
 
	process1.angle=3;
	user1.x=44;
 
  // Test association b1/a1 directly
  printf("This should be %d => %d\n", user1.x, process1.user->x);
  printf("this should be %d => %d\n\n", process1.angle, user1.process->angle);
 
 // user1.ad();
  process1.sub();
 
  printf("This should be %d => %d\n", user1.x, process1.user->x);
  printf("this should be %d => %d\n", process1.angle, user1.process->angle);
 
  return 0;
}

Ca veut fonctionner de cette maniere, je ne dois donc pas etre loin. Le probleme c'est que mes classes ne "dialogues" que dans un seul sens.

SI je decommente le //process->add(); dans ad(), erreur de compilation

method `void User::ad()':
invalid use of undefined type `class Process'
forward declaration of `class Process'
cc: /usr/lib/gcc-lib/ntox86/2.95.3/cc1plus error 33

Vous allez me demander pourquoi je ne regroupe pas les deux classes en une seule ...

En fait c'est pour un system embarque temps reel. Les deux classes sont des thread, parce que je ne veux pas rester bloque en attendant une entree clavier par l'utilisateur.

Qu'est-ce que j'ai fais d'horrible ??
Une maniere plus elegante (et juste) de faire ?
J'ai beaucoup cherche, mais je n'ai trouve aucun exemple, seulement un template http://www.flipcode.com/archives/A_S...te_for_C.shtml mais j'obtiens la meme erreur.

Merci beaucou pour n'importe quelles pistes ... je n'en dors (presque) plus

**KorWipe** · 18/02/2009, 00h29

Tu as un problème de dépendance cyclique au niveau de l'implémentation.
Il faut que tu dispatches tes classes dans un fichier .h pour la déclaration et .cpp pour l'implémentation au lieu de tout avoir dans un seul fichier (il est d'ailleurs conseillé de toujours appliquer ce découpage pour chaque classe (sauf pour les templates qui est un cas un peu spécial), ca permet de réduire les dépendances et cela peut améliorer le temps de compilation notamment donc pourquoi s'en priver

).

De cette manière, le compilateur se suffira des forward declaration (que tu avais déjà écrit) lors de la lecture des .h, par contre il aura besoin de connaitre entièrement chacun des types pour la compilation des .cpp. Il suffit pour cela de mettre un #include et le tour est joué.

Ca doit donner quelque chose comme ça:
Fichier user.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#ifndef USER_H
#define USER_H
 
class Process;         // <= forward declaration
 
class User{
public:
	int x;
	Process* process;
 
	User();
	void attach(Process* proc);
  	void add();
  	void substract();
};
 
#endif

Fichier user.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
 
#include "user.h"
#include "process.h"       // <= include afin de connaitre entièrement la declaration du type
 
User::User() 
:process(NULL)
,x(0)
{
}
 
void User::attach(Process* proc)
{
        process = proc;
}
 
void User::add(void)
{
	x = 2;
	process->add();
}
 
void User::substract(void)
{
	x--;	
}

Fichier process.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#ifndef PROCESS_H
#define PROCESS_H
 
class User;         // <= forward declaration
 
class Process{
public:
	int angle;
	User *user;
 
	Process();
	void attach(User* usr);
  	void add(void);
  	void sub(void);
};
 
#endif

Fichier process.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
 
#include "process.h" 
#include "user.h"       // <= include afin de connaitre entièrement la declaration du type
 
Process::Process()
:angle(0)
,User(NULL)
{
 
}
 
void Process::attach(User* usr)
{
	user = usr;
}
 
void Process::add(void)
{
	angle++;	
}
 
void Process::sub(void)
{
        user->substract();
}

**shaiton** · 18/02/2009, 16h45

YES !!

Merci beaucoup KorWipe.
En fait j'avais vue cette belle maniere de programmer ... mais je me suis adapte au programme existant du prof ... Je n'aurais pas due

A propos, il me semble que tu as une erreur de majuscule dans Process.cpp, c'est user(NULL) et non User(NULL).

Je joins l'archive de mon projet, ca pourra aider (d'autre, et moi :p)