Discussion :

[makal]

Bonjour je veux une fonction qui trie et renvoie un tableau d'objets trié selon un de ses attributs..
Voici mon code........

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
#ifndef PROCESSUS_H
#define PROCESSUS_H
 
#include <iostream>
#include <stdlib.h>
#include <vector>
 
using namespace std;
 
class Processus{
	private:
		int num;
		int dureeEstime;
		int dateArrive;
  		int dureeSej;
		int dureeAtt;
		int priorite;
	public:
		Processus(int a,int b,int c);
		Processus();
		void affiche();
		void attribuerPriorite();
		Processus * triProcessus(Processus procs[], int nbr);
 
};
#endif

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
Processus * Processus::triProcessus(Processus proc[], int nb){
	Processus * process[nb] ;
	int minarr , i, j;
	for(i=0; i<nb; i++){
		minarr = i;
		for(j=i+1; j<nb ; j++){		
			if(proc[j].dateArrive < proc[minarr].dateArrive){
				minarr = j;
			}
		}
		process[i] = new          Processus(proc[minarr].num,proc[minarr].dureeEstime,proc[minarr].dateArrive);
	}
 
	return *process;
}

[imperio]

Au lieu d'envoyer un tableau d'objet, pourquoi ne pas envoyer un vector ?

Pourquoi ne pas faire un petit tour sur cette page ?

[koala01]

Salut,

De toutes façons:

1- Un processus est, typiquement, quelque chose qui a sémantique d'entité, ce qui implique parce que tu ne peux jamais avoir deux processus qui peuvent avoir des valeurs strictement identique en mémoire au même instant (autrement, comment être sûr que tu modifies bel et bien le processus que tu crois modifier )

Ce qui implique que tu peux envisager de trier tes processus selon différnts critères, mais qu'il n'y a strictement aucune raison d'implémenter un opérateur < "global" (les classes ayant sémantique d'entité ne sont pas comparables).

2- Tu ne dois jamais donner la responsabilité du tri d'objets aux objets qui doivent être triés : c'est, systématiquement "autre chose" qui s'occupe de trier les objets, éventuellement, sur base de critères bien déterminés.

3- Comme l'a si bien dit impero, tu devrais utiliser la classe std::vector pour maintenir tes (pointeurs vers les) différents objets.

[oodini]

Ce qui implique que tu peux envisager de trier tes processus selon différnts critères, mais qu'il n'y a strictement aucune raison d'implémenter un opérateur < "global" (les classes ayant sémantique d'entité ne sont pas comparables).

Même si on veut donner une priorité aux processus ?

[Médinoc]

Rien ne t'empêche de les trier par priorité, mais ce n'est pas aux processus qu'il revient de faire ça, c'est au conteneur. Les processus doivent seulement soit exposer directement en lecture leur priorité, soit exposer une fonction comparePriority() (mais jamais compare() tout court).

[koala01]

Même si on veut donner une priorité aux processus ?

A ce moment là, ton processus (ou "autre chose", qui peut être externe à ton processus) dispose de l'information ad-hoc.

Mais, si tu veux trier tes processus selon leur priorité, ce sera plus une fonction du genre lessByPriority ou toute autre que tu utiliseras

Le propre de quelque chose qui est identifié de manière unique est de ne permettre que la comparaison des éléments qui le composent, quel que soit l'élément envisagé pour la comparaison.

Le fait d'avoir un opérateur "<" (ou tout autre opérateur de comparaison possible) prend la sémantique de

Code :

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

Tel (processus, dans le cas présent) est plus petit que tel autre.

C'est très bien, mais plus petit selon quel critère

Selon son identifiant unique

Selon sa priorité

Selon la durée depuis laquelle il s'exécute

Il est impossible de le déterminer.

Du coup, tu te trouves avec un opérateur qui risque d'être utilisé à mauvais escient parce que chacun "verra midi à sa porte" et qu'un développeur envisagera une solution et un autre envisagera une autre solution, quand il n'y en aura pas un qui considérera que c'est d'abord la priorité, puis la durée depuis laquelle le processus s'effectue

Si tu ne peux pas assurer la sémantique d'un opérateur, le mieux est encore de ne pas définir cet opérateur, quitte à définir une fonction équivalente qui précise exactement ce qu'elle fait et dans quel ordre.

Il faut bien comprendre qu'un opérateur n'est jamais qu'un "sucre syntaxique": une manière de laisser le développeur aller vers sa fainéantise naturelle

[oodini]

Le fait d'avoir un opérateur "<" (ou tout autre opérateur de comparaison possible) prend la sémantique de

Code :

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

Tel (processus, dans le cas présent) est plus petit que tel autre.

C'est très bien, mais plus petit selon quel critère

La question reste valable avec les sémantiques de valeur, à partir du moment où les données sont composées de plusieurs valeurs.