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) {
  /* ... */
}

[Nikolai]

La fonction init_V, il faut pas la declarer dans le header ? et dedans je mets ma fonction VC1 n'est ce pas ?

[hiura]

La fonction init_V, il faut pas la declarer dans le header ?

Non, sinon elle sera accessible à toutes les autres sources, ce qui n'est pas désirable si on ne veut vraiment qu'une seule construction du vecteur. ( Si tu veux une copie, copie le vecteur déjà créé, ça ira plus vite. )

et dedans je mets ma fonction VC1 n'est ce pas ?

dedans quoi ? Dans le header ?

Je sais pas exactement ce qu'est VC1. Mais l'idée est la suivante :
dans le header : la fonction pour récupérer le vecteur et c'est tout.
dans la source : la définition de ce "getter" et la fonction qui permet de construire ce fameux vecteur.
dans les autres sources qui utilisent ce vecteur : une include du header ci-dessus défini.

[Pragmateek]

Non, sinon elle sera accessible à toutes les autres sources

Ne pas la déclarer ne changera rien à la possibilité d'y accéder.
L'accès est géré par le linker.

Il y a plusieurs façon de faire :
- façon C-like deprecated : déclarer la fonction static,
- façon C++ : définir la fonction dans un namespace anonyme.

f.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
namespace
{
	void fn(void)
	{
	}
}
 
void f(void)
{
}
 
static void fs(void)
{
}

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
void fn(void);
void fs(void);
void f(void);
 
int main(void)
{
	f();
	fn();
	fs();
}

Ca compile mais ça ne link pas car fn et fs ne sont pas accessibles contrairement à f.

[Nikolai]

j'ai procédé de la manière suivante :

j'ai crée un header avec

Code :

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

const std::vector<double>& get_C1(void);

puis un fichier source 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
17
void init_C1(std::vector<double>& coord)
{ //ma fonction de remplissage
}
 
const std::vector<double>& get_C1(void)
 {
  static bool is_already_init(false);
  static std::vector<double> C1;
 
  if ( !is_already_init ) {
    C1 = init_C1(C1);
 
    is_already_init = true;
  }
 
  return C1;
}

et dans le main je fait

Code :

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

vector< double > C1 = get_C1();

ce qui ne marche pas. voyez vous ou est l'erreur ? merci

[Pragmateek]

A moins que ce ne soit une erreur de typo :

Code :

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

C1 = init_C1(C1);

n'est pas correct car init_C1 ne renvoie pas de résultat.

[Nikolai]

c'est vrai! ce serait plutot

Code :

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

init_C1(C1);

mais j'ai une erreur au niveau du header :

error : expected initializer before '<' token

[Pragmateek]

Corrige juste la première erreur, la seconde en découle.

[Nikolai]

yeah, that works!

merci beaucoup!!

[hiura]

Ne pas la déclarer ne changera rien à la possibilité d'y accéder.
L'accès est géré par le linker.

Il y a plusieurs façon de faire :
- façon C-like deprecated : déclarer la fonction static,
- façon C++ : définir la fonction dans un namespace anonyme.

f.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
namespace
{
    void fn(void)
    {
    }
}
 
void f(void)
{
}
 
static void fs(void)
{
}

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
void fn(void);
void fs(void);
void f(void);
 
int main(void)
{
    f();
    fn();
    fs();
}

Ca compile mais ça ne link pas car fn et fs ne sont pas accessibles contrairement à f.

AH ! C'est bon à savoir ça.