faite une pause temporairement

Version imprimable

Voir 40 message(s) de cette discussion en une page

01/02/2007, 16h27
Laurent Gomila

Disons que c'est mieux si tu le récupères, puis testes dans ton programme qu'il est bien supérieur ou égal à 2.
01/02/2007, 16h30
S2S

justement non, je connait le nombre ... c'est 1 = le nombre de milliseconde
RHOOOO! c'est 2, (je vait me faire enguirlander a dire des betise grosse comme moi...ha non, j'suis tout sec, c vraie)
que je recupere comme suis: sec[1] (dans mon code)

aparrament lui sait de quoi il sagit...
donc sous cet angle et/ou d'un point de vue conventionnel, doit on le mettre obligatoirement

PS: +1 = j'en aurai peut etre besoin (meme certainement) pour la gestion des erreur: parrametre manquant.
mais ne laissont pas une question sans reponse, si ca sert pas maintenant et a moi...cela me sera peut etre utile plus tard aissi qu'a d'autre.

---

ca va vite les reponse, merci, c'est tres apreciable (et aprecier;) ).
bon je l'ai rajouter (le 'n'), ne soyon pas radin, meme TTC c'est pas + cher.
01/02/2007, 16h36
Twindruff

Citation:

Envoyé par S2S

j'en aurai peut etre besoin (meme certainement) pour la gestion des erreur: parrametre manquant.

Mais oui c'est de ça qu'on parle :P

Ben oui:
Ici, le code avec les noms standard:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <sstream>
#include <iostream>
#include <windows.h>
 
int main(int argc, char * argv[])
{
   if(argc >= 2)
   {
      int millisecondes;
      std::istringstream iss( argv[1] );
      iss >> millisecondes;
      Sleep(millisecondes);
      return EXIT_SUCCESS;
   }
   else
   {
      std::cout << "Parametre manquant" << std::endl;
      return EXIT_FAILURE;
   }
}

Quand je disais "le paramètre de type int", c'est bien de argc que je parlais, mais comme tu ne lui avais pas donné de nom... ;)

On peut faire comme ça aussi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <sstream>
#include <iostream>
#include <windows.h>
 
int main(int argc, char * argv[])
{
   if(argc >= 2)
   {
      int secondes;
      std::istringstream iss( argv[1] );
      iss >> secondes;
      Sleep(secondes*1000);
      return EXIT_SUCCESS;
   }
   else
   {
      std::cout << "Parametre manquant" << std::endl;
      return EXIT_FAILURE;
   }
}

02/02/2007, 00h01
S2S

exelent 'Médinoc',;)

bon tu me gache un peu mon plaisir en m'aportant le truk sur un plateau
mais vu la complexiter :mouarf: de la chose :mouarf: , ca ira pour cet foi :D

bon il me reste une chose a voir
peut on retourner une variable ERRORLEVEL
(je supose que c'est une variable, sinon ca pourait etre quoi ?...)
avec la valeur:
0 au lieu de EXIT_SUCCESS
10 au lieu de EXIT_FAILURE

la je le dit, ce n'ai plus presser (le code actuel sufi au besoin que j'en avait)
donc je prefere juste une orientation (sauf si ce n'est pas possible 8O , la on poura abreger)
c'est en cherchant que j'en apprendrai le plus...

edit
---

j'alait oublier, il faudra que je prevoi une valeur par default au lieu de fermer le programme , donc ERRORLEVEL 10 si la valeur par default est utiliser...
02/02/2007, 02h56
koala01
Salut,

L'idée du retour de la fonction main est d'indiquer au système la manière dont s'est terminée l'application:

Windows considère deux valeurs: de manière correcte ou de manière incorrecte et les linuxoïdes considère une valeur supplémentaire: avec avertissement

Les valeurs sont EXIT_SUCCESS (valeur 0: sortie sur réussite) et EXIT_FAILURE (valeur 1: sortie sur échec)... (sous linuxoide, avec avertissement prend la valeur 2)

Il ne sert donc à rien de renvoyer une valeur autre que 0,1 ou, selon le système 2...

EXIT_SUCCESS et EXIT_FAILURE ne sont pas des variables, mais bel et bien, tout simplement d'alias (sous la forme de #define) que l'on retrouve dans le fichier stdlib.h et, par le jeu des inclusions, entre autre dans cstdlib et iostream, et ne sont définis que par "commodité", parce que c'est plus compréhensible à la lecture que 0 et 1 ;)

Toutes les valeurs que tu pourrait utiliser pour indiquer un mauvais fonctionnement (gestion d'erreur) ne devraient te servir que:
- pour te permettre la gestion finale avant sortie
- pour le débuggage afin de retrouver l'endroit où l'erreur s'est produite
Si tu le souhaites, tu peux disposer d'une liste de pres de 40 définitions d'alias pour des erreurs allant de EPERM (opération non autorisée) à EILSEQ(séquence d'octets illégale) grace à la majeur partie des conteneur STL...

Mais, encore une fois, ces numéros d'erreurs ne sont normalement pas destinés à etre renvoyés à la console ;)
02/02/2007, 11h17
S2S

"koala01", limpide.

tres claire et tres complete comme explication.
je ne m'attarderai plus que sur une valeur par default dans ce cas.;)

merci

Code:

1 2 3 4 5 6 7 8 9 10 int main(int argc, char* sec[]) { if(argc == 2 && sec[1] == XXXXXX) { int secondes; std::istringstream iss( sec[1] ); iss >> second; Sleep(second); return EXIT_SUCCESS; }
est-ce possible de specifier :
-if(argc == 2 && sec[1] ...???...
-Si le nbre d'argument est 2 ET si le 1er parrametre est convertible en 'int', faire... :aie: la, je n'ai pas le moindre debut d'idee pour tester si une conversion est possible

car il poura egalement contenir -? ou /? pour afficher une aide,
ou rien, et on utilisera la valeur par default,
ou bien autre chose (qui sera alors considerer comme erreur de syntax.

...des indice, des orientation, mais pas de reponse toute faite (sauf si impossible).merci;)

02/02/2007, 13h35
koala01

Tu peux tout à fait utiliser une synthaxe de test "cumulatif" grace à l'opérateur logique ET...

En effet, le fonctionnement de l'opérateur logique ET (AND) fait que la deuxième expression n'est évaluée que si la première a déjà donné un résultat vrai, et ainsi de suite...

Par contre, il *semble* judicieux de t'inciter à utiliser des noms d'arguments "classiques" pour la fonction main, juste, histoire d'éviter la confusion parce que "les habitudes sont tenaces" :P

Les noms d'arguments passés à main sont, classiquement argc (pour argument count) et argv(pour argument value), et ca peut en surprendre plus d'un que argv soit renommé en sec ;)

De plus, il faut malgré tout faire attention au fait que le test tel que tu le présente aura un inconvéniant majeur:

Le test ne donnera un résultat vrai que si les deux conditions sont vraies (argc==2 ET sec[1]==XXX)

Cela signifie que, si tu décides de permettre à l'utilisateut de passer d'autres parametres à l'application (par exemple /?), tu devra retester argc qui doit etre égal à 2... et que, si tu décide qu'il peut passer plus d'un parametre, tu devra écrire autant de test que de valeurs de parametres potentiellement fournis...

C'est la raison pour laquelle, il semble plus logique de tester argc de manière séparée et de ne tester la valeur de sec[1] que si tu es sur qu'il existe ;)

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
#include <iostream>
#include <sstream>
#ifdef __WIN32__
    #include <windows.h>
    #define sleep(x) Sleep(x)  // Sleep() sous Windows
#else
    #include <ctime>
    #define sleep(x) nanosleep((x)*1000) // nanosleep() POSIX
#endif
 
int main(int argc, char **argv)
{
    // Vérifie la syntaxe de la commande
    if(argc != 2)
    {
        std::cerr<<argv[0]<<" secondes"<<std::endl;
        return EXIT_FAILURE;
    }
 
    // Lit le paramètre (TODO : vérifier qu'il est numérique)
    std::istringstream param(argv[1]);
    int secondes;
    param>>secondes;
 
    // Attend
    sleep(secondes * 1000);
 
    return EXIT_SUCCESS;
}

Il n'y a réellement aucun programme sous Windows pour attendre X secondes ?

8O daccord,

Citation:

classiquement argc (pour argument count) et argv(pour argument value),

je voyai plutot ca comme un modelle (un prototype),
mais si c'est conventionnel je m'execute ;)

sinon, if(argc == 2 && argv[1] == XXXXXX ; j'avait bien compri...c'etait surtout le test de l'argument ( convertible ou non en 'int')

RAMRAM :aie: = j'avait dit une orientation PAS de solution toute faite :cry:
c'est pas grave, ca n'a pas l'air d'etre ca, ou j'ai rien compri (comment ca encore :? )
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <sstream> #include <iostream> #include <windows.h> int main(int argc, char* argv[]) { if(argc == 2 && argv[1] est convertible en 'int'...alors fait ceci: { int secondes; std::istringstream iss( argv[1] ); iss >> second; Sleep(second); return EXIT_SUCCESS; } else if
c'est plutot cet parti la qui m'interesse:

Code:

&& argv[1] est convertible en 'int'...alors fait ceci:

merci quan meme pour l'intention ;)

Citation:

Il n'y a réellement aucun programme sous Windows pour attendre X secondes ?

La plupart se serve d'un: @ping 127.0.0.1 /n XX>NUL
mais ce n'est plus du bricolage a ce niveau :aie: , devrai y avoir des loi pour proteger les fonction de tel abut :mrgreen:
Sinon...en JScript/WSH mais c'est pas le meme interpreteur et a par un pop up (equivalent a celui du 'net send'), je sai pas m'en servir :cry:

02/02/2007, 20h33
Laurent Gomila
Pour savoir si ton entier s'est bien extrait du flux, il suffit de tester l'état de ce dernier après l'extraction.
Code:

1 2 3 iss >> second if (iss) Sleep(second);
Ou même directement :
Code:

1 2 if (iss >> second) Sleep(second);

Citation:
Envoyé par Laurent Gomila
Pour savoir si ton entier s'est bien extrait du flux, il suffit de tester l'état de ce dernier après l'extraction.
Code:

1 2 3 iss >> second if (iss) Sleep(second);
Ou même directement :
Code:

1 2 if (iss >> second) Sleep(second);
hummm! comprend pas...et on test le flux avant sa creation: (je voi pas l'usage)
Code:

1 2 3 4 5 6 7 8 9 if(argc == 2 && (iss >> second)) Sleep(second); { int secondes; std::istringstream iss( argv[1] ); iss >> second; Sleep(second); return EXIT_SUCCESS; }
======================

Citation:

Cela signifie que, si tu décides de permettre à l'utilisateut de passer d'autres parametres à l'application (par exemple /?), tu devra retester argc qui doit etre égal à 2... et que, si tu décide qu'il peut passer plus d'un parametre, tu devra écrire autant de test que de valeurs de parametres potentiellement fournis...

En lettre, voila le shema que je voudrai suivre (je suis ton conseille en testant d'abort argc)
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 Si il y a 2 argument, faire: { Si le 1er parametre est convertible en 'int' faire: if(std::istringstream iss( argv[1] );iss >> second) (ca ce fait ca ?) { convertir la chaine dans une variable 'int' attendre le temp demander. } ou sinon, Si le 1er parametre est '-?' ou '/?' faire: { afficher l'aide } sinon { prevenir d'une erreur de syntax et quitter } } Sinon { Si trop d'argument (>= 3) { erreur de syntax } sinon { attendre le temp par default prevenir que le temp par default a ete utilise. } }
Je bloc toujour pour tester si 'argv[1]' ==>> 'int'
la ou j'ai mi:
if(std::istringstream iss( argv[1] );iss >> second)
ou:
if(std::istringstream iss( argv[1] ) >> second)

pour le reste, c'est bon...

Bon, c'est pas tout a fait dans l'ordre prevu
mais ca fait ce qu'il faut (normalement):

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
#include <sstream>
#include <iostream>
#include <windows.h>

int main(int argc, char* argv[])
{
   if(argc == 2 )
   {
       if(std::istringstream iss( argv[1] ) >> second)  // Ca, ca ne fonctionne pas evidement
       {                                              // je n'ai pas encore trouver
           int second;
           std::istringstream iss( argv[1] );
           iss >> second;
           Sleep(second);
           return EXIT_SUCCESS;
       }
       else
       {
           std::cout << "Owait.exe   Permet une pause de X millisecondes.\nSyntaxe:\n\n Owait XXXX  (XXXX en millisecondes)" << std::endl;
           if(argv[1] == "/?" || "-?")
           {
               return EXIT_SUCCESS;
           }
           else
           {
               return EXIT_FAILURE;
           }
       }
   }
   else
   {
       if(argc == 1 )
       {
           std::cout << "Temps non specifier, 3 seconde est utiliser \npar default. (Owait /? pour avoir une aide)" << std::endl;
           int second=3;
           Sleep(second);
           return EXIT_SUCCESS;
       }
       else
       {
           std::cout << "Erreur de Syntaxe:\n\nOwait.exe   Permet une pause de X millisecondes.\n" << std::endl;
           std::cout << "Syntaxe: Owait XXXX  (XXXX en millisecondes)" << std::endl;
           return EXIT_FAILURE;
       }
   }
}

toujour je test du argv >> 'int', que je trouve pas...

04/02/2007, 19h55
Laurent Gomila

Citation:

hummm! comprend pas...et on test le flux avant sa creation: (je voi pas l'usage)

Non, tu testes le flux après l'extraction. Je ne sais pas pourquoi ça te gêne, mais si tu veux à tout prix faire le test avant il faut passer par un autre flux comme tu as tenté de le faire.

Si tu veux le faire en une ligne il ne faut pas nommer ta variable temporaire :

Code:

if (std::istringstream( argv[1] ) >> second)
08/02/2007, 11h08
S2S

merci bien ;)
j'ai pas pu tester
windows a planter grub, j'en ai un peut baver a remetre
en place sans reinstaller (et finalement, j'aurai ete plus vite, mais c'est moin drole)

donc je vai tester ca

Code:

if (std::istringstream( argv[1] ) >> second)

et ca devrai aller
a +

Voir 40 message(s) de cette discussion en une page