Discussion :

[Deezio]

Bonujour, j'essaie de m'initier au c++, et je me retrouve face a un probleme : je ne comprends pas comment faire pour créé un tableau d'objet. Pour m'entrainer au c++ j'ai recuperé les sujets de la piscine de l'ecole 42 (j'en suis d01 ex03 : https://github.com/jpirsch/piscines/.../d01.en(1).pdf).

J'essaie donc de faire un objet, qui peux créé un tableau d'objet.
Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef ZOMBIEHORDE_HPP
# define ZOMBIEHORDE_HPP
 
#include <iostream>
#include <stdlib.h>
#include "Zombie.hpp"
#include "ZombieEvent.hpp"
 
class ZombieHorde {
 
private:
	Zombie	*horde[];
 
public:
	ZombieHorde(int nbrZombie);
	void	announce(void);
};
 
# endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include "ZombieHorde.hpp"
 
ZombieHorde::ZombieHorde(int nbrZombie) {
	srand(time(0));
	ZombieEvent	zombie_event("Infecté");
	std::string	tab[] = {"Daniel", "Moncef", "Louis", "John", "Phillipe"};
	int			i = 0;
 
	while (i < nbrZombie) {
		this->horde[i] = zombie_event.newZombie(tab[rand() % 5]);
		i++;
	}
	this->horde[i] = NULL;
}
 
void	ZombieHorde::announce(void) {
	int	i = 0;
 
	while (this->horde[i] != NULL) {
		this->horde[i]->announce();
		i++;
	}
}
 
int	main(void) {
	ZombieHorde	horde(5);
	horde.announce();
}

Mais mon programme me retourne soit un bus error soit une segmentation fault :

<Louis (Infecté)> Braiiiiiiinnnssss...
<Daniel (Infecté)> Braiiiiiiinnnssss...
<Phillipe (Infecté)> Braiiiiiiinnnssss...
<Phillipe (Infecté)> Braiiiiiiinnnssss...
<Louis (Infecté)> Braiiiiiiinnnssss...
[1] 89101 bus error ./zombie

J'avoue etre un peu perdu, je ne vois pas ce qui cloche dans ma classe...
J'ai lu sur le net que la fonction vector() pourrait m'aider, mais j'aimerais joué le jeu et faire sans (cette fonction n'est pas autorisé pour les etudiants qui font cette piscine apparemment)
Sachant que je n'ai pas encore fait le destructeur, ca doit venir de lui, parce qu'on dirait que c'est au moment ou le programme se ferme, quoi que je mette dans le programme, ca va s'executer, et mettre le segfault ensuite.
Mais meme en sachant ca je ne vois pas pourquoi il pourrait segfault

[Bousk]

Ton code n'a aucune chance de fonctionne.
Zombie *horde[]; est un tableau de pointeur de Zombie de taille inconnu. Tu ne pourras pas insérer de données là-dedans.
Un tableau c'est std::vector ou std::array, selon que sa taille est connue à la compilation ou non.

Edit: on dirait qu'il y a une règle plutôt stupide qui interdit d'utiliser la stl avant l'exo 8... Donc ce qu'ils attendent c'est Zombie* horde ou Zombie** horde si tu veux des pointeurs, et l'utilisation de new[]/delete[].

[Deezio]

Rassure-moi, c'est comme en C, ils n'ont pas changer ça : Zombie **horde revient exactement au meme que Zombie *horde[] ?

EDIT: Merci ! J'ai trouvé. (avec ca comme code pour ceux qui seraient interessés :)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include "ZombieHorde.hpp"
 
ZombieHorde::ZombieHorde(int nbrZombie) : nbrZombie(nbrZombie) {
	srand(time(0));
	std::string	names[] = {"Daniel", "Moncef", "Louis", "John", "Phillipe"};
	int			i = 0;
 
	this->horde = new Zombie*[nbrZombie];
	while (i < this->nbrZombie) {
		this->horde[i] = new Zombie(names[rand() % 5], "Infecté");
		i++;
	}
}
 
void	ZombieHorde::announce(void) {
	int	i = 0;
 
	while (i < this->nbrZombie) {
		this->horde[i]->announce();
		i++;
	}
}
 
int	main(void) {
	ZombieHorde	horde(22);
	horde.announce();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef ZOMBIEHORDE_HPP
# define ZOMBIEHORDE_HPP
 
#include <iostream>
#include <stdlib.h>
#include "Zombie.hpp"
#include "ZombieEvent.hpp"
 
class ZombieHorde {
 
private:
	int		nbrZombie;
	Zombie	**horde;
 
public:
	ZombieHorde(int nbrZombie);
	void	announce(void);
};
 
# endif

[dalfab]

Rassure-moi, c'est comme en C, ils n'ont pas changer ça : Zombie **horde revient exactement au meme que Zombie *horde[] ?

Je te rassure c'est comme en C, mais en C++ on préfère éviter les tableaux dits "bruts" car même les développeurs C en oublient les subtilités.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
extern char tab1[];              // tableau de taille non définie
extern char tab1[10];            // idem tableau de taille non définie!
char tab2[] = {1,2,3,4,5}       // tableau de taille connue (ici 5), en C++ on préfère ôter le '='.
void fct( char tab3[] );         // pointeur sur un entier
void fct( char* tab3 );          // idem, pointeur sur un entier
void fct( char tab3[12] );       // idem, pointeur sur un entier!
void fct( char tab4[static 3] ); // Ça c'est du C, pas du C++
void fct( char (&tab5)[5] );     // Ça c'est du C++, pas du C
template<size_t N> void fct(char (&tab6)[N]); // Ça aussi c'est du C++

sizeof(tab1)==sizeof(tab3)==sizeof(tab4)==sizeof(void*), sizeof tab2==sizeof tab5==4, sizeof(tab6)==taille du tableau passé.

EDIT: Merci ! J'ai trouvé. (avec ca comme code pour ceux qui seraient interessés

Attention quand même, ce code est un très mauvais exemple à ne pas reproduire. C'est peut-être dû aux recommandations de l'école 42; mais il y a de graves lacunes (p.e l'objet ZombieHorde ne doit pas être instancié plusieurs fois, ou copié sans risquer de sérieuses anomalies...)

[Deezio]

Le probleme avec ma class vient surement du Zombie **horde, qui ne pourra pas être copié c'est ca ? Alors que faudrait il utilisé ici ? Des std::vector ou std::array c'est bien ca ?
Par contre je ne vois pas ce qui bloquerait le fait de faire plusieurs instances

[dalfab]

* En fait la copie va "plus" que fonctionner, avec une copie ultra-rapide mais qui produit des objets "siamois" impossible à libérer correctement.
* En effet utiliser des collections permettra de gérer correctement les allocations, les copies et les éventuelles exceptions. Sinon on peut le faire "à la main", mais il y a de nombreuses choses à écrire avec de nombreux risques d'erreur (des constructeurs et opérateurs de copie, un destructeur et le constructeur à corriger.)
* Ici, il n'a aucune libération de mémoire. Si on multiplie les instances, on multiplie la mémoire perdue et l'application pourra tomber par manque de mémoire.