Bonjour,

J'ai un problème avec ma fonction qui doit me retourner un tableau avec seulement la taille des filles. Quand je souhaite afficher le tableau celà me donne des chiffres énormes ce qui veut dire que le tableau n'est pas initialisé ? Ou celà me donne "Error in `./main': malloc(): memory corruption: 0x0000000001ab67e0". Je ne sais pas commet régler ce soucis merci à vous et désolé du dérangement.

Dans le programme P=extraire...(T,m,SEXE), P est un tableau rempli de 0 (pour fille) et 1 (pour garçon)

int *extraireTailleFille(personne *T,int m,int choix)
{
 int j;
 int *P;
 P=extraireSexe(T,m,SEXE);
 int *critere=new int[m];
 switch (choix){
 case 1:
  for(int i=0;i<m;i++)
  {
    if(P[i]==0)
    {
      critere[j]=T[i].taille;
      j++;
    }
  }
 }
 int *SP= new int[j];
 for(int i=0;i<j;i++)
  {
    SP[i]=critere[i];
  }
    delete [] critere;
    return(SP);
}

Lu'!

Pour créer une tableau de taille dynamique en C++ : std::vector. On n'utilise pas new et delete en C++ à moins d'avoir une très bonne raison de le faire. Tu ferais également bien mieux de passer personne par référence et pas à travers un pointeur.

Cela résoudrait tous les problèmes en cours.

Sinon ici, sans le code appelant, c'est compliqué de faire du debug.

Le problème c'est que je n'ai pas le droit d'utiliser les vecteurs, le code appelant c'est le main ? Si c'est ça le voilà 

int main()
{
 int *Z,N,A,*L,B;
 int *P,*M;
 personne *T=lire_fichier(N);
 P=extraireTailleFille(T,N,TAILLE);
 for(int i=0;i<N;i++)
 {
 cout<<P[i]<<" ";
 }
}

GG pour les pointeurs non-initialisés, etc...

Le message d'erreur, c'est juste de runtime-C qui a détecté que vous aviez déjà salopé le mémoire.

Regardez avec le débogueur le contenu de mémoire qui est déjà salopé et devinez quel partie du code la salope.

Moi, je suis assez dubitatif avec l'usage de la variable locale j pas initialisée et utilisée partout et n'importe comment.

Votre prof. n'est qu'un dinosaure sadique.

C'est trop dur de mettre un vrais nom de variable?

Je n'ai pas chercher a creuser, car c'est pas assez lisible.

Salut,

Encore une fois, nous sommes face à un problème induit par un prof qui essaye d'adapter "ce qu'il croit connaitre" du C au C++ et qui se  plante royalement.

Car, soyons bien clair : en dehors de std::cout, le code que ton prof t'oblige à faire, c'est du C.  J'aurais presque envie que tu lui demande (avec tout le respect qui lui est du, bien sur) de passer sur le forum qu'on puisse lui expliquer (enfin !!!) que C et C++ ne sont plus du tous les mêmes langage depuis plus de vingt ans!

Ceci étant dit, il y a quand même quelques corrections qui sont à ta portée :

1- choisi des noms explicites:

Nous ne sommes plus à l'époque où le moindre octet utilisé coûtait la moitié d'un bras, et  où il fallait donc essayer de rendre le code le plus compact possible pour ne pas trop risque de remplir les disques durs et autres bandes magnétiques!

Dis toi bien que, de toutes manières, les noms (de manière générale) sont totalement supprimés du code binaire qui sera créé, et que l'on s'en fout donc si, dans le code que l'on écrit, les noms que nous utilisons nécessitent plus d'un caractère!

Plus les noms que tu choisira seront clairs et précis, plus il sera facile pour celui qui "vient après toi" de relire le code et de s'assurer qu'il est correct.

Les noms Z, N,  A, L, B, P, M, T, ca ne me dit absolument rien.

Je sais que la plupart de ces données sont des entiers (enfin, des pointeurs sur des entiers), que T est un pointeur sur une personne, mais c'est la seule information dont je dispose.  Je n'ai aucune idée  de l'usage que tu prévois de faire de tes données.

Je n'ai donc aucun moyen de n'avoir ne serait-ce que la plus petite chance de comprendre ce que tu fais.  Car je ne peux pas vraiment compter sur les deux malheureuses fonctions auxquelles tu fais appel pour me faire une idée de ce dont tu as besoin

2- Une ligne == une instruction

Cela signifie : tu as dix variables à déclarer ? très bien: utilises une ligne pour chaque déclaration.  Ne serait-ce que pour éviter que je me pose la question à tout moment de savoir si N, A ou B ne sont pas des pointeurs!

3- Utilise des conventions de nommage strictes et cohérentes:

Tu as une fonction lire_fichier et une autre appelée extraireTailleFille.

D'ici à ce que tu commences à faire une soupe entre les fonctions qui ont besoin d'un underscore et celles qui ont besoin de majuscules, il n'y a qu'un pas.

Facilites toi la vie : choisi une convention de nommage, et tiens toi y pour l'ensemble de ton projet. Si tu veux utiliser une autre convention de nommage, change de projet

4-Déclares tes données au moment où elles deviennent utiles.  Ni avant, ni après:

Les déclarer avant te mets dans une situation dans laquelle tu risques de les utiliser pour un usage pour lequel elles ne sont pas prévue, les déclarer après, c'est le faire trop tard.

Attend -- à tout le moins --  de pouvoir leur donner une valeur cohérente! Cela résoudra la plupart de tes problèmes.

Un simple exemple : quelle est la valeur de N lorsque tu fais appel à lire_fichier ??? hé bien, je vais te le dire, moi:

• Dans le meilleur des cas, N vaut ... 0.
• Dans le pire des cas, N vaut ... les crasses laissées par une utilisation antérieure de la mémoire.  Autrement dit, à peu près n'importe quoi.

5- Un ordinateur est un brave petit soldat: il ne prendra aucune décision que tu n'aie pas laissée à sa charge.  Mais il ne posera pas la moindre question en cas de doute: si tu lui dit de sauter, il va sauter, aussi loin et aussi haut qu'il lui sera possible de le faire.

Si tu veux qu'il travaille avec une valeur particulière, tu dois lui dire d'utiliser cette valeur de manière explicite!

J'ai rarement vu autant de pointeurs bruts dans un code C++.

Au passage, ne mettez pas de parenthèses au niveau du return, ça peut avoir des conséquences.

https://stackoverflow.com/a/25615981/840599

-
Edité par markand 16 janvier 2019 à 8:56:54

Au pire, vu que tu n'as pas droit aux conteneurs de la STL (quelle hérésie !), fait toi une classe qui représente un tableau dynamique.

Naïf et fait à l'arrache:

class dynamicArray
{
public:
	dynamicArray();
	dynamicArray(dynamicArray const&);
	~dynamicArray();
	dynamicArray operator=(dynamicArray const&);
	int& operator[](size_t) const;
	size_t size() const;
	void push_back(int);
private:
	int* mArray;
	size_t mSize;
	void deepCopy(int*, int*);
};

dynamicArray::dynamicArray():	mArray{new int[0]},
								mSize{0}
{
}

dynamicArray::dynamicArray(dynamicArray const& in):	mArray{new int[in.mSize]},
													mSize{in.mSize}
{
	deepCopy(mArray, in.mArray);
}

dynamicArray::~dynamicArray()
{
	delete[] mArray;
}
dynamicArray dynamicArray::operator=(dynamicArray const& right)
{
	mSize = right.mSize;
	delete[] mArray;
	mArray = new int[right.size()];
	deepCopy(mArray, right.mArray);
	return *this;
}

int& dynamicArray::operator[](size_t index) const
{
	return mArray[index];
}

size_t dynamicArray::dynamicArray::size() const
{
	return mSize;
}
void dynamicArray::push_back(int valeur)
{
	int* temp = new int[mSize+1];
	deepCopy(temp, mArray);
	temp[mSize] = valeur;
	++mSize;
	delete[] mArray;
	mArray = temp;
}

void dynamicArray::deepCopy(int* left, int* right)
{
	for(size_t i=0; i<mSize; ++i)
		left[i] = right[i];
}

(A toi d'adapter pour tes besoins).

dynamicArray dynamicArray::operator=(dynamicArray const& right)
{
    mSize = right.mSize;
    delete[] mArray;
    mArray = new int[right.size()];
    deepCopy(mArray, right.mArray);
    return *this;
}

Surtout pas malheureux, si tu échoues ton allocation, ton objet est maintenant invalidé. Idiom copy and swap ici.

Ouais, mais le prof anti-STL ne veux probablement pas en entendre parler.

On peux tous de même s'en sortir, il faut également changer deepCopy, et les fonctions qui y font appel:

// #include <cassert>

class dynamicArray
{
public:
	dynamicArray();
	dynamicArray(dynamicArray const&);
	~dynamicArray();
	dynamicArray operator=(dynamicArray const&);
	int& operator[](size_t) const;
	size_t size() const;
	void push_back(int);
private:
	int* mArray;
	size_t mSize;
	void deepCopy(int*, int*, size_t);
};

dynamicArray::dynamicArray():	mArray{new int[0]},
								mSize{0}
{
}

dynamicArray::dynamicArray(dynamicArray const& in):	mArray{new int[in.mSize]},
													mSize{in.mSize}
{
	deepCopy(mArray, in.mArray, in.mSize);
}

dynamicArray::~dynamicArray()
{
	delete[] mArray;
}

dynamicArray dynamicArray::operator=(dynamicArray const& right)
{
	// assert(mSize != right.mSize);
	int* temp = new int[right.mSize];
	deepCopy(temp, right.mArray, right.mSize);
	delete[] mArray;
	mArray = temp;
	mSize = right.mSize;
	return *this;
}

int& dynamicArray::operator[](size_t index) const
{
	return mArray[index];
}

size_t dynamicArray::dynamicArray::size() const
{
	return mSize;
}
void dynamicArray::push_back(int valeur)
{
	int* temp = new int[mSize+1];
	deepCopy(temp, mArray, mSize);
	temp[mSize] = valeur;
	++mSize;
	delete[] mArray;
	mArray = temp;
}

void dynamicArray::deepCopy(int* left, int* right, size_t size)
{
	for(size_t i=0; i<size; ++i)
		left[i] = right[i];
}

Une assertion est également utile, mais du fait des contraintes préhistoriques, c'est en commentaire.

Re bonjour, j'ai tenu compte de vos réponses et j'ai essayé de faire de mon mieux vous m'excuserez je l'espère mon tableau m'affiche bien la taille de la sous population que je veux mais à la fin de celle-ci j'ai soit d'énorme valeur soit que des 0 pourtant j'ai essayé de faire un tableau de bonne taille à la fin de la fonction voici mon code :

int *extraire(personne *T,int tailleTableau,int choix,int numero) //Choix= soit taille,sexe,,age,poids. numero c'est juste pour me repérer// 
{
  if(choix==TAILLE and numero==2){
  int j=0;
  int *tableauDeSexe;
  tableauDeSexe=extraireSexe(T,tailleTableau,SEXE); //Tableau contenant des 0 et des 1 (0 pour fille)
  int *critere=new int[tailleTableau];
  switch (choix){
  case 1:
  for(int i=0;i<tailleTableau;i++)
  {
    if(tableauDeSexe[i]==0)
    {
      critere[j]=T[i].taille;
      j++;
    }
  }
 }
 int *tableauDeBonneTaille= new int[j];
 for(int i=0;i<j;i++)
 {
 tableauDeBonneTaille[i]=critere[i];
 }
 delete [] critere;
 return(tableauDeBonneTaille);
  }

}

-
Edité par Anonyme 16 janvier 2019 à 13:44:47

Comme je te l'ai indiqué, fait toi des classes qui représentent tes tableaux dynamiques.
Ca t'éviteras de trimballer des pointeurs nu et de faire des allocation dynamiques manuelles dans tous les sens (d'ailleur tu as des fuites).
Ca t'éviteras aussi de calculer et trimballer la taille des tableaux.

A mon avis, la fonction extraireSexe est foireuse, et je suspecte que les fonctions que tu ne nous à pas montré le sont aussi.

Alors on à pas peur de se mettre à poil et on montre tout.
(un descriptif du fichier d'entrée peut également être intéressant).

PS: Ton indentation est à revoir, et il manque un break a la fin de ton case.

Le problème c'est que dans les consignes c'est indiqué que je n'ai le droit de travailler qu'avec les choses déjà vu les classes n'ont font pas parti,pour le fichier d'entré il ce présente avec des chiffres tel que(0 180 18 33) sur plusieurs ligne 1er chiffre pour le sexe,deuxième pour la taille,age,poids. Pour les autres fonction j'ai celle donné pas mon professeur les voici que je suis tenu d'utiliser pour le extraire Sexe je l'ai essayé et il à l'air de bien marché mais le voici aussi :

struct personne
{
 int sexe;
 int taille;
 int age;
 int poids;
};

personne *lire_fichier(int & N)
{
 ifstream fichier("population.txt", ios::in);
 string contenu;
 personne *aux=new personne[1000000];
 int i=0;
 while(fichier)
 { 
 getline(fichier, contenu);
 const char *s=contenu.c_str();
 sscanf(s,"%d %d %d %d",&(aux[i].sexe),&(aux[i].taille),&(aux[i].age),&(aux[i].poids));
 i++;
 }
 N=i; 
 personne *T=new personne[N];
 for (int j=0;j<N;j++) T[j]=aux[j];
 delete [] aux;
 return(T);
}

enum Attribut
{
 SEXE,
 TAILLE,
 POIDS,
 AGE
};

int *extraireSexe(personne *T,int m,int choix)
{
 int *critere=new int[m];
 switch (choix){
 case 0:
 for(int i=0;i<m;i++)
    {
      critere[i]=T[i].sexe;
    }
 }
 return critere;
}

-
Edité par Anonyme 16 janvier 2019 à 15:00:12

Aux grands maux, les grands remèdes . Si tu fais du C++, tu as le droit d'utiliser tout ce que C++ peut t'offrir. Or vector fait partie de C++, cf la norme. 

Ce lien contient les drafts finaux de toutes les normes de C++(les publications finales sont payantes, mais elles sont à 99.9999% identiques, de la première qui date de 1998 à la dernière qui date de 2017). Si tu vas voir dans N316, tu verras que vector existe déjà en 2003. En fait, vector faisait déjà partie de la norme C++98, et il faisait aussi partie de la proposition initiale de bibliothèque standard pour C++, qui date du début des années 1990.

20 ans pour se mettre à jour, ce n'est plus du "j'ai pas eu le temps", c'est la preuve que ton prof t'enseigne de la merde et qu'il n'en a rien à foutre... En somme, un branleur incompétent, qui mériterait de se faire virer à grand coups de pompes dans le cul.

-
Edité par int21h 17 janvier 2019 à 4:13:56