appeler une méthode appartenant à un objet pendant sa définition

Bonjour,

Le sujet à l'air un peu compliqué donc voila le code pour que se soit plus simple à comprendre :

class grille() {
public : ...
private :...
}

grille::actions() {
//Depuis cette méthode on voudraita appeler la méthode grille::aide(int)
}

on a utilisé les syntaxes suivantes qui se sont montrées inefficaces :
aide (3);
this -> aide (3);


Voila.
En espérant que quelqu'un prenne le temps de se pencher sur le problème.
Merci d'avance.


PS : le reste du code est bon mais on peut toujours en envoyer un bout si ça peut vous aider.

Normalement depuis une méthode membre on peut appemer n'importe quelle autre méthode membre de la classe. Il faudrait plus de code ainsi que les messages d'erreurs du compilo ou du linker.

ok alors voila le code :

Mets le dans ton compilateur, pour comprendre le fonctionnement du programme regarde surtout les méthodes :

grille::actions() //Dans le case '3' du switch(key)
et grille::aide()
Merci beaucoup

pour que le programme marche, il te faudrait une liste de mot dans un fichier que nous avons sur le pc... Mais le programme ne va aps jusque la pour l'instant ^^

enfin, pour entrer un mot dans la grille il te suffit de le taper normalement.
ensuite tu peut naviguer dans la grille avec les touches 4,2,6,8
pour supprimer une lettre appuie sur 7
pour ajouter une case noire appuie sur 9
(le programme est une aide a la conception de mots croisés)
pour lancer l'aide a la conception pour un mot horizontal place toi sur la premiere lettre de ce mot et tape 3
et pour pour un mot vertical tape 1

eninf enfin, le concept est de laisser 2 ou 3 cases vides et le programme doit proposer une liste de mots qui conviennent.




//Conception de mots croisés v0.1b

#include <cstdlib>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <time.h>
#include <conio.h>

#define N 100
#define M 10000000

int bye;

//LES CLASSES

class grille {
protected:
 char tableau[N][N];
 int nblignes; // Taille
 int nbcolonnes;
 int curseurli; //Curseur
 int curseurco;
public:
 grille (int,int); //Constructeur
 void ajouterlettre (char[],int,int);
 void ajoutercasenoire (int,int);
 void supprimer (int,int);
 void afficher ();
 void actions (); //Pilotage curseur
 void aide(int);
 //void validation();
};

grille::grille (int Nli,int Nco) {
 nblignes=Nli;
 nbcolonnes=Nco;
 curseurli=1;
 curseurco=1;
 int i;
 int j;
 for(i=1;i<=nblignes;i++) {
  for(j=1;j<=nbcolonnes;j++) {
   tableau[i][j]='.';
  }
 }
}

void grille::ajouterlettre (char lettre[10],int li,int co) {
 tableau[li][co]=lettre[0];
}

void grille::supprimer (int li,int co) {
 tableau[li][co]='.';
}

void grille::ajoutercasenoire (int li,int co) {
 tableau[li][co]='#';
}

void grille::afficher () {
 int i;
 int j;
 char tabaffichage[N][N];
 for(i=1;i<=nblignes;i++) {
        for(j=1;j<=nbcolonnes;j++) {
            tabaffichage[i][j]=tableau[i][j];
        }
    }   
 tabaffichage[curseurli][curseurco]='@';
 printf("(%d, %d)\n\n",curseurli,curseurco);
 for(i=1;i<=nblignes;i++) {
        for(j=1;j<=nbcolonnes;j++) {
   if(j==nbcolonnes) {
    printf("%c\n",tabaffichage[i][j]);
   }
   else {
    printf("%c ",tabaffichage[i][j]);
   }
  }
 }   
}

void grille::actions (){
 char key;
 key=getche();
 switch(key) {
  case '2':
   if(curseurli==nblignes) {
    curseurli=1;
   }
   else {
    curseurli++;
   }
   break;
  case '8':
   if(curseurli==1) {
    curseurli=nblignes;
   }
   else {
    curseurli--;
   }
   break;
  case '4':
   if(curseurco==1) {
    curseurco=nbcolonnes;
   }
   else {
    curseurco--;
   }
   break;
  case '6':
   if(curseurco==nbcolonnes) {
    curseurco=1;
   }
   else {
    curseurco++;
   }
   break;
  case '9':
   tableau[curseurli][curseurco]='.';
   break;
  case '7':
   tableau[curseurli][curseurco]='#';
   if(curseurco!=nbcolonnes) {curseurco++;}
   else if(curseurli!=nblignes) {curseurco=1; curseurli++;}
   else {}
   break;
        case '1':
   aide(key);
            break;
        case '3':
   aide(key);
            break;              
  case '0':
   bye++;
   break;
  default:
   tableau[curseurli][curseurco]=key;
   if(curseurco!=nbcolonnes) {curseurco++;}
   else if(curseurli!=nblignes) {curseurco=1; curseurli++;}
   else {}
   break;
 }
}

void grille::aide(int a) {
     char tampon[50];
     if (a==1) {
        int i=curseurli;
        int j=0;
        while (tableau[i][curseurco]!='#' && i<=nblignes) {
              tampon[j]=tableau[i][curseurco];
              i++;j++;
              }
     }
     else if (a==3) {
        int i=curseurco;
        int j=0;
        while (tableau[curseurli][i]!='#' && i<=nbcolonnes) {
              tampon[j]=tableau[curseurli][i];
              i++;j++;
              }
     }
     FILE* fic;
  char complist[50][M];
  int taille=1;
  int k;
  char mot[50];
     strcpy(mot,tampon);
  char aux[50];
  fic=fopen("mots.dat","r");
  if(fic!=NULL){
    while(!feof(fic)){
     int l=0;
    int mauvais=0;
    fscanf(fic,"%s",aux);
    if(strlen(mot)==strlen(aux)){
     while (l!=strlen(mot) && !mauvais){
      if( (aux[l]==mot[l]) || (mot[l]=='.') ) {}
      else{
       mauvais++;
      }
      l++;
     }
     if(mauvais==1){
     }
     else{strcpy(complist[taille],aux);taille++;}
    }
    else{}
   }
   fclose(fic);
  }
  else{printf("Probleme mots.dat nexiste pas");}
  system("cls");
     printf("\nListe des mots compatibles :\n\n");
     printf("%s\n\n",tampon);    
  for(k=1;k<taille;k++){
   printf("%d. %s\n",k,complist[k]);
   printf("\n");
  }
     system("PAUSE");    
}
 

void main () {
 int a;
 int b;
 char saisie [10];
 int encore;

// Saisie du nb de lignes
 do{
  bye=0;
  encore=0;
  printf ("Veuillez indiquer le format de la grille <nb lignes>");
  scanf ("%s", saisie);
  if (! sscanf(saisie,"%d",&a)){
   encore = 1;
   printf("Vous devez saisir un chiffre.\n");
  }
  else {
   if ( a<0 || a>100 ){
    printf("Le nombre doit etre compris entre 1 et 100.\n");
    encore = 1;
   }
  }
 } while (encore == 1);
// Saisie du nb de colonnes
 do{
  encore=0;
  printf ("Veuillez indiquer le format de la grille <nb colonnes>");
  scanf ("%s", saisie);
  if (! sscanf(saisie,"%d",&b)){
   encore = 1;
   printf("Vous devez saisir un chiffre.\n");
  }
  else {
   if ( b<0 || b>100 ){
    printf("Le nombre doit etre compris entre 1 et 100.\n");
    encore = 1;
   }
  }
 } while (encore == 1);
//mise en place de la grille
 printf ("test\n");
 grille grid (a,b);
//MENU
 //system("cls");
 bye=0;
 do {
  system("cls");
  grid.afficher();
  grid.actions();
  system("cls");
  grid.afficher();
 } while ( bye != 1);
}

Bon, on a plus ou moins résolu le probleme.

Le binome avec lequel je travail, a trouvé judicieux de définir une taille de tableau de 100000000 (il a prétendu s'endormir sur le clavier lors de la saisie).

apparement, cela saturait la mémoire...

C'est pas jolie jolie ce mélange de C et de C++.
Je manque de temps la, mais une chose est sur:
this -> aide (3); // <= CA, CA MARCHE NORMALEMENT

++

J'ai essayé ce code et sous VC6 ça compile

10000000 pour une taille de tableau c'est effectivement enorme, et donc cela fait exploser la pile

Dans ta classe, tu créés un tableau de 100x100 alors que lorsque tu créés ton objet, si tu donnes juste une grille de 50x50, tu perds 75% de mémoire. faut utiliser de l'allocation dynamique pour ton truc.

ymca2003, je comprends pas pk tu dis que ca fait exploser la pile. Il a suffisamment surement assez de ram pour stocker ces tableaux.
ET pour finir, je vois pas l'utilité de ton tableau [50][10000000].

A mon avis, ta fonction est corectement appelée. Mais, mais mais....tu confonds le type char avec int.

si char a= '1'
alors
{
   int b= (int) a;
  (b == 1) est faut
}
donc 
   utilise sprintf(key, "%d", &i); et surtout un débogueur.

luthor -> allouer d'un coup autant de mémoire sur la pile est trop (variable local à une fonction -> allouée sur la pile):
char complist[50][M]; avec M = 10000000 -> environ 50Mo d'allouer sur la pile (et par défaut windows en alloue 1Mo).
[ Lien ]

il est possible de stocker un tel tableau mais il faut utiliser l'allocation dynamique