Transformer un code sur la console en C++ en Qt

**khadijadadou** · 12/09/2013, 12h22

bonjour à tous
j'ai un code en c++ et je veux le refaire en Qt
aviez vous une idée qui me facilite la tâche?
voilà mon code
fichier main

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
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
 
#include <iostream>
#include "graph.h"
#include <iostream>
#include <ctime>
#include <malloc.h> 
#include<stdlib.h>
using namespace std;
#include"queue.h"
#include"prims_kruskal.h"
 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
 
 
 
int main(int argc, char** argv) 
{
    int choix,taille,nb_arc,a,b;
    int i=1;
    cout<<"*** graphe non value tapez 1 ***"<<endl<<"*** graphe  value tapez 2 ***"<<endl;
    cin>>choix ;
    if (choix==1)
    {
        cout<<"entrez la taille du graphe"<<endl;
        cin>>taille;
        Graph g(taille);
        cout<<"entrez le nombre d'arcs"<<endl;
        cin>>nb_arc;
        while( i!=nb_arc+1)
        {
            if(i==1)
                cout<<"pour le 1 er arc"<<endl;
            else
                cout<<"pour le "<<i<<" eme arc"<<endl;
            cout<<" entrez le sommet de depart ";
            cin>>a;
            cout<<"entrez le sommet d'arrivee ";
            cin>>b;
            g.addEdge(a,b) ;
            i++;
        }
        cout<<"*** voulez vous appliquer quel parcours sur votre graphe? ***"<<endl<<"*** parcours en profondeur tapez 1 ***"<<endl<<"*** parcours en largeur tapez 2 ***"<<endl<<"*** les deux parcours tapez 3 ***"<<endl; ;
        cin>>choix;
        if(choix==1)
        {
            cout<<"entrez le sommet racine "<<endl;
            cin>>a;
            cout<<"entrez le sommet d'arret "<<endl;
            cin>>b;
            g.DFS(a,b);
 
        }
 
        else if(choix==2)
        {
            cout<<"entrez le sommet racine "<<endl;
            cin>>a;
            cout<<"entrez le sommet d'arrivee "<<endl;
            cin>>b;
            g.BFS(a,b);
 
        }
        else if(choix==3)
        {
            cout<<"entrez le sommet racine "<<endl;
            cin>>a;
            cout<<"entrez le sommet d'arrivee "<<endl;
            cin>>b;
            g.BFS(a,b);
            g.DFS(a,b);
        }
        else
        {
            cout<<"choix non valide"<<endl;
        }
    }
    //valorise
    else if(choix==2)
    { 
 
        cout<<"*** plus court chemin tapez 1 ***"<<endl<<"*** arbre recouvrant a poids minimum tapez 2 ***"<<endl<<"*** flot maximum tapez 3 ***"<<endl;
        cin>>choix;
        if(choix==1)
        {
            cout<<"pas encore"<<endl;//pcc
        }
        else if (choix==2)
        {
 
            cout<<"*** quel algorithme voulez-vous appliquer sur votre graphe? ***"<<endl<<"*** PRIM tapez 1 ***"<<endl<<"*** KRUSKAL tapez 2 ***"<<endl<<"*** steiner tapez 3 ***"<<endl;
            cin>>choix;
            if(choix==1)
            { 
                prims_kruskal g;
                g.createGraph();
                g.prim();
            }
            else if(choix==2)
            {
                prims_kruskal g;
                g.createGraph();
                g.kruskal();
                //kruskal
            }
            else if(choix==3)
            { 
                cout<<"*** pas encore ***"<<endl;//steiner
            }
            else
            {
                cout<<"*** choix non valide ***"<<endl;
            }
 
        }
 
        else if (choix==3){
            //flot max
            cout<<"*** pas encore ***"<<endl;
        }
        else {
        }
    }
    //fin de valorisee
    else 
    {
        cout<<"choix non valide"<<endl;
    }
    /* Graph g(12);
    g.addEdge(1, 2); g.addEdge(1, 3);
    g.addEdge(2, 4); g.addEdge(3, 4);
    g.addEdge(3, 6); g.addEdge(4 ,7);
    g.addEdge(5, 6); g.addEdge(5, 7);
    //clock_t t1;
    // t1 = clock();
    g.BFS(1, 15);
    //float diff = (double)(clock() - t1)/CLOCKS_PER_SEC ;
    //cout <<endl<< "The time taken for Breadth first search: "<< diff << endl;
    g.DFS(1,15); */
    return 0;
}

fichier queue.h

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
37
38
39
40
41
42
43
44
45
 
#include "graph.h"
#include <iostream>
#include <ctime>
#include <malloc.h> 
#include<stdlib.h>
using namespace std;
 
#include"queue.h"
#include <iostream>
#include <ctime>
#include <malloc.h> 
#include<stdlib.h>
using namespace std;
 
 
 
struct node {
    int info;
    node *next;
}; 
 
class Queue {
    private:
        node *front;
        node *rear;
    public:
        Queue();
        ~Queue();
        bool isEmpty();
        void enqueue(int);
        int dequeue();
        void display(); 
 
}; 
class stack
{ struct node *top;
    public:
         stack();
        void push(int);
        int pop();
        bool isEmpty();
        void display();
 
};

fichier queue.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
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
 
#include "queue.h"
void Queue::display(){
    node *p = new node;
    p = front;
    if(front == NULL){
        cout<<"nNothing to Displayn";
    }else{
        while(p!=NULL){
            cout<<endl<<p->info;
            p = p->next;
        }
    }
} 
 
Queue::Queue() {
    front = NULL;
    rear = NULL;
} 
 
Queue::~Queue() {
    delete front;
} 
void Queue::enqueue(int data) {
    node *temp = new node();
    temp->info = data;
    temp->next = NULL;
    if(front == NULL){
        front = temp;
    }else{
        rear->next = temp;
    }
    rear = temp;
} 
 
int Queue::dequeue() {
    node *temp = new node();
    int value;
    if(front == NULL){
        cout<<"nQueue is Emtptyn";
    }else{
        temp = front;
        value = temp->info;
        front = front->next;
        delete temp;
    }
    return value;
} 
bool Queue::isEmpty() {
    return (front == NULL);
} 
stack::stack(){
    top = NULL;
} 
void stack::push(int data){
    node *p;
    if((p=(node*)malloc(sizeof(node)))==NULL){
        cout<<"Memory Exhausted";
        exit(0);
    }
    p = new node;
    p->info = data;
    p->next = NULL;
    if(top!=NULL){
        p->next = top;
    }
    top = p;
} 
 
int stack::pop(){
    struct node *temp;
    int value;
    if(top==NULL){
        cout<<"\nThe stack is Empty"<<endl;
    }else{
        temp = top;
        top = top->next;
        value = temp->info;
        delete temp;
    }
    return value;
} 
 
bool stack::isEmpty(){
    return (top == NULL);
} 
 
void stack::display(){
    struct node *p = top;
    if(top==NULL){
        cout<<"\nNothing to Display\n";
    }else{
        cout<<"\nThe contents of Stack\n";
        while(p!=NULL){
            cout<<p->info<<endl;
            p = p->next;
        }
    }
}

fichier graph.h

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
#include "graph.h"
#include <iostream>
#include <ctime>
#include <malloc.h> 
#include<stdlib.h>
using namespace std;
#include"queue.h"
 
 class Graph {
    private:
        int n;
        int **A;
    public:
        Graph(int size = 2);
        ~Graph();
        bool isConnected(int, int);
        void addEdge(int x, int y);
        void BFS(int , int);
        void DFS(int , int);
};

fichier graph.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
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
 
#include "graph.h"
Graph::Graph(int size) {
    int i, j;
    if (size < 2) n = 2;
    else n = size;
    A = new int*[n];
    for (i = 0; i < n; ++i)
        A[i] = new int[n];
    for (i = 0; i < n; ++i)
        for (j = 0; j < n; ++j)
            A[i][j] = 0;
} 
 
Graph::~Graph() {
    for (int i = 0; i < n; ++i)
    delete [] A[i];
    delete [] A;
} 
 
bool Graph::isConnected(int x, int y) {
    return (A[x-1][y-1] == 1);// diff de 0
} 
 
void Graph::addEdge(int x, int y) {
    A[x-1][y-1] = A[y-1][x-1] = 1;
} 
void Graph::BFS(int x, int required) {
    Queue Q;
    bool *visited = new bool[n+1];
    int i;
    for (i = 1; i <= n; ++i)
    visited[i] = false;
    Q.enqueue(x);
    if(x == required) return;
    visited[x] = true;
    cout << "Breadth first Search starting from vertex ";
    cout << x << " : " << endl;
    while (!Q.isEmpty()) {
        int k = Q.dequeue();
        if(k == required){
            cout<<" FOUND HERE ";
            continue;
        }
        cout << k << " ";
        for (i = 1; i <= n; ++i)
            if (isConnected(k, i) && !visited[i]) {
                Q.enqueue(i);
                visited[i] = true;
            }
    }
    cout << endl;
    delete [] visited;
} 
void Graph::DFS(int x, int required){
    stack s;
    bool *visited = new bool[n+1];
    int i;
    for(i = 0; i <= n; i++)
        visited[i] = false;
    s.push(x);
    visited[x] = true;
    if(x == required) return;
    cout << "Depth first Search starting from vertex ";
    cout << x << " : " << endl;
    while(!s.isEmpty()){
        int k = s.pop();
        if(k == required) break;
        cout<<k<<" ";
        for (i = n; i >= 0 ; --i)
            if (isConnected(k, i) && !visited[i]) {
                s.push(i);
                visited[i] = true;
            }
    }
    cout<<endl;
    delete [] visited;
}

fichier prims_kruskal.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 #include<stdio.h>
#include<stdlib.h>
using namespace std;
 
 
class prims_kruskal
{
     int graph[20][20],nodes;
public:
    prims_kruskal();
    void createGraph();
    void prim();
    void kruskal();
};

fichier prims_kruskal.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
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
#include "prims_kruskal.h"
#include<iostream>
#define infinity 5343636
using namespace std;
 
 prims_kruskal :: prims_kruskal(){
    for(int i=0;i <     20;i++)
        for(int j=0;j < 20;j++)
            graph[i][j]=0;
}
 
 
 
void prims_kruskal :: createGraph(){
    int i,j,m,c,a,b;
    j=1;
    cout << "Entez le nombre total des noeuds : ";
    cin >> nodes;
    cout << "\n\nEntez la matrice d'adjacence : \n";
    for(i=0;i < nodes;i++)
        for(j=0;j < nodes;j++)
            cin >> graph[i][j];
    //cout<<"entrez le nombre des arcs : " ;
    //cin>>m;
    //cout << "\n\nEntez la matrice d'adjacence : \n";
    //for(i=0;i < nodes;i++)
    //{
    /*while(j<=m)
    {
        if(j==1)
        cout<<"pour le 1 er arc : "<<endl;
        else
        cout<<"pour le "<<j<<" eme arc : "<<endl;
        cout<<"entrez le sommet de depart"<<endl;
        cin>>a;
        cout<<"entrez le sommet d'arrivee"<<endl;
        cin>>b;
        cout<<"entrez le cout"<<endl;
        cin>>c;
        j++;
 
    //}*/
 
 
    //graph[a-1][b-1]=graph[b-1][a-1]=c;
 
 
 
    //Assign infinity to all graph[i][j] where weight is 0.
    for(i=0;i < nodes;i++){
        for(j=0;j < nodes;j++){
            if(graph[i][j]==0)
                graph[i][j]=infinity;
        }
    }
}
 
 
 
void prims_kruskal :: prim(){
    cout<<"*** arbre couvrant par l'algorithme de prim : ***" ;
    int selected[20];
    int i,j,ne; //ne for no. of edges
    int fals=0;
    int tru=1;
    int min,x,y;
    for(i=0;i < nodes;i++)
        selected[i]=fals;
    selected[0]=tru; ne=0;
    while(ne < nodes-1){
        min=infinity;
 
        for(i=0;i < nodes;i++)
        {
            if(selected[i]==tru){
                for(j=0;j < nodes;j++){
                    if(selected[j]==fals){
                        if(min > graph[i][j])
                        {
                            min=graph[i][j];
                            x=i;
                            y=j;
                        }
                    }
                }
            }
        }
        selected[y]=true;
 
        cout<<"\narc de " << x+1 << " --> " << y+1;
        ne=ne+1;
    }
}
 
void prims_kruskal::kruskal()
{
    cout<<"\n*** arbre couvrant par l'algorithme de kruskal : ***" ;
    int i,j,k,visit,visited[10],l,v,count,count1,vst,p,dup1,dup2;
    visit=1;
    while(visit<nodes)
    {
        v=infinity;
        for(i=0;i<nodes;i++)
            for(j=0;j<nodes;j++)
            if(graph[i][j]!=infinity && graph[i][j]<v  && graph[i][j]!=-1 )
            {
                int count =0;
                for(p=0;p<nodes;p++)
                {
                    if(visited[p]==i || visited[p]==j)
                        count++;
                }
                if(count >= 2)
                {
                    for(p=1;p<=nodes;p++)
                        if(graph[i][p]!=infinity && p!=j)
                            dup1=p;
                    for(p=1;p<=nodes;p++)
                        if(graph[j][p]!=infinity && p!=i)
                            dup2=p;
 
                    if(graph[dup1][dup2]==-1)
                        continue;
                }
                l=i;
                k=j;
                v=graph[i][j];
            }
 
        cout <<"\narc de " <<l+1 <<"-->"<<k+1;
        graph[l][k]=-1;
        graph[k][l]=-1;
        visit++;
        int count=0;
        count1=0;
        for(i=1;i<=nodes;i++)
        {
            if(visited[i]==l)
                count++;
            if(visited[i]==k)
                count1++;
        } 
        if(count==0)
            visited[++vst]=l;
        if(count1==0)
            visited[++vst]=k;
    }
}

aidez-moi SVP et merci d'avance

**koala01** · 12/09/2013, 12h57

Salut,

Comme tu es parti, je dirais que tu peux récupérer tes fichiers d'en-tête, mais que tu est bon pour virer tous tes fichiers d'implémentation!, ou à peu près.

Cela ne te ferait de toutes manières pas de tord, parce qu'une fonction main contenant une centaine de lignes, c'est une fonction qui en contient très certainement au minimum 75 de trop

si tu veux pouvoir faire évoluer ton application en fonction de tes envies ou de tes besoins, il faut le prévoir dés le départ, autrement, tu pars à la catastrophe.

Il y a, entre autres, cinq principes à respecter scrupuleusement. Ils sont réunis dans l'acronyme SOLID

Tu n'en as très certainement pas respecté le S (mis pour SRP ou Single Responsability Principle ou en francais : principe de la responsabilité unique) avec ta fonction main, pas plus que tu n'en as respecté le D (mis pour DIP ou Dependy Inversion Principle ou en français Principe d'inversion des dépendances) en n'utilisant pas une abstraction pour ce qui est de l'affichage et en utilisant systématiquement cout dans tout ton code.

Avant de pouvoir faire quoi que ce soit, il faudra de toutes manières résoudre ces deux problèmes et faire une distinction nette entre ce qui est tes données "métier" d'une part et tout ce qui a trait à l'affichage et à l'introduction par l'utilisateur d'autre part.

En outre, on sent particulièrement fort "l'ancienne école" et l'influence d'habitudes issues du C dans ton code.

Cela fait une bonne dizaine d'années que nous nous battons (en tout cas, depuis que je le fréquente et je présumes que c'était déjà le cas avant) sur ce forum pour inciter les gens à perdre ces habitudes qui sont peut être excellentes en C mais qui manquent cruellement de sécurité en C++.

Une approche plus "moderne" de ton code qui utiliserait l'ensemble des possibilités propres (tu pourrais déjà commencer par utiliser la classe std::queue au lieu de ta file perso et std::vector au lieu de tes tableaux C style, ce serait déjà pas si mal

) au C++ serait tout à ton bénéfice

Enfin, tu devrais vraiment penser à supprimer les lignes de code que tu as commentées, vu qu'elles sont devenue inutiles... Cela faciliterait grandement la lecture

**AF_2.8** · 16/09/2013, 11h34

Tel quel, en oubliant les soucis éventuels d'organisation du code soulignés koala01, tu n'as aucune difficulté à importé ton projet sous QT.
Il te suffit de créer un projet QT en mode console. Tu copie toutes classes dans le répertoire du projet QT et tu les inclus.
Tu n'aura que le fichier main à modifier à la main.

Transformer un code sur la console en C++ en Qt

C++

Vue hybride

Discussions similaires

Partager

Partager