paramètres pour la fonction main en c ++

[polo29]

bonjour,

je voudrais savoir s'il est est-il possible d'avoir des paramètres pour la fonction main qui viennent de sous programmes?

je m'explique: dans mon main je définis une matrice, j'ai des sous programmes qui travaillent dessus et créent d'autres matrices. dans la suite de mon main, je veux me servir de ces matrices en leur appliquant d'autres sous programmes. comment indiquer à mon main où aller les chercher (les matrices créees par les sous programmes)?

j'ai essayé de les déclarer en paramètres de main: int tab[][], ainsi que char* mais il bloque à la compilation..

merci d'avance!

[Yarflam]

Salut.
Je ne suis pas très pro sur C++.
Mais je te conseille d'utiliser la POO pour ce genre de traitement.
Ça te donnera plus de clarté et d'efficacité.
Et du coup tu disposeras de l'héritage. A ne pas négliger.

[fred]

@polo29
J'ai rien compris, mais ton problème semble être l'inclusion de multiples headers (.h ou .hpp)

@Yarflam
L'héritage est un avantage? Dans quel cas on l'utilise?

[Yarflam]

L'héritage permet de dupliquer les attributs et les méthodes d'une classe existante pour en concevoir une autre.

Par exemple j'ai ma classe Cube qui possède les attributs ID, X, Y, Couleur et je veux une classe "Cube Magma" pour ajouter les attributs Température, Luminosité. L'héritage permettra de définir une extension à la classe Cube, tout en ajoutant le complément. Ça évite de définir à nouveau les paramètres communs.

Enjoy !

[fred]

L'héritage permet de dupliquer les attributs et les méthodes

Ok, mais concrètement en terme d'objet, quel est son avantage?

Imaginons je prend une table de cuisine, je crée ma classe et j'hérite de table, donne moi un exemple d'objet pouvant hériter de table.

[Yarflam]

Ok, mais concrètement en terme d'objet, quel est son avantage?

Qu'est-ce que je peux te dire de plus ? Ça hérite. On étend un modèle vers des spécifications particulières.

Donne moi un exemple d'objet pouvant hériter de table.

On peut par exemple hériter la table de cuisine selon l'origine géographique / le bois / l'année de fabrication / les actions possibles. Table_Louis_XVI_Chêne, Table_Holographique_Rouge, Table_Véhicule_Magique, Table_IKEA_Blanc_2013. L'imagination que diable !

img14.jpg
img15.jpg
NB: L'image ci-dessus montre simplement le résultat de deux objets créés sous les deux constructeurs, dont un héritant de l'autre.

Très bon tuto sur le site du zéro.

Quand est-ce que je sais si telle classe doit hériter d'une autre ?

Soit deux classes A et B. Pour qu'un héritage soit possible, il faut que vous puissiez dire que Aest unB. Par exemple, un magicien est un personnage, donc héritage. Un chien est un animal, donc héritage aussi. Bref, vous avez compris le principe.

[fred]

On peut par exemple hériter la table de cuisine selon l'origine géographique / le bois / l'année de fabrication / les actions possibles. Table_Louis_XVI_Chêne, Table_Holographique_Rouge, Table_Véhicule_Magique, Table_IKEA_Blanc_2013. L'imagination que diable !

Désolé c'était une question fermée. En fait non, l'héritage ne doit pas être utilisé pour modifier des attributs, mais pour en ajouter ou en supprimer.

En gros, une table basse peut hériter d'une table de cuisine, car des actions (méthodes) et des attributs s'y retrouvent, seulement concrètement, la table basse n'a pas le même rôle qu'une table de cuisine.

table de cuisine -> Pour manger
table basse -> Pour poser des bibelots par exemple.

cependant elles ont les mêmes attributs (couleur, taille, hauteur, ...), des méthodes identiques (déplacer, changer_couleur, ...), par contre on peut ajouter des méthodes à table basse, ce qui va lui modifier son rôle, comme par exemple une méthode poser, tourner, diminuer_taille, ...

Bref la notion d'héritage mal comprise, ça fait un sacré massacre dans du code
En général on dit toujours cela
"Si tu te poses des questions sur l'héritage, c'est qu'à 99% des cas, l'héritage est inutile."

[Yarflam]

Hum ... tu peux parler tout seul devant ton PC ça reviendra au même. :/

[Docteur Lalla]

Bonjour à tous,

l'héritage est simplement un moyen de spécialiser une classe en créant une ou plusieures sous-classe(s). On peut comparer ça à une hiérarchie de catégories (lien entre un fruit et une banane par exemple). On a besoin de faire hériter B de A si et seulement si on peut dire "B est un A".

Pour revenir dans le sujet, l'héritage ou même la POO n'a absolument rien à voir avec le problème de l'OP. En fait, il faudrait que tu ailles voir du côté des "pipes" (tuyaux), des processus et éventuellement du réseau (cas extrême). Tu peux essayer de formatter tes matrices de manière à les envoyer en entrée à ton sous-programme et les récupérer via sa sortie standard (typiquement std::cout).

En espérant t'avoir aidé.
Bisou.

[Yarflam]

Tu ferais bien te poster ton code source polo29.
Histoire qu'on évalue un peux tout ça.

[polo29]

le voici!

c'est sensé être un programme pour gérer un projet: on a des tâches avec les temps nécessaires pour les accomplir, ainsi que des relations entre elles (tache 2 construire les murs après tâche 1: construire les fondations).

on en fait une matrice (donnée directement dans le main) sur laquelle on travaille pour savoir le temps le plus court pour finir le projet et les étapes qui déterminent ce chemin le plus court.

les 2 matrices que je voudrai passer en paramètre de main sont int PoidsCumul[TailleMax] et int CheminPlusCourt[TailleMax]. ici elles sont déclarées en variables globales suite à mes recherches. ça marche, mais j'aimerai pouvoir les mettre seulement en paramètre de main pour utiliser moins de mémoire (ou tout simplement pour savoir le faire!)

#include <iostream>
using namespace std;

#define TailleMax 100

int PoidsCumul[TailleMax];int CheminPlusCourt[TailleMax];

int AfficheGraphe(int graphe[TailleMax][TailleMax], int & nbS);
int AppartVoisins(int graphe[TailleMax][TailleMax], int x, int  y);
int AfficheGraphe(int graphe[TailleMax][TailleMax], int & nbS);
int CalcPoidsCumul (int graphe[TailleMax][TailleMax], int & nbS);
int Affichetableau (int PoidsCumul[TailleMax], int & nbS);
int DefineChemin( int & nbS,int graphe[TailleMax][TailleMax]  );

//---------------------------------------------------

int main(  )
{ int nbS; int graphe[TailleMax][TailleMax]; int k; 
     
	 nbS=8;
     
     
     
    graphe[0][0] = 0;graphe[0][1] =16;graphe[0][2] =10;graphe[0][3] =4;graphe[0][4] =0;graphe[0][5] =0;graphe[0][6] =0;graphe[0][7] =0;

    graphe[1][0] =0;graphe[1][1] =0;graphe[1][2] =0;graphe[1][3] =0;graphe[1][4] =0;graphe[1][5] =0;graphe[1][6] =4;graphe[1][7] =0;

    graphe[2][0] =0;graphe[2][1] =0;graphe[2][2] =0;graphe[2][3] =0;graphe[2][4] =12;graphe[2][5] =0;graphe[2][6] =21;graphe[2][7] =0;

    graphe[3][0] =0;graphe[3][1] =0;graphe[3][2] =0;graphe[3][3] =0;graphe[3][4] =10;graphe[3][5] =0;graphe[3][6] =0;graphe[3][7] =0;

    graphe[4][0] =0;graphe[4][1] =0;graphe[4][2] =0;graphe[4][3] =0;graphe[4][4] =0;graphe[4][5] =3;graphe[4][6] =0;graphe[4][7] =0;

    graphe[5][0] =0;graphe[5][1] =0;graphe[5][2] =0;graphe[5][3] =0;graphe[5][4] =0;graphe[5][5] =0;graphe[5][6] =3;graphe[5][7] =5;

    graphe[6][0] =0;graphe[6][1] =0;graphe[6][2] =0;graphe[6][3] =0;graphe[6][4] =0;graphe[6][5] =0;graphe[6][6] =0;graphe[6][7] =3;

    graphe[7][0] =0;graphe[7][1] =0;graphe[7][2] =0;graphe[7][3] =0;graphe[7][4] =0;graphe[7][5] =0;graphe[7][6] =0;graphe[7][7] =0;


	
   AfficheGraphe(graphe,  nbS); 
   
   CalcPoidsCumul ( graphe,  nbS);
   
   
   cout<<"le temps le plus court est "<<CalcPoidsCumul ( graphe,  nbS)<<" jours \n ";
   
      DefineChemin(  nbS, graphe );
   
	
return 0;	
}


//---------------------------------------------------

int AppartVoisins(int graphe[TailleMax][TailleMax], int x, int  y)
{

int voisin; 

voisin = 0;

if(graphe[x][y]!=0){
voisin = 1;}

return voisin;
}

//---------------------------------------------------

int AfficheGraphe(int graphe[TailleMax][TailleMax], int & nbS)
{

int i,j; 

for (i=0; i<nbS; i++){
 for (j=0; j<nbS; j++){
     
     cout<<" "<<graphe[i][j]<<"\t";
                
     }  
cout<<"\n"; 
}
return 0;
}

//---------------------------------------------------


int CalcPoidsCumul (int graphe[TailleMax][TailleMax], int & nbS){

int i; int j; 



for (i = 0 ;i< nbS ;i=i+1){
PoidsCumul[i] = 0;}

for (i = 0 ;i< nbS ;i=i+1)
{
                               for (j = i ;j< nbS ;j=j+1)
                               {
                                               if  (AppartVoisins(graphe,i,j) ==1)
                                               { if( PoidsCumul[j]==0 || PoidsCumul[j]< PoidsCumul[i]+graphe[i][j]   )
                                                  {
                                                     PoidsCumul[j] = PoidsCumul[i]+graphe[i][j];
                                                  }
                                               }

                               }
}
      Affichetableau( PoidsCumul, nbS );
      return PoidsCumul[nbS-1]; 



    }
    
  //-------------------------------------  
    
    

int Affichetableau (int PoidsCumul[TailleMax], int & nbS)
{int i;

for (i=0; i<nbS; i++){


     cout<<" "<<PoidsCumul[i]<<" ";

     }
cout<<"\n";

return 0;
}


//------------------------------------------------



int DefineChemin( int & nbS,int graphe[TailleMax][TailleMax] ){

    int i; int j ; int k; 


for (i = 0 ;i< nbS ;i=i+1){
                            CheminPlusCourt[i] = 0;
                          }


for (i = 0 ;i< nbS ;i=i+1)
{
                               for (j = i ;j< nbS ;j=j+1)
                               {
                                               if  (AppartVoisins(graphe,i,j) ==1)
                                               { if( PoidsCumul[j]==0 || PoidsCumul[j]< PoidsCumul[i]+graphe[i][j]   )
                                                  {
                                                     PoidsCumul[j] = PoidsCumul[i]+graphe[i][j]; CheminPlusCourt[i]=i;
                                                  }
                                               }

                               }
}
cout<<"les étapes du chemin le plus court sont ";
 for (k = 0 ;k< nbS ;k=k+1){ cout<<CheminPlusCourt[k];

}
  return 0;
}

[Docteur Lalla]

Du coup, je ne comprends plus trop. Tu veux envoyer tes matrices à une fonction ou à un autre programme ?
Pour les envoyer à des fonctions, plutôt que d'écrire des crochets (pour montrer que c'est un tableau), écrire un astérisque (pour montrer que c'est un pointeur), et ça marche.

[polo29]

je dois mettre int main( PoidsCumul*[TailleMax];int* CheminPlusCourt[TailleMax]) ?

pour l'objectif: j'ai défini une matrice graphe dans le main
j'ai deux sous programme qui travaillent dessus: CalcPoidsCumul et DefineChemin, chacun crée une petite matrice avec.

j'ai un autre sous programme: Affichetableau, que je veux exécuter dans le main pour pouvoir afficher mon résultat.

comment faire pour que le main aille chercher mes deux petites matrices au bon endroit?

[Yarflam]

Je vais déjà remettre sur pied mon CODE::Blocks qui je ne sais pour quel raison ne marche pas sur Windows 8 (le compiler). Après je pourrai t'aider.

EDIT : Bon, j'ai installé CODE::Blocks sur LinuxMint.
Ton code fonctionne correctement. Et je l'ai un peux organisé.
Je vais essayer de le comprendre ...

[Yarflam]

Voilà j'ai corrigé ton code. Il suffisait de définir des variables globales.
http://www.anonpaste.me/anonpaste2/i...L18nl+UZHLGG0=

#include <iostream>
using namespace std;

#define TailleMax 100

int PoidsCumul[TailleMax];
int CheminPlusCourt[TailleMax];
int graphe[TailleMax][TailleMax];
int nbS;
int AfficheGraphe();
int Affichetableau();
int CalcPoidsCumul();
int DefineChemin();
int AppartVoisins(int x, int y);

//---------------------------------------------------//

int main(  ) {
    int k;
    nbS=8;
    graphe[0][0] =0;graphe[0][1] =16;graphe[0][2] =10;graphe[0][3] =4;graphe[0][4] =0;graphe[0][5] =0;graphe[0][6] =0;graphe[0][7] =0;
    graphe[1][0] =0;graphe[1][1] =0;graphe[1][2] =0;graphe[1][3] =0;graphe[1][4] =0;graphe[1][5] =0;graphe[1][6] =4;graphe[1][7] =0;
    graphe[2][0] =0;graphe[2][1] =0;graphe[2][2] =0;graphe[2][3] =0;graphe[2][4] =12;graphe[2][5] =0;graphe[2][6] =21;graphe[2][7] =0;
    graphe[3][0] =0;graphe[3][1] =0;graphe[3][2] =0;graphe[3][3] =0;graphe[3][4] =10;graphe[3][5] =0;graphe[3][6] =0;graphe[3][7] =0;
    graphe[4][0] =0;graphe[4][1] =0;graphe[4][2] =0;graphe[4][3] =0;graphe[4][4] =0;graphe[4][5] =3;graphe[4][6] =0;graphe[4][7] =0;
    graphe[5][0] =0;graphe[5][1] =0;graphe[5][2] =0;graphe[5][3] =0;graphe[5][4] =0;graphe[5][5] =0;graphe[5][6] =3;graphe[5][7] =5;
    graphe[6][0] =0;graphe[6][1] =0;graphe[6][2] =0;graphe[6][3] =0;graphe[6][4] =0;graphe[6][5] =0;graphe[6][6] =0;graphe[6][7] =3;
    graphe[7][0] =0;graphe[7][1] =0;graphe[7][2] =0;graphe[7][3] =0;graphe[7][4] =0;graphe[7][5] =0;graphe[7][6] =0;graphe[7][7] =0;

   AfficheGraphe();
   CalcPoidsCumul();

   cout<<"le temps le plus court est "<<CalcPoidsCumul()<<" jours \n ";
   DefineChemin();
   return 0;
}

//---------------------------------------------------//

int AppartVoisins(int x, int  y) {
    int voisin;
    voisin = 0;
    if(graphe[x][y] != 0){ voisin = 1; }
    return voisin;
}

//---------------------------------------------------//

int AfficheGraphe() {
    int i,j;
    for (i=0; i<nbS; i++) {
        for (j=0; j<nbS; j++) {
            cout<<" "<<graphe[i][j]<<"\t";
        }
        cout<<"\n";
    }
    return 0;
}

//---------------------------------------------------//


int CalcPoidsCumul (){
    int i; int j;
    for (i = 0 ;i< nbS ;i=i+1) { PoidsCumul[i] = 0; }
    for (i = 0 ;i< nbS ;i=i+1) {
        for (j = i ;j< nbS ;j=j+1) {
            if (AppartVoisins(i,j) ==1) {
                if (PoidsCumul[j]==0 || PoidsCumul[j]< PoidsCumul[i]+graphe[i][j]) {
                    PoidsCumul[j] = PoidsCumul[i]+graphe[i][j];
                }
            }
        }
    }
    Affichetableau();
    return PoidsCumul[nbS-1];
}

//---------------------------------------------------//

int Affichetableau () {
    int i;
    for (i=0; i<nbS; i++) {
        cout<<" "<<PoidsCumul[i]<<" ";
    }
    cout<<"\n";
    return 0;
}

//---------------------------------------------------//

int DefineChemin(){
    int i; int j ; int k;
    for (i = 0 ;i< nbS ;i=i+1) {
        CheminPlusCourt[i] = 0;
    }
    for (i = 0 ;i< nbS ;i=i+1) {
        for (j = i ;j< nbS ;j=j+1) {
            if  (AppartVoisins(i,j) ==1) {
                if( PoidsCumul[j]==0 || PoidsCumul[j]< PoidsCumul[i]+graphe[i][j]) {
                    PoidsCumul[j] = PoidsCumul[i]+graphe[i][j]; CheminPlusCourt[i]=i;
                }
            }
        }
    }
    cout<<"les étapes du chemin le plus court sont ";
    for (k = 0 ;k< nbS ;k=k+1){ cout<<CheminPlusCourt[k]; }
    return 0;
}