Erreur Memoire ne peut pas être read

Bonjour  à tous,
J'ai une erreur du genre "L'instruction à l'adresse @ emploie l'adresse memoire @. la memoire ne peut pas être "Read" ouu "write" suivant que je tente d'écrire ou de lire de la mémoire. Merci de m'aider car je perds du temps...
Peace Asis1

En général cela provient d'un dépassement lors de l'accès à un tableau où l'accès à un pointeur non valide (déjà libéré, non initialisé)

Pour s'en sortir
 => vérifier avant d'accèder à un élément du tableau s'il est valide (à l'aide de macro ASSERT par exemple).
=> mettre à NULL un pointeur qui vient d'être libéré ou déclaré (permettra un test à NULL pour vérifier la validité).

Merci.
Au fait j'utilise des pointeurs.....mais j'ai essayé de faire ce que tu m'as dit mais rien n'y fait, voilà une portion de mon programme:
char* id="ab", *nom="mon nom", *comment="no comment";
int num=12;
critere* crit=NULL;
crit->createcritere(id,nom,comment,num);//c'est làou l'erreur survient lors de l'execution
merci de me faire part de votre aide

Peace Asis1

On ne manipule pas les chaînes de caractères comme cela :
on déclare un tableau de char ou on alloue avec malloc et on recopie dedans avec strcpy ou bien ou déclare et on initialise en même temps :

1)char id[3];
strcpy(id, "ab");

2) char* id = malloc(3);
strcpy(id, "ab");

3) char id[3] = "ab";

on peut néanmoins faire
char* id = "ab";
mais attention, la chaîne de caractère sera readonly, tu ne pourras pas la modifier avec
strcpy(id, "12");

critere* crit=NULL;
crit->createcritere(id,nom,comment,num);
=> c'est normal que ça plante car tu accèdes à une fonction d'un pointeur NULL (où alors il y ades lignes en plus entre ces 2 là), crit doit être initialiser à autre chose que NULL (avec un objet existant ou avec malloc/new) avant d'être utilisé

Au fait la déclaration je lui remis comme cela mais ça plante tjours. Désolé de t'embeter avec ça mais je suis  nul en c++.
critere *crit;
 String idet="M1",name="Moyen",comment="No comment";
 float va=10.0;
 int nb=5;
 crit=new criterion(10);
 crit->createcriterion(idet,name,comment,va,nb);

Peace Asis1

Pourrais-tu mettre le code de la fonction createcriterion (avec son prototype) ?

dans la classe critere.h j'ai juste mis ça:
void createcriterion(char*,char*,char*,float,int);
et dans le .cpp j'ai mis ça:
static critere* crit;
static tabcritere *tabcrit;
void critere::createcriterion(char* ident, char* name, char* comment, float val, int nb)
{
  
 id->setident(ident);
 id->setname(name);
 id->setcomment(comment);
 crit->setidentifier(id);
 valmat->setvaleur(val);
 crit->setvaleur(valmat);
 crit->nb=nb;
 tabcrit->setcriterion(crit);
};

Peace Asis1

ces variables là sont-elles initialisées quelque part ?
static critere* crit;
static tabcritere *tabcrit;

les pointeurs id et valmat, ils sortent d'où ? Je me demande si tu as bien compris la notion d'objet en c++ (variables et fonctions membres...) car dans la classe critere, tu utilise une fonction membre pour initiliser un objet critere static.

je pense qu'il faudrait l'ensemble du prog( si c'est pas trop long) ou au moins l'ensemble de la classe critere et les varibles globales utilisées.

Ok voici la classe critere
class critere{
 int nb;
 identifier* id;
 valeurMatrice* val;
//   friend ostream & operator << (criterion &crit);
public:
 criterion(int numb){nb=numb;};
 ~criterion(){delete []id; delete []val;};
 void setidentifier(identifier *ident)
  {id = ident;}
 void setvaleur(valeurMatrice *vale)
  {val = vale;}
 valeurMatrice *getvaleur(criterion*)
  {return val;}
 const int& getnb(){return nb;}
 void createcriterion(char*,char*,char*,float,int); 
};
 
et voici la classe valeurMatrice
class valeurMatrice
{
 float valeur;

public:
 valeurMatrice(){};
 ~valeurMatrice(){valeur=0.0;}
 void setvaleurmatrice(float id)
  {valeur = id;}
 const float getvaleurmatrice(const int i)const
  {return valeur;}
};

dans le.cpp
static critere* crit;
static tabcritere *tabcrit;
static valeurMatrice* valmat;
static identifier *id;
void critere::createcriterion(char* ident, char* name, char* comment, float val, int nb)
{
 crit=new criterion(); 
 id->setident(ident);
 id->setname(name);
 id->setcomment(comment);
 crit->setidentifier(id);
 valmat->setvaleurmatrice(val);
 crit->setvaleurMatrice(valmat);
 crit->nb=nb;
 tabcrit->setcriterion(crit);
};

la classe identifier:
class identifier{
 String ident;
 String name;
 String comment;
public:
 identifier(){ident="";name="";comment="";}
 ~identifier(){delete [] ident; delete [] name; delete [] comment;}
 void setident(const char *id)
  {ident = id;}
 void setname(const char *nom)
  {name = nom;}
 void setcomment(const char *com)
  {comment = com;}
 const String& getident()const
  {return ident;}
 const String& getname()const
  {return name;}
 const String& getcomment()const
  {return comment;}
};

j'espère que j'ai fourni tout le necessaire. En tout cas merci encore mille fois de ton aide
Peace Asis1

les variables static sont à virer.

la fonction createcriterion est une fct membre de la classe critere donc appelée avec un objet critere, inutile d'en crée un dedans, opn a accès implicitement à l'appelant par le pointeur this.

void critere::createcriterion(char* ident, char* name, char* comment, float val, int localnb)
{
id= new identifier();
 id->setident(ident);
 id->setname(name);
 id->setcomment(comment);
valmat = new valeurMatrice();
 valmat->setvaleurmatrice(val);
 crit->nb=localnb;
 tabcrit->setcriterion(crit);
};

dans la classe Identifier :
- soit tu utilise des String qui gère automatiquement la mémoire auquel cas tu ne doit pas faire delete[] dessus dans le destructeur (doit pas compilé d'ailleurs)
- doit tu utilise des char* qu'il faut allouer lors de la recopie et libérer dans le destructeur :