Discussion :

[odessos]

Bonjour,

J'ai besoin d'utiliser argc et argv dans une fonction assez loin du main.
Existe-il un moyen de récupérer ces arguments sans les faire passer d'objet en objet?

Merci.

[Bousk]

Bonsoir,

le meilleur moyen serait de les passer en paramètre des appels nécessaires.
Une autre "technique" moins propre pourrait consister à les stocker quelque part d'accessible depuis le 2° endroit. Après y'a des niveaux dans la propreté : en global, beurk, dans une classe spéciale avec add/get pourquoi pas, et on peut imaginer plusieurs variantes..

[Emmanuel Deloget]

Bonsoir,

le meilleur moyen serait de les passer en paramètre des appels nécessaires.
Une autre "technique" moins propre pourrait consister à les stocker quelque part d'accessible depuis le 2° endroit. Après y'a des niveaux dans la propreté : en global, beurk, dans une classe spéciale avec add/get pourquoi pas, et on peut imaginer plusieurs variantes..

Rappel : argc et argv sont deux constantes. N'étant pas modifiables, elles ne peuvent pas poser de problème si elle sont stockées en tant que globales.

Personnellement, je préfèrerais une autre approche, plus idiomatique : les traiter dans main(), et définir les conditions qui seront passées aux autres entités du programme. Ca n'a pas de sens de passer argc/argv à une fonction "assez loin de main" (quoi que ça signifie).

[odessos]

les traiter dans main(), et définir les conditions qui seront passées aux autres entités du programme. Ca n'a pas de sens de passer argc/argv à une fonction "assez loin de main" (quoi que ça signifie).

J'utilise une bibliothèque de résolution de systèmes linéaires qui requiert ces paramétres.

Elle est nécessaire dans la classe en bout de chaîne :

main
-> classe centrale des calculs
-> classe représentant une matrice avec un sens physique
-> classe de matrice creuse (abstraite)
-> classe représentant le format Csc (où j'utilise la bibliothèque de résolution)

De plus, il y a 4 classes qui dérivent de la classe matrice creuse ( ce serait dommage de leur faire passer argc et argv à tous)

Je vais essayer de les mettre en global

Merci en tout cas

[koala01]

Salut,

Déjà, il faudrait savoir quels sont les paramètres que tu envisages de récupérer par argv...

De prime abord, je dirait que, outre quelques flags éventuels, c'est essentiellement des noms de fichiers (un pour le nom de fichier d'entrée voire, peut etre un deuxième pour un nom de fichier de sortie).

Je te vois en effet assez mal commencer à fournir l'ensemble des valeurs d'une matrice à la main

Si je ne me trompe pas, le noms de fichier reçu sera sans doute au format csc, et la première chose que tu devras faire, c'est... lire le fichier d'entrée avec un instance de la classe qui gère ce format.

Si nom de sortie il y a, tu devras éventuellement le fournir à une deuxième de la classe qui gère le format afin de lui demander d'y écrire la matrice résultante.

Enfin, si flags il y a, c'est à 'instance de la classe de calcul qu'ils seront destinés afin de lui demander de faire les manipulation ad-hoc.

Mais cela signifie que ta classe gérant le format csc (je n'en connais pas le nom, donc je vais considérer qu'elle s'appelle "LibClass" ) présente sans doute une interface qui permet:

1. de lire un fichier dont on donne le nom ( read(filename) )
2. d'écrire dans un fichier dont on donne le nom ( write(filename) )
3. d'avoir quelques test pour savoir si c'est une matrice creuse ou pas (isEmpty(), isHollow(), isFull() )
4. de transmettre une matrice (creuse ou non)
5. de récuprer une matrice (creuse ou non)

Au final, ta fonction main devrait pouvoir ressembler, au pire, à quelque chose comme:

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
int main(int argc char **argv)
{
   /* récupération des arguments, dont le fichier d'entrée (inFilename)
    * le fichier de sortie (outFilename), et les différents flags */
   LibClass reader;
   reader.read(inFilename);
   Calculator calc;
   /* un type */ result
   if(reader.isHollow() )
   {
        HollowMatrix  mat= reader.getHollow();
        result = calc.execute( mat /* flags */
   }
   else
   {
        FullMatrix mat= reader.getFull();
        result = calc.execute( mat /* flags */
   }
   LibClass writer;
   writer.setMatrix(result);
   writer.write(outFilename);
   return 0;
}

Au mieux, toute cette logique est exécutée dans ta classe "calcul" et ta fonction main ressemblerait alors à quelque chose comme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main(int argc, char ** argv)
{
   /* récupération des arguments, dont le fichier d'entrée (inFilename)
    * le fichier de sortie (outFilename), et les différents flags */
    Calculator calc;
    calc.setInFilename(inFilename);
    calc.setOutFilename(outFilename);
    calc.setFlags(flags);
    calc.execute();
    return 0;
}

Et c'est la classe que j'ai nommé "Calculator" qui maintiendra les différents arguments et qui les utilisera pour demander à "LibClass" de lire ou d'écrire dans le nom de fichier, voire pour invoquer d'autres classes de la bibliothèque (car je présume qu'elle ne fait pas que lire et écrire dans un format donné ) quand c'est utile, dans une des fonctions appelée (peut etre de manière indirecte ) depuis la fonction execute

Ce qu'il faut comprendre, c'est que tes classe (dérivant de) "matrice creuse" et "matrice pleine" ne devrait pas avoir à connaitre les classes offertes par ta bibliothèque manipulant le format csc.

Il doit, éventuellement, y avor des possibilités de conversions entre tes classes et celles de la bibliothèque, mais tes propres classe ne sont là que pour servir "d'intermédiaire" éventuel entre les différentes parties de l'application, dont, pourquoi pas, pour être transmise à une IHM quelconque

Au passage, une matrice contenant essentiellement des valeurs numérique, elle a, classiquement, une sémantique de valeur (ce n'est, après tout, qu'un ensemble cohérent de valeurs ) et ne devrait donc pas servir de base à une hiérarchie de classe (pas d'héritage )

[odessos]

Déjà, il faudrait savoir quels sont les paramètres que tu envisages de récupérer par argv...

Ce sont des paramétres utiles à la bibliothèque de résolution pour son passage en MPI. C'est donc le nombre de processeurs et la liste des machines disponibles.
Mais c'est bien argc et argv dont j'ai besoin : la bibliothèque (écrite en C) doit être utilisée en commençant par MPI_Init_thread(&argc, &argv, required, &provided);

Je te vois en effet assez mal commencer à fournir l'ensemble des valeurs d'une matrice à la main

Le remplissage de la matrice se fait au fur et à mesure d'un calcul dans une autre classe
En fait on donne à l'exécution quel format de matrice on veut utiliser, pour pouvoir réaliser des comparaisons plus facilement (les bibliothèques de résolutions d'équation linéaires ne fonctionnent pas toutes avec le même format)

Ce qu'il faut comprendre, c'est que tes classe (dérivant de) "matrice creuse" et "matrice pleine" ne devrait pas avoir à connaitre les classes offertes par ta bibliothèque manipulant le format csc.

Elles ne les connaissent pas. La classe abstraite gérant les matrices creuse ("ISparseMat") posséde une méthode virtuelle solve()=0; , et chaque classe dérivé posséde sa propre bibliothèque de résolution adapté à son format