Discussion :

[Nikolai]

Bonjour,

je code actuellement un programme dans lequel j'utilise des fonctions pour remplir des vectors, comme la fonction suivante :

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
void VC1( vector< double > & coord )
{
  string line;
  ifstream myfile ("test3.txt");
 
 
  if (myfile.is_open())
  {
 
    coord.reserve(2500);
    while ( getline (myfile,line))
      {
 
      stringstream ss(line);
 
	double nombre1;
    double nombre2;
	double nombre3;
	char   sep;
 
 
	while(ss >> nombre1 >> sep >> nombre2 >> sep >> nombre3)
	    {
		coord.push_back(nombre1-584848.847);
	    }
 
      }
 
    myfile.close();
  }
 
  else cout << "Unable to open file";
 
   cout << "tâche 1 terminée"<< ' ';
 
}

le problème de cette méthode est que je suis obligé de faire appel à cette fonction dans d'autres fonctions, pour utiliser le vector.
comment dois-je m'y prendre pour ne construire le vector qu'une seule fois, au début de mon programme, et simplement le rappeler après, sans avoir à le reconstruire ?
merci!

[hiura]

La réponse à cette question est très dure à donner étant donné qu'on ne connait pas ton application ( but et arch ) .

Que penses-tu d'une classes avec le vecteurs en attribut static, un bool pour indiqué s'il a été créé et une fonction statique aussi pour récupérer le vecteur ?

[Klaim]

Une solution rapide mais peut être dangereuse dans certains cas serait de stocker le résultat de cette fonction dans un vecteur statique, qui sera réutilisé pour fournir le resultat a chaque appel.

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
 
void VC1( vector< double > & coord )
{
  static vector< double > results; // ici
 
  // on ignore le reste si on a déjà le résultat
  if( results.empty() ) 
  { 
    // on récupère les résultats...
 
  string line;
  ifstream myfile ("test3.txt");
  //...
	while(ss >> nombre1 >> sep >> nombre2 >> sep >> nombre3)
	    {
		results.push_back(nombre1-584848.847); // hop le resultat dans le vecteur statique
	    }
 //...
 
   }
 
   // on fournis les résultats
   // on les "ajoute" en fait...
   coord.insert( coord.end() , results.begin(), results.end() );
   cout << "tâche 1 terminée"<< ' ';
 
}

Ou une variante retournant directement le vecteur de résultat (comme ça l'utilisateur fait ce qu'il veut avec.

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
const vector< double > & VC1()
{
   //...
   return results;
}
 
void test(  vector<double>& coord )
{
   // utilisation:
   const vector<double>& results = VC1();
   // par ajout ajout:
   coord.insert( coord.end(), results.begin(), results.end() );
  // ou par assignation
   coord = results;
  // ou autre manip...
}

Mias dans l'idéal il vaudrait mieu faire en sorte que le résultat soit stocké quelque part d'accessible. Là avec la variable statique tu peux avoir des problemes si ton appli est multithreadée et que cette fonction est utilisée par plusieurs threads (sauf corrections).

[Nikolai]

utiliser une classe serait peut etre un moyen propre d'y parvenir en effet. en déclarant le vector static. mais j'ai essayé sans y parvenir.

quelle est la démarche à suivre?
la fonction VC1 devient une méthode ?
(je suis un peu perdu avec la construcion des classes...j'ai plutot tout tendance à mettre dans le meme fichier, façon bourrin )

[hiura]

En fait, même pas besoin de classe quand j'y pense :

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
const std::vector<T>& get_V(void) {
  static bool is_already_init(false);
  static std::vector<T> V;
 
  if ( !is_already_init ) {
    V = init_V(); 
  /* ou 
    init_V(V);
      qui prendrait une référence pour supprimer une copie.
  */
    is_already_init = true;
  }
 
  return V;
}

Tu peux ainsi :
-> avoir un fichier header qui ne fait que déclarer la fonction
-> avoir un fichier source qui définit init_V de façon qu'elle ne soit pas accessible depuis un autre fichier.

[Nikolai]

je sais pas si j'ai bien compris :

je définis mon VC1 dans un autre fichier source, lié à un header.
et la fonction que tu as écrite, je la met dans le fichier source principal ?

[hiura]

nan, comme ceci :
-> main.cpp ( ou tout autre source ) : #include "V.hpp"
-> V.hpp : déclaration de get_V

Code :

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

const std::vector<T>& get_V(void);

+ anti inclusion multiple.
-> V.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include "V.hpp"

void init_V(std::vector<T>& V) {
  /* Cette fonction n'est accessible que depuis ce fichier source. */
  /* ... */
}

const std::vector<T>& get_V(void) {
  /* ... */
}