Discussion :

[gesa50]

Bonjour à tous.
Une petite question:
Sous windows et à partir d'un programme codé en c et sdl,est-il possible "d'appeler" et "lancer" un exécutable codé lui aussi en c et sdl?
Dans l'afffirmative,quelle serait la procédure à suivre?
Merci.
Cordialement.

[Médinoc]

Il est facile de lancer un autre exécutable (même en C standard), mais communiquer avec est une autre histoire.

[Matt_Houston]

Certes Médinoc, mais cela ne répond pas à la question initiale.

system ou spawn* peuvent peut-être répondre à ton cas d'utilisation. Plus d'informations ici. J'imagine qu'il existe d'autres alternatives mais je connais personnellement très mal la programmation système sous Windows.

[chrtophe]

la simple fonction C system te permettra d'appeler un autre programme, mais je pense que cet appel bloque le programme appelant jusqu'à la fin de l’exécution du programme fils . Il vaut mieux regarder du coté de CreateProcess :

https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx

[gesa50]

Bonjour à tous.
Merci,Médinoc,Matt_Houston et Chrtophe pour vos réponses.
Cordialement.

[sambia39]

Bonjour,

Certes Médinoc, mais cela ne répond pas à la question initiale.

system ou spawn* peuvent peut-être répondre à ton cas d'utilisation. Plus d'informations ici. J'imagine qu'il existe d'autres alternatives mais je connais personnellement très mal la programmation système sous Windows.

Je ne suis pas d’accord sur la réponse donnée concernant la fonction « system » pour les raisons suivantes :

• La fonction « system » est bloquante et permet l’exécution d’une commande ou application externe à travers un Shell (terminal) c'est-à-dire, que "system" va faire appel à un nouveau Shell qui va exécuter l’application externe et attendra la fin d’exécution du programme externe pour renvoyer le code retour de fin d’exécution à l’application appelante et c’est très embêtant, car si vous comptez garder le flot d’exclusion initiale de l'application appelante, vous êtes obligé d’attendre la fin d’exécution du programme appelé avant de faire d'autre traitements. Ici, "system" n’est pas du tout adapté.
  Exemple simple sur unix:
  

  Code C :

  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
   
  #include <stdio.h>
  #include <stdlib.h>
   
  int main( int argc, char *argv[] ){
   
      int ret_shell = EOF;
      fprintf( stdout, "START PROCCESS SHELL\n");
      ret_shell = system("top");   // appel de système est bloquante
   
      /*  Aucune autre instruction n'est executé tant que le shell
       *  n'a pas rendu la main
       */
      fprintf( stdout, "SUITE DU PROGRAMME %s\n", argv[1] );
      fprintf( stdout, "Code retour shell\t:%d\n", ret_shell );
   
      return EXIT_SUCCESS;
  }

• La fonction « spawn » et ses variantes sont par défaut (si je ne me trompe pas) bloquantes. Pour qu'elle soit non bloquante, il faut fournir les drapeaux (flag ou mode) nécessaires selon l'utilisation souhaitée. Techniquement, la fonction « spawn » crée et exécute un nouveau processus et les flags ou modes, vont déterminer l'action que doit entreprendre le processus appelant avant et pendant une opération de création du processus .Certes « spawn » va créer un autre processus, mais il faut spécifier les flags nécessaires cas contraires elle est bloquante.

D’un autre côté, @Médinoc a raison, car si vous crée des processus, faudrait s’assurer préalablement que l’on est un où des mécanismes de communication et synchronisation interprocessus cela permet d’échanger des informations d’accéder à des ressources communes, etc.

Cependant, si vous réalisez une application avec la librairie SDL, celle-ci mets a votre disposition des threads "dits processus léger" (léger, car il s’applique à la mémoire utilisée, mais aussi au coût de sa réalisation).
Le mieux est d’avoir un programme "multithreadé", cela vous permet d’avoir un processus normal qui abrite plusieurs processus légers dont chacun a son propre flot d'exécution bien distinct, mais attention, les threads partagent leurs espaces mémoire donc, il faut mettre en place les outils de synchronisation des threads.
Pour les thread SDL, vous avez les ressources disponibles sur la liste actuelle dont voici un lien qui traite des thread: http://loka.developpez.com/tutoriel/sdl/thread/. Libres à vous par la suite de faire le nécessaire.
à bientôt

[Matt_Houston]

[...] Ici, "system" n’est pas du tout adapté.

Sans plus de précision sur le cas d'utilisation de l'OP dont je rappelle l'énoncé ci-après, system est au contraire parfaitement adapté.

Sous windows et à partir d'un programme codé en c et sdl,est-il possible "d'appeler" et "lancer" un exécutable codé lui aussi en c et sdl?
Dans l'afffirmative,quelle serait la procédure à suivre?

Rasoir d'Occam : aucune raison d'extrapoler en abordant la communication inter-processus, ou en affirmant que l'appel bloquant est inadapté.

[sambia39]

Bonsoir,

Rasoir d'Occam : aucune raison d'extrapoler en abordant la communication inter-processus, ou en affirmant que l'appel bloquant est inadapté.

Anti-rasoir: "Il est vain d'essayer de faire avec moins ce qui requiert plus". (Walter Chatton)
Voici un exemple avec Glut et OpenGL utilisant la fonction "system" qui permet de faire appel à un nouveau shell qui va exécuter l’application externe (qui n’est rien d’autre que l’application elle-même).

Attention, le code source ci-dessous sont susceptibles de comporter des erreurs, certaines syntaxes ou instructions ont été volontairement implémentés ou ignorées par moi dans l’unique but d’apporté (fournir) un exemple simple et fonctionnel ressemblant à la problématiques énoncées dans mon précédent poste.

Code C :

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
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
 
//
//  Glut_exe.c
//  GLUT_Teste
//
//  Created by SAMBIA39 on 03/09/2016.
//  Copyright © 2016 SAMBIA39.
//
 
#include <stdio.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
 
#include <openGL/gl.h>
#include <openGL/glu.h>
#include <glut/glut.h>
 
typedef struct {
    float x, y, z, r, g, b;
} point;
 
void keyboard(unsigned char key, int x, int y);
void display();
void mouse(int button, int state, int x, int y);
void mousemotion(int x, int y);
void reshape(int x, int y);
 
 
float xold, yold, anglex = 0, angley = 0, presse = 0;
 
 
point p[8] = {
    {-0.5, -0.5, 0.5, 1.0, 0.0, 0.0},
    {-0.5, 0.5, 0.5, 0.0, 1.0, 0.0},
    {0.5, 0.5, 0.5, 0.0, 0.0, 1.0},
    {0.5, -0.5, 0.5, 1.0, 1.0, 1.0},
    {-0.5, -0.5, -0.5, 1.0, 0.0, 0.0},
    {-0.5, 0.5, -0.5, 0.0, 1.0, 0.0},
    {0.5, 0.5, -0.5, 0.0, 0.0, 1.0},
    {0.5, -0.5, -0.5, 1.0, 1.0, 1.0}};
 
int f[6][4] = {
    {0, 1, 2, 3},
    {3, 2, 6, 7},
    {4, 5, 6, 7},
    {0, 1, 5, 4},
    {1, 5, 6, 2},
    {0, 4, 7, 3}};
 
 
int main(int argc, char *argv[]){
 
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
        glutInitWindowPosition(200, 200);
        glutInitWindowSize(250, 250);
        g_nWindowID = glutCreateWindow("GLUT && OpenGL Teste");
 
        glClearColor(0, 0, 0, 0);
        glPointSize(2.0);
        glEnable(GL_DEPTH_TEST);
 
 
        glutDisplayFunc(display);
        glutKeyboardFunc(keyboard);
        glutMouseFunc(mouse);
        glutMotionFunc(mousemotion);
        glutReshapeFunc(reshape);
        glutMainLoop();
 
        exit( EXIT_SUCCESS);
}
 
 
void keyboard(unsigned char key, int x, int y){
 
    int ret_exc = 0;
    switch(key){
        case 'p':
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            glutPostRedisplay();
            break;
        case 'f':
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
            glutPostRedisplay();
            break;
        case 's':
            glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
            glutPostRedisplay();
            break;
        case 'd':
            glEnable(GL_DEPTH_TEST);
            glutPostRedisplay();
            break;
        case 'D':
            glDisable(GL_DEPTH_TEST);
            glutPostRedisplay();
            break;
 
            /*
             *  Commande lancement de système
             */
        case 'c':
        case 'C':
            system("./Deb");
            break;
            /*
             * Fermeture de la fenêtre
             */
        case 'q':
            glutDestroyWindow(g_nWindowID);
            exit(EXIT_SUCCESS);
            break;
    }
}
 
 
void display(){
    int i, j;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    for(i = 0; i < 6; i++) {
        glBegin(GL_POLYGON);
        for(j = 0; j < 4; j++) {
            glColor3f(p[f[i][j]].r, p[f[i][j]].g, p[f[i][j]].b);
            glVertex3f(p[f[i][j]].x, p[f[i][j]].y, p[f[i][j]].z);
        }
        glEnd();
    }
    glFlush();
    glLoadIdentity();
    glRotatef(-anglex, 0.0, 1.0, 0.0);
    glRotatef(-angley, 1.0, 0.0, 0.0);
    glutSwapBuffers();
}
 
void mouse(int button, int state, int x, int y){
    if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
        presse = 1;
        xold = x;
        yold = y;
    }
    if(button == GLUT_LEFT_BUTTON && state == GLUT_UP) presse = 0;
}
 
void mousemotion(int x, int y) {
    if(presse == 1) {
        anglex = anglex + (x-xold);
        angley = angley + (y-yold);
        glutPostRedisplay();
    }
    xold = x;
    yold = y;
}
 
void reshape(int x, int y) {
    if(x < y) glViewport(0, (y-x)/2, x, x);
    if(y < x) glViewport((x-y)/2, 0, y, y);
}

Code Compile :

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

gcc main.c -framework GLUT -framework OpenGL -framework Cocoa -o Deb

Après avoir lancé la première fenêtre graphique et que l’on appuie sur la touche "C", on remarque clairement que l’on lance une nouvelle fenêtre graphique dont la première ne peut continuer son exécution. Elle est bloquée.
Quant à la seconde, elle fonctionne et si l’on appuie à nouveau sur la touche "C", le phénomène devient récurrent cette fois la troisième fenêtre est fonctionnelle, mais pas les deux fenêtres graphiques précédentes. Pour reprendre le flux d’exécution de chaque fenêtre, il faut arrêter le successeur du prédécesseur.

Il est clair que "system" dans cette situation n’est pas du tout adapté et il n’y a aucun intérêt à employer "system" de cette façon.
En revanche, pour que l’application puisse fonctionner avec la fameuse fonction "system", vous êtes obligé de créer un nouveau processus cela a l’avantage de ne pas interrompre le flux d’exécution de la première fenêtre ouverte. Au final, vous obtenez, deux applications qui fonctionnent indépendamment.

Attention, cela ne veut pas dire que le code source ou la solution énoncée précédemment est parfait, idéales ou autre dans l’état. Elle est faite pour justifier l’utilisation des processus avec la fonction "system" pour exécuter un programme externe indépendamment de la première. J’insiste fortement là-dessus : C’est un exemple donc, il ne faut pas comprendre autrement que les processus dans ce genre de situation sont la solution envisageable contrairement à la fonction "system" utiliser de façon directe.

Voici le code source qui utilise les processus. Étant sur une plate-forme Mac j’utilise "fork" vous pouvez faire de même sous Windows en utilisant « Cygwin ».
Attention, le codes sources ci-dessous est susceptible de comporter des erreurs, certaines syntaxes ou instructions ont été volontairement implémentés ou ignorés par moi dont l’unique but d’apporté (fournir) un exemple simple et fonctionnel ressemblant à la problématiques énoncées dans mon précédent poste.

Code C :

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
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
 
//
//  Glut_process.c
//  GLUT_Teste
//
//  Created by SAMBIA39 on 03/09/2016.
//  Copyright © 2016 SAMBIA39.
//
 
#include <stdio.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
 
#include <openGL/gl.h>
#include <openGL/glu.h>
#include <glut/glut.h>
 
typedef struct {
    float x, y, z, r, g, b;
} point;
 
void keyboard(unsigned char key, int x, int y);
void display();
void mouse(int button, int state, int x, int y);
void mousemotion(int x, int y);
void reshape(int x, int y);
 
 
float xold, yold, anglex = 0, angley = 0, presse = 0;
 
 
point p[8] = {
    {-0.5, -0.5, 0.5, 1.0, 0.0, 0.0},
    {-0.5, 0.5, 0.5, 0.0, 1.0, 0.0},
    {0.5, 0.5, 0.5, 0.0, 0.0, 1.0},
    {0.5, -0.5, 0.5, 1.0, 1.0, 1.0},
    {-0.5, -0.5, -0.5, 1.0, 0.0, 0.0},
    {-0.5, 0.5, -0.5, 0.0, 1.0, 0.0},
    {0.5, 0.5, -0.5, 0.0, 0.0, 1.0},
    {0.5, -0.5, -0.5, 1.0, 1.0, 1.0}};
 
int f[6][4] = {
    {0, 1, 2, 3},
    {3, 2, 6, 7},
    {4, 5, 6, 7},
    {0, 1, 5, 4},
    {1, 5, 6, 2},
    {0, 4, 7, 3}};
 
 
int main(int argc, char *argv[]){
 
    int ret_exec = 0;
    pid_t _id = fork();
    if( -1 == _id ){
        fprintf( stderr, "Erreur fork()\n" );
        exit( EXIT_FAILURE );
    }else if( 0 == _id )
        exit( EXIT_SUCCESS );
    if( 0 < _id ){
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
        glutInitWindowPosition(200, 200);
        glutInitWindowSize(250, 250);
        g_nWindowID = glutCreateWindow("GLUT && OpenGL Teste");
 
        glClearColor(0, 0, 0, 0);
        glPointSize(2.0);
        glEnable(GL_DEPTH_TEST);
 
 
        glutDisplayFunc(display);
        glutKeyboardFunc(keyboard);
        glutMouseFunc(mouse);
        glutMotionFunc(mousemotion);
        glutReshapeFunc(reshape);
        glutMainLoop();
 
        while( waitpid(-1, NULL, WNOHANG) > 0 );
        exit( EXIT_SUCCESS);
    }
}
 
 
void keyboard(unsigned char key, int x, int y){
 
    int ret_exc = 0;
    switch(key){
        case 'p':
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            glutPostRedisplay();
            break;
        case 'f':
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
            glutPostRedisplay();
            break;
        case 's':
            glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
            glutPostRedisplay();
            break;
        case 'd':
            glEnable(GL_DEPTH_TEST);
            glutPostRedisplay();
            break;
        case 'D':
            glDisable(GL_DEPTH_TEST);
            glutPostRedisplay();
            break;
 
        /*
         *  Commande lancement de système
         */
        case 'c':
        case 'C':
            system("./Deb");
            break;
        /*
         * Fermeture de la fenêtre
         */
        case 'q':
            glutDestroyWindow(g_nWindowID);
            exit(EXIT_SUCCESS);
            break;
    }
}
 
 
void display(){
    int i, j;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    for(i = 0; i < 6; i++) {
        glBegin(GL_POLYGON);
        for(j = 0; j < 4; j++) {
            glColor3f(p[f[i][j]].r, p[f[i][j]].g, p[f[i][j]].b);
            glVertex3f(p[f[i][j]].x, p[f[i][j]].y, p[f[i][j]].z);
        }
        glEnd();
    }
    glFlush();
    glLoadIdentity();
    glRotatef(-anglex, 0.0, 1.0, 0.0);
    glRotatef(-angley, 1.0, 0.0, 0.0);
    glutSwapBuffers();
}
 
void mouse(int button, int state, int x, int y){
    if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
        presse = 1;
        xold = x;
        yold = y;
    }
    if(button == GLUT_LEFT_BUTTON && state == GLUT_UP) presse = 0;
}
 
void mousemotion(int x, int y) {
    if(presse == 1) {
        anglex = anglex + (x-xold);
        angley = angley + (y-yold);
        glutPostRedisplay();
    }
    xold = x;
    yold = y;
}
 
void reshape(int x, int y) {
    if(x < y) glViewport(0, (y-x)/2, x, x);
    if(y < x) glViewport((x-y)/2, 0, y, y);
}

Code Compile :

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

gcc Glut_process.c -framework GLUT -framework OpenGL -framework Cocoa -o Deb_Process

Pour moi, l’utilisation de "system" doit être justifiée de plus, cette fonction est soumise à des problématiques de sécurité importantes je préférerais utilisé (dans la limite) « popen » où mieux encore « g_spawn_command_line_sync*», « g_spawn command line sync », « g_spawn_sync » «*g_spawn_async_with_pipes*» etc.. de la Glib(ici) et peut être « CreateProcess » dans le cas de Windows.
à bientôt.