Différence ./main et exécutable main

Bonjour,
Voila j'ai un petit problème dont je ne vois pas bien la source. J'ai créé un petit programme me permettant de calculer des trucs (osef) et de me les sortir sous forme de données en .dat. Mon programme marche au poil mais je rencontre un problème avec l'exécutable lors qu'il est seul. Je m'explique. J'ai regroupé les différentes parties de mon code dans un dossier avec un makefile. J'ouvre le dossier dans un terminal je tape "make" puis "./main" et là le programme roule: il calcul puis il me sort mes .dat. Le problème intervient lorsque je compile mon code, "make", puis ferme le terminal et double clic sur mon exécutable. Le terminal s'ouvre, les calculs s'effectuent mais je n'ai aucun .dat qui sort? Comment est-ce possible?!

Merci de votre aide.

Mon Makefile si ça peut aider:

Code:

---

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

############################## # Makefile du TP Projet ##############################     #Chemin pour utiliser Vecteur.o VECTEUR=./Vecteur   OBJECTS = main.o EDO2.o $(VECTEUR)/Vecteur.o all: main   COMPILCOMMAND=g++ -std=c++11 -I$(VECTEUR) -c -o $@ $<   # Commande generique %.o: %.cpp %.h $(COMPILCOMMAND)   #commande pour l’executable %.o: %.cpp $(COMPILCOMMAND)   # Fichiers source a generer EDO2.o: EDO2.h main.o: EDO2.h   # Creation de l'executable main: $(OBJECTS) g++ -std=c++11 -o main $(OBJECTS) -lgsl -lgslcblas   # Commande de nettoyage clean: rm -f *.o main *.dat *~

---

C'est le "working directory" qui change :mrgreen:

À la console tu forces la racine de ton exécutable avec "./"

Alors que lorsque tu double cliques dessus, le "working directory" c'est peut-être ton "home", peut-être "/bin", peut-être "/user/bin" ...

Il faut soit afficher le "working directory" (avec une interruption pour le voir *) soit rechercher le fichier ".dat" à partir de la racine "/" (éventuellement regarder dans 2-3 dossiers connus avant)


* -> Soit avec un Sleep de X secondes soit avec une boîte de dialogue

J'ai oublié de l'expliciter, je suis une vraie bite dans ce domaine :aie:
Comme faire exactement? Merci.

Ah oui, je vois ce que tu veux dire. Effectivement après vérification mes .dat on bien été envoyés à la racine de mon pc. Mais du coup comment faire en sorte qu'ils soient créés dans le même dossier que mon exécutable? La manip se fait au niveau du make file ou du fstream?

Bon j'ai essayé plein de chose mais rien ne marche...
Voila où j'en suis:

Code:

---

1 2 3

string filename= "./Résultats/Diffusion-L="+to_string(barriere)+"nm-E="+to_string(Energie)+"eV.dat";   ofstream fichier(filename);

---

Je ne connais pas Linux (enfin si mais pas l'API C/ C++), mais je vois 2 trucs :mrgreen::

• chdir
• system ou 1 exec system("cd /XXX/XXX/XXX");.

En fait le problème c'est que mon code est amené à être utilisé pas d'autres personnes, mes profs en l'occurence. Du coup j'aimerais que peu importe où se trouve le programme il me crache mes .dat dans le même dossier.
Il n'y a pas moyen récupéré le répertoire de l'exécutable et de l'insérer comme fonction de mon ofstream?

Je ne connais pas Linux (enfin si mais pas l'API C/ C++), mais as-tu regardé le argv[0]? :mrgreen:

Dans ton main, il y a 2 paramètres main(int argc, char* argv[]).
Et le argv[0] est souvent/ toujours le nom de l'exécutable. Peut-être qu'il y a un chemin? :koi: :koi:

Non j'ai juste un int main()

Je vais te mettre tout mon code ainsi que mon makefile si ça peut t'aider (attention c'est un peu lourds ^^):

EDO2.h

Code:

---

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 49 50 51 52 53

#ifndef __EDO2_H__ #define __EDO2_H__ #include "Vecteur/Vecteur.h" #define eV 1.6e-19 #define nm 1e-9   class EDO2 {   protected:   int N;//Nombre d'iteration/de points double L;//Largueur de la barriere double V;//Potentiel int rk; //Methode utilisee   //m: Masse particule; hb: Constante de Dirac double m=1.9e-31,hb=1.04082e-33;   Vecteur yf; // Valeurs de y(xf) double *xtab,*ytabNorm,*Energie,*Trans,*TAnaly; Vecteur *ytabRe, *yptabRe,*ytabIm, *yptabIm;   void stocke(int i,double x,double ytabNorm, Vecteur Re, Vecteur Rep, Vecteur Im, Vecteur Imp ); void stockeT(int i,double x, double y, double z);   public:   EDO2(int Ni); ~EDO2();   void setRk(int a){rk=a;}; void setL(double a){L=a*nm;}; void setV(double a){V=a*eV;};   //Systeme d'equa diff Vecteur evalSys(double x, double E, Vecteur y);   //Integration par Runge-Kutta Vecteur calculDiff(double x0,double xf,double E);   //Calcul coefficient de transmission double calculT(double E); double calculTAnaly(double E, double h);   //Calcul de T(E) double tracerT();   //Sortie des .dat void ecrireDiff(double E); void ecrireT(); };   #endif

---

EDO2.cpp

Code:

---

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 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228

#include "EDO2.h" #include <fstream> #include <iomanip> #include <iostream> #include <string> #include <cmath> using namespace std;   EDO2::EDO2(int Ni) : N(Ni) { yf.redim(4); // On alloue les tableaux servant a stocker les données xtab=new double [N+1]; // [0..N] => N+1 ytabNorm=new double [N+1]; Energie=new double [N+1]; Trans=new double [N+1]; TAnaly=new double [N+1]; ytabRe=new Vecteur [N+1]; yptabRe=new Vecteur [N+1]; ytabIm=new Vecteur [N+1]; yptabIm=new Vecteur [N+1]; for (int i=0;i<N+1;i++) { ytabRe[i].redim(2); yptabRe[i].redim(2); ytabIm[i].redim(2); yptabIm[i].redim(2); } }   EDO2::~EDO2() { delete[] xtab; delete[] ytabNorm; delete[] ytabRe; delete[] yptabRe; delete[] ytabIm; delete[] yptabIm;delete[] Energie; delete[] Trans; delete[] TAnaly; }   //Stockage des donnees void EDO2::stocke(int i,double x,double Norm, Vecteur Re, Vecteur Rep, Vecteur Im, Vecteur Imp ) { xtab[i]=x; ytabRe[i]=Re; yptabRe[i]=Rep; ytabIm[i]=Im; yptabIm[i]=Imp; ytabNorm[i]=Norm; } void EDO2::stockeT(int i,double En, double T, double TAnalytique) { Energie[i]=En; Trans[i]=T; TAnaly[i]=TAnalytique; }   //Ecriture des donnees sous forme d'un .dat void EDO2::ecrireDiff(double E) {int barriere=rint(L/nm); int Energie=rint(E/eV);   string filename= "./Résultats/Diffusion-L="+to_string(barriere)+"nm-E="+to_string(Energie)+"eV.dat";   ofstream fichier(filename); fichier<<"# x"<<setw(20)<<"Re"<<setw(20)<<"Im"<<setw(20)<<"Norme"<<endl; for (int i = 0 ; i < N+1 ; i++) { fichier<< setprecision(12) << xtab[i]; fichier << setw(20) << setprecision(12) << ytabRe[i](1)<< setw(20) << setprecision(12) << ytabIm[i](1)<< setw(20) << setprecision(12) << ytabNorm[i]; fichier << endl;} fichier.close(); } void EDO2::ecrireT() {int barriere=rint(L/nm); int EnergieV=rint(V/eV); string filename = "./Résultats/Transmission-"+to_string(barriere)+"nm-V="+to_string(EnergieV)+"eV.dat";   ofstream fichier( filename ); fichier<<"# Energie"<<setw(20)<<"Tnum"<<setw(20)<<"Tanaly"<<endl; for (int i = 0 ; i < N+1 ; i++) { fichier<< setprecision(12) << Energie[i]; fichier << setw(20) << setprecision(12) << Trans[i]<< setw(20) << setprecision(12) <<TAnaly[i]; fichier << endl;} fichier.close(); }       //Le systeme d'equa diff Vecteur EDO2::evalSys(double x, double E, Vecteur y) { //Vecteur d'onde suivant x: interieur ou exterieur du potentiel double K=(2*m)/(hb*hb), Kiterieur=K*(V-E), Kexterieur=K*-E; if (x>=0 && x<=L) K=Kiterieur; else K=Kexterieur;     //Notre systeme d'equations Vecteur v(2); v(1)=y(2); v(2)=K*y(1); return v;}     //Resolution de ce systeme Vecteur EDO2::calculDiff(double x0,double xf, double E) { //Vecteur d'onde pour conditions initiales double k=(sqrt(2*m*E))/hb;   //Condition initiale Re double y00Re[2]={cos(k*x0),-k*sin(k*x0)};//Formule d'Euler Vecteur y0Re(2,y00Re);   //Condition initiale Im double y00Im[2]={sin(k*x0),k*cos(k*x0)}; Vecteur y0Im(2,y00Im);   double x; Vecteur yRe(2),yIm(2); Vecteur ypRe(2),ypIm(2); Vecteur k1(2), k2(2), k3(2), k4(2); yRe=y0Re; yIm=y0Im; double ynorm; //La norme double h = (xf - x0)/N;//Le pas     for (int i = 0 ; i<N ; i++) { x = x0 + i*h; ynorm=yRe(1)*yRe(1)+yIm(1)*yIm(1);//Definition de la norme ypRe= evalSys(x,E, yRe); ypIm= evalSys(x,E, yIm); stocke(i,x*(1/nm),ynorm,yRe,ypRe,yIm,ypIm);//Stockage des donnees   //Rung-Kutta d'ordre 4 if(rk==4){ //Re k1 = h * ypRe; k2 = h * evalSys(x+h/2,E ,yRe+k1/2 ); k3 = h * evalSys(x+h/2,E, yRe+k2/2); k4 = h * evalSys(x+h,E , yRe+k3 ); yRe=yRe+(k1+2*k2+2*k3+k4)/6;   //Im k1 = h * ypIm; k2 = h * evalSys(x+h/2,E, yIm+k1/2 ); k3 = h * evalSys(x+h/2,E, yIm+k2/2); k4 = h * evalSys(x+h, E, yIm+k3 ); yIm=yIm+(k1+2*k2+2*k3+k4)/6;}     //Rung-Kutta d'ordre 2 else if(rk==2){   //Re k1 = h * ypRe; k2 = h * evalSys(x+h/2,E ,yRe+k1/2 ); yRe = yRe + k2;   //Im k1 = h * ypIm; k2 = h * evalSys(x+h/2,E ,yIm+k1/2 ); yIm = yIm + k2;}   }   // yf est de la forme: yf(1)=yRe(1);// (Re ) yf(2)=yRe(2);// yf=(Re') yf(3)=yIm(1);// (Im ) yf(4)=yIm(2);// (Im') stocke(N,xf*(1/nm),ynorm,yRe,evalSys(xf,E,yRe),yIm,evalSys(xf,E,yIm)); return yf; }   double EDO2::calculT(double E) {double k, a,b,ia,ib,t,it,T,x0=100.*nm;   Vecteur psi0=calculDiff(x0,0,E);//Recuperation condition limte x=0   //Voir annexe rapport k=(sqrt(2*m*E))/hb; ib=0.5*(psi0(3)+(psi0(2)/k)); ia=0.5*(psi0(3)-(psi0(2)/k)); a=0.5*(psi0(1)+(psi0(4)/k)); b=0.5*(psi0(1)-(psi0(4)/k));   t=a/(a*a+ia*ia); it=-ia/(a*a+ia*ia); T=pow(t,2)+pow(it,2); return T; }   double EDO2::calculTAnaly(double E,double h) {double TAnaly,K1,K10,K2,K20; //Tout ce qui suit sert a calculer T analytique K1=sqrt(2*m*V*L*L*(1-(E/V)))/hb; K2=sqrt(2*m*V*L*L*((E/V)-1))/hb; K10=sqrt(2*m*V*L*L*(1-((V-h)/V)))/hb; K20=sqrt(2*m*V*L*L*(((V+h)/V)-1))/hb; if (E<V)TAnaly=1/(1+((pow(sinh(K1),2))/(4*(E/(V*V))*(V-E))));   else if(E==V) TAnaly=((1/(1+((pow(sinh(K10),2))/(4*((V-h)/(V*V))*(V-(V-h))))))+(1/(1+((pow(sin(K20),2))/(4*((V+h)/(V*V))*((V+h)-V))))))/2.;   else TAnaly=1/(1+((pow(sin(K2),2))/(4*(E/(V*V))*(E-V)))); return TAnaly;}       double EDO2::tracerT()//Calcul de T pour différentes energies { double E0=0.,Ef=2.*V,x0=100.*nm;   double E,k,T,TAnaly,K1,K10,K2,K20, Err=0.; Vecteur psi0;   double h = (Ef - E0)/N;   for(int i=1; i<=N; i++) {E = E0 + i*h; //Calcul numerique de T T=calculT(E);   //Calcul analytique de T TAnaly=calculTAnaly(E,h);   //Erreur comme somme des difference TAnaly et T Err+=fabs(TAnaly-T);   stockeT(i,(E*(1/eV)),T,TAnaly);   } return (Err/N); }

---

main.cpp

Code:

---

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 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

#include <iostream> #include <iomanip> #include <cmath> #include "EDO2.h" using namespace std; int main() {   int rk, N; double E,L,V,Err;   cout<<endl <<"##########################################################"<<endl <<"############ ############"<<endl <<"############ Programme de Diffusion Quantique ############"<<endl <<"############ ############"<<endl <<"##########################################################"<<endl <<"# Martinon/Diop ############################### Mai 2016 #"<<endl <<"##########################################################"<<endl<<endl<<endl;     cout <<"Selectioner le nombre de points:"; cin>>N; cout <<"Selectioner la methode a utiliser Rk(2 ou 4):"; cin>>rk; cout <<"Selectioner la largueur du potentiel (en nm):"; cin>>L; cout <<"Selectioner l'energie du potentiel (en eV):"; cin>>V; cout <<"Selectioner l'energie de la particule (en eV):"; cin>>E; cout<<endl;   cout<<"N="<<N<<setw(18)<<"Methode:RK"<<rk<<setw(10)<<"L="<<L<<"nm"<<setw(10)<<"V="<<V<<"eV"<<setw(10)<<"E="<<E<<"eV"<<endl<<endl;   EDO2 psi(N);   psi.setL(L); psi.setV(V); psi.setRk(rk);     double x0=100.*nm , xf=-100.*nm, timeT, timeTE, dt; E=E*eV; Vecteur yres(4);   //Mesure temps de calcul T timeT = clock() ;   yres=psi.calculDiff(x0,xf,E);   //Ecriture .dat psi.ecrireDiff(E);   //Calcul T psi.calculT(E);   dt = clock() - timeT ; timeT = (double)dt/CLOCKS_PER_SEC; cout<<"Coefficient de transmission T="<<psi.calculT(E)<<endl; cout<<"Coefficient de reflexion R="<<1-psi.calculT(E)<<endl;   //Mesure temps de calcul T(E) timeTE = clock() ;   Err=psi.tracerT();   dt = clock() - timeTE ; timeTE = (double)dt/CLOCKS_PER_SEC;   cout<<endl<<"Temps de calcul de T:"<<timeT<<"secondes."<<endl; cout<<"Temps de calcul T(E):"<<timeTE<<"secondes."<<endl<<endl; cout<<"Precision moyenne de la methode:"<<Err<<endl<<endl; cout<<"Sortie de psi et de T(E) sous forme de .dat dans /Résultats"<<endl<<endl;   //Ecriture .dat psi.ecrireT();   return 0;}

---

Makefile:

Code:

---

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

############################## # Makefile du TP Projet ##############################     #Chemin pour utiliser Vecteur.o VECTEUR=./Vecteur   OBJECTS = main.o EDO2.o $(VECTEUR)/Vecteur.o all: main   COMPILCOMMAND=g++ -std=c++11 -I$(VECTEUR) -c -o $@ $<   # Commande generique %.o: %.cpp %.h $(COMPILCOMMAND)   #commande pour l’executable %.o: %.cpp $(COMPILCOMMAND)   # Fichiers source a generer EDO2.o: EDO2.h main.o: EDO2.h   # Creation de l'executable main: $(OBJECTS) g++ -std=c++11 -o main $(OBJECTS) -lgsl -lgslcblas   # Commande de nettoyage clean: rm -f *.o main *.dat *~ ./Résultats/*.dat

---

Citation:

---

Envoyé par momovelo

Non j'ai juste un int main()

---

Et qu'est-ce qui t'empêche de coder le main officiel? :mrgreen:

Bha heu, j'en sais rien :mrgreen:

Non, je me casse les dents là dessus mais je ne vois vraiment pas..

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <string> #include <iostream>   int main(int, char ** av) { std::string d = av[0]; auto const pos = d.rfind('/'); if (pos != std::string::npos) { d.resize(pos+1); } else { d = "./"; }   std::cout << "directory: " << d; }

---

J'ai pas compris ce que fais ton code à part me sortir "directory: ./":|

Il donne le chemin du programme relatif au dossier de travail, c'est à dire le dossier de l'exécutable.
Au besoin, le dossier de travail peut être changé avec chdir.

note: Sur Windows, il faudrait utiliser '\\' au lieu de '/'.

Citation:

---

Envoyé par momovelo

J'ai pas compris ce que fais ton code à part me sortir "directory: ./":|

---

Sors toi les doigts :roll: :roll:

Documentation de rfind: il te sort "./" parce qu'il n'y a pas le chemin, juste le nom de l'exécutable.
De toute manière tu colles un point d'arrêt (breakpoint) et tu es fixé en 30 secondes.

Avec une recherche Google How do I get the directory that a program is running from?, sous Linux, soit:

• Utiliser le fichier "/proc/XXX_PID/exe" (mais ce n'est pas portable à 100% apparemment) (*)
• Soit getcwd

Sous Windows, GetModuleFileName


* ->

Code:

---

1 2 3 4 5 6

char szTmp[32]; sprintf(szTmp, "/proc/%d/exe", getpid()); int bytes = MIN(readlink(szTmp, pBuf, len), len - 1); if(bytes >= 0) pBuf[bytes] = '\0'; return bytes;

---

Citation:

---

Envoyé par jo_link_noir

note: Sur Windows, il faudrait utiliser '\\' au lieu de '/'.

---

Dans les API Windows, les 2 sont supportés :mrgreen:

Citation:

---

Envoyé par momovelo

J'ai oublié de l'expliciter, je suis une vraie bite dans ce domaine :aie:
Comme faire exactement? Merci.

---

J'ai appris le code il y a six mois. Alors c'est bien beau de me traiter de branleur mais ça ne m'aide pas vraiment...
De plus, désolé de ne pas vous l'avoir précisé, je code sous mac (famille unix).

Citation:

---

Envoyé par momovelo

J'ai appris le code il y a six mois. Alors c'est bien beau de me traiter de branleur mais ça ne m'aide pas vraiment...

---

Pas de branleur, mais ne pas avoir de réflexes :aie: :aie:

Il y a Internet et des sites références pour décrire toutes les méthodes standards: Tu ne vois pas ce que fait un bout de code, et tu vois std::rfind ou std::npos: réflexe je vais voir.

Savoir ce qu'il y a dans une variable (ici argv[0]): réflexe 2 lignes de code et un point d'arrêt.

Un problème, réflexe: stackoverflow ou un autre (une fois que le problème est dégagé, parce que des fois c'est le brouillard ;))

Citation:

---

Envoyé par momovelo

De plus, désolé de ne pas vous l'avoir précisé, je code sous mac (famille unix).

---

Et tu te plains en ayant les 2 meilleurs compilateurs C++ :mouarf: :mouarf:: gcc et clang.

Par contre effectivement :mrgreen: le truc du "/proc/XXX_PID/exe" cela va passer moyen-moyen: il faut tester

Rah il ne veut vraiment pas!
Je viens de coder ça:

Code:

---

1 2 3 4 5

#include <unistd.h> #include <limits.h> char buff[PATH_MAX + 1]; char *cwd = getcwd( buff, PATH_MAX + 1 );

---

cwd retourne le working directory (je le stocke dans WD). Maintenant dans mon ofstream je fais simplement ofstrem fichier(WD+filename);
Quand je fais un petit cout<<WD+filename j'ai bien le répertoire où je veux que mes .dat sortent.
Mais le problème persiste, lorsque je lance le main seul, les .dat disparaissent...

Tu es sûr d'avoir les droits d'écriture sur le dossier final ? Si ce n'est pas le cas, le programme ne plantera pas, tu n'auras juste pas tes fichiers.

Citation:

---

Envoyé par foetus

Dans les API Windows, les 2 sont supportés :mrgreen:

---

Peut-être, mais le caractère cherché dans argv n'est pas quantique ;).