Bonjour, j'ai créé une classe qui a beaucoup de methodes. Certaines d'entre elle ne sont pas reconnues.
La compilation de la classe est ok, par contre quand je veux utiliser la méthode en question, dev-cpp me dit que la classe utilisée ne comporte pas la méthode utilisée.
La plupart des autres méthodes autour marchent bien. Je me demande donc s'il existe une taille limite dans l'écriture d'une classe.
Merci d'avance.

T'as du faire une erreur. Post une partie de ton code.

Alors dans la déclaration en public (.h) :
float getDx(void) const;
et pour l'implémentation (.cpp):
float cubic::getDx(void) const
{
      return Dx;
}
avec Dx déclaré en privé (.h) : float Dx;

J'ai pas mal d'autre méthodes qui sont faites de la meme façon et qui ne posent pas de probleme .

Bas ca, c'est correct, mais essai de poster tout le fichier .h. Et le code qui pose pb.

Un conseil: mets plutot "const float getDx(void) const;"

Voila le .h , ce qui pose probleme est quand j'utilise cube.getDx() dans le main , cube etant une instance de cubic.
Dev-cpp me renvoit : 'class cubic' has no member named 'getDx'

#include<iostream>
using namespace std;
#ifndef _cubich_
#define _cubich_

class cubic{
     
private:
 int Nx;  
 int Ny;
 int Nz;
 int Nxm;  
 int Nym;
 int Nzm;
 float echelle;
 float Dx; 
 float Dy;
 float Dz;
 int Nvar;
 float rho;
 float M;  
 float Ialpha; 
 float Ibeta;
 float Iphi;
 float Fgx; 
 float Fgy;
 float Fgz;
 float xc; 
 float yc;
 float zc;
 /*float f1p1x;float f1p2x;float f1p3x;float f1p4x; //vertex du cube, x
 float f2p1x;float f2p2x;float f2p3x;float f2p4x;
 float f3p1x;float f3p2x;float f3p3x;float f3p4x;
 float f4p1x;float f4p2x;float f4p3x;float f4p4x;
 float f5p1x;float f5p2x;float f5p3x;float f5p4x;
 float f6p1x;float f6p2x;float f6p3x;float f6p4x;
 
 float f1p1y;float f1p2y;float f1p3y;float f1p4y; //vertex du cube, y
 float f2p1y;float f2p2y;float f2p3y;float f2p4y;
 float f3p1y;float f3p2y;float f3p3y;float f3p4y;
 float f4p1y;float f4p2y;float f4p3y;float f4p4y;
 float f5p1y;float f5p2y;float f5p3y;float f5p4y;
 float f6p1y;float f6p2y;float f6p3y;float f6p4y;
 
 float f1p1z;float f1p2z;float f1p3z;float f1p4z; //vertex du cube, z
 float f2p1z;float f2p2z;float f2p3z;float f2p4z;
 float f3p1z;float f3p2z;float f3p3z;float f3p4z;
 float f4p1z;float f4p2z;float f4p3z;float f4p4z;
 float f5p1z;float f5p2z;float f5p3z;float f5p4z;
 float f6p1z;float f6p2z;float f6p3z;float f6p4z;*/
 float vxc; 
 float vyc;
 float vzc;
    float alpha; 
    float beta;
    float phi;
    float valpha; 
    float vbeta;
    float vphi; 
    float*** face1;
    float*** face2;
    float*** face3;
    float*** face4;
    float*** face5;
    float*** face6;
   
   
   
public:
       cubic::cubic();
       cubic::~cubic();
      
       cubic& saisir(void);
      
       void setface1(int i,int k,int m,float val);
       void setface2(int i,int j,int m,float val);
       void setface3(int j,int k,int m,float val);
       void setface4(int i,int k,int m,float val);
       void setface5(int i,int j,int m,float val);
       void setface6(int j,int k,int m,float val);
      
       void maj(float dt);
      
       void setxc(float val);
       void setyc(float val);
       void setzc(float val);
      
       void setFg(float F1,float F2,float F3);
             
       float*** getface1(void) const;
       float*** getface2(void) const;
       float*** getface3(void) const;
       float*** getface4(void) const;
       float*** getface5(void) const;
       float*** getface6(void) const;
      
      
       float getxc(void) const;
       float getyc(void) const;
       float getzc(void) const;
       float getvxc(void) const;
       float getvyc(void) const;
       float getvzc(void) const;
       float getalpha(void) const;
       float getbeta(void) const;
       float getphi(void) const;
      
       float getDx(void) const;
       float getDy(void) const;
       float getDz(void) const;
      
      
       int getNx(void) const;
       int getNy(void) const;
       int getNz(void) const;

      
       float getM(void) const;
      
       /*float getf1p1x(void) const;
       float getf1p1y(void) const;
       float getf1p1z(void) const;
       float getf1p2x(void) const;
       float getf1p2y(void) const;
       float getf1p2z(void) const;
       float getf1p3x(void) const;
       float getf1p3y(void) const;
       float getf1p3z(void) const;
       float getf1p4x(void) const;
       float getf1p4y(void) const;
       float getf1p4z(void) const;
      
       float getf2p1x(void) const;
       float getf2p1y(void) const;
       float getf2p1z(void) const;
       float getf2p2x(void) const;
       float getf2p2y(void) const;
       float getf2p2z(void) const;
       float getf2p3x(void) const;
       float getf2p3y(void) const;
       float getf2p3z(void) const;
       float getf2p4x(void) const;
       float getf2p4y(void) const;
       float getf2p4z(void) const;
      
       float getf3p1x(void) const;
       float getf3p1y(void) const;
       float getf3p1z(void) const;
       float getf3p2x(void) const;
       float getf3p2y(void) const;
       float getf3p2z(void) const;
       float getf3p3x(void) const;
       float getf3p3y(void) const;
       float getf3p3z(void) const;
       float getf3p4x(void) const;
       float getf3p4y(void) const;
       float getf3p4z(void) const;
      
       float getf4p1x(void) const;
       float getf4p1y(void) const;
       float getf4p1z(void) const;
       float getf4p2x(void) const;
       float getf4p2y(void) const;
       float getf4p2z(void) const;
       float getf4p3x(void) const;
       float getf4p3y(void) const;
       float getf4p3z(void) const;
       float getf4p4x(void) const;
       float getf4p4y(void) const;
       float getf4p4z(void) const;
      
       float getf5p1x(void) const;
       float getf5p1y(void) const;
       float getf5p1z(void) const;
       float getf5p2x(void) const;
       float getf5p2y(void) const;
       float getf5p2z(void) const;
       float getf5p3x(void) const;
       float getf5p3y(void) const;
       float getf5p3z(void) const;
       float getf5p4x(void) const;
       float getf5p4y(void) const;
       float getf5p4z(void) const;
      
       float getf6p1x(void) const;
       float getf6p1y(void) const;
       float getf6p1z(void) const;
       float getf6p2x(void) const;
       float getf6p2y(void) const;
       float getf6p2z(void) const;
       float getf6p3x(void) const;
       float getf6p3y(void) const;
       float getf6p3z(void) const;
       float getf6p4x(void) const;
       float getf6p4y(void) const;
       float getf6p4z(void) const;*/
      
      
      
       /*void afficher(void) const;
       void afficher1(int i,int j,int k,int m,int it) const;
       int getNx(void) const;
       int getNy(void) const;
       int getNz(void) const;*/
      
      
};

#endif

Et une classe Vertex ne te tente pas  (pour les x, y, z ) ?

ah oui,
sinon

jamais de  : using namespace std;
dans tes .h

et les includes guard ( #ifndef, #define ), devraient être les premières lignes de ton .h


et
       cubic::cubic();
       cubic::~cubic();

est inhabituel non,

       cubic();
       ~cubic();
suffit.

Le void pour indiquer pas d'argument, c'est pour le C surtout en C++ on s'en passe allègrement.

luhtor > const float getX() const;..
le premier const n'est pas un peu de "trop" (is on peut dire) ?
(Il ne sert pas à grand chose)

Si peut etre a terme, mais je n'en suis pas encore la. C'est juste un premier jet pour l'instant, j'arrive pas encore a voir a l'avance ce qui est le plus pratique.

d'accord merci je vais essayer ça.

Je ne suis pas sûr que de ce préoccuper aussi tôt (ça compile pas) de la performance soit une bonne idée.
Bonne chance en tout cas.