Discussion :

[Kalemiro]

Bonsoir,

Je suis entrain de faire un interface en utilisant la SDL, et pour la création et positionnement des icônes j'utilise un vector afin de pouvoir ajouter ou retirer facilement des icônes. C'est l'utilisateur qui choisis les icones en éditant un fichier texte de cette syntaxe:
- La première ligne contient le nombre d’icône, exemple: 2
- Cette ligne contient la commande pour exécuter l'application, exemple: kodi
- Cette ligne contient le nom du fichier image, exemple: Kodi.png
(et ainsi de suite)


J'ai donc aussi une classe icone dont le constructeur est:

Code :

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

Icone::Icone(SDL_Surface* _affichage, int _r, int _g, int _b, int _x, int _y, char* _commande, char* _pathIcone)

commande étant la commande décrit plus haut, et pathIcone est en fait le nom du fichier
cette classe contient une methode dessinIcone()

J'ai initialisé un vector de mon type Icone:

Code :

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

std::vector<Icone> tabIcone;

Je fais une lecture de fichier pour créer les icones:

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
 
	if(fichier)
	{
		int nbApp;
		std::string icone, commande, strNbApp;
		getline(fichier, strNbApp);
		if(!(std::istringstream(strNbApp) >> nbApp) ) nbApp = 0;
		std::cout << "nb app: " << nbApp << std::endl;
 
		for(unsigned int i = 0; i<nbApp; ++i)
		{
			getline(fichier, commande);
			getline(fichier, icone);
			nomIcone = (char*)icone.c_str(); //Conversion des string en char* pour les paramètres du constructeur
			commandeIcone = (char*)commande.c_str();
			tabIcone.emplace_back(affichage, 0, 0, 0, 20*i, (maxH/10)+20, commandeIcone, nomIcone); //Constructeur
		}
	}

Une fois le vector remplis, je l'appelle dans une fonction dessinerInterface() qui permet de dessiner différents élèments de l'interface dont les icones (j'ai allégé la fonction avec seulement les élèments qui nous intéressent):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void dessinerInterface(std::vector<Icone>& tabIcone)
{
	for(unsigned int i=0; i<tabIcone.size(); ++i)
	{
		(tabIcone.at(i)).dessinIcone(); //Appel de la méthode de dessin
 
	}
 
 
}

Pour cette partie j'ai aussi essayé avec un:

Code :

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

1
2
3
4
5
 
for(auto &icone: tabIcone) ///Permet d'appliquer la methode � tout les mobs
        {
                  icone.dessinIcone();
        }

Le problème c'est que les icônes n'apparaissent pas à l'écran mais les autres éléments de l'interface oui, et si je crée les icônes "a la main" en instanciant et en appelant la méthode dessinIcone() en dur les icônes que je veux ça marche. Je ne vois pas d’où viens le problème et j'ai déjç utilisé une technique similaire dans un autre projet sans souci.

[ternel]

le vector contient une copie des icones que tu lui demande de dessiner, il est probable que ces copies ne soient pas correctement configurées.

[Kalemiro]

Je comprend pas trop ta réponse, je ne vois pas ou je fais une copie et comment elles pourraient être mal configurées du coup

[dragonjoker59]

C'est dû au fonctionnement de strd::vector.
Vu qu'il lui arrive de devoir redimensionner son buffer interne lors de l'ajout de nouveaux éléments, il copie les éléments depuis son ancien buffer vers son nouveau buffer.
Le fait qu'un type soit copiable est une des conditions pour pouvoir définir un std::vector de ce type.

[ternel]

Quand tu fais un push_back, le vector crée un nouveau Icone, en utilisant le constructeur par copie avec l'Icone que tu lui donnes.
Si tu fais une transformation à l'Icone que tu as donné au push_back, elle n'est pas répercuté à la copie située dans le vector.

En gros, si tu fais:

Code :

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

1
2
3
4
5
std::vector<Icone> icones;
Icone i(...);
icones.push_back(i);
i.setRotation(15);
for(auto const& icone: icones) icone.draw();

l'icone affichée n'est pas tournée.

La solution pratique serait de passer par la référence retournée par vector::back().

[Médinoc]

C'est dû au fonctionnement de str::vector.
Vu qu'il lui arrive de devoir redimensionner son buffer interne lors de l'ajout de nouveaux éléments, il copie les éléments depuis son ancien buffer vers son nouveau buffer.
Le fait qu'un type soit copiable est une des conditions pour pouvoir définir un std::vector de ce type.

Cela devrait aussi être gérable avec la sémantique de mouvement, non?

[Kalemiro]

J'ai compris pour le push.back(), mais dans mon cas je fais un emplace.back(), le comportement est le même ?

[dragonjoker59]

Cela devrait aussi être gérable avec la sémantique de mouvement, non?

Oui, avec emplace_back, non?

[Bousk]

Peut-être que la réallocation du vector quand sa taille dépasse serait la cause ?
Dans tous les cas c'est une bonne pratique de reserve quand on sait quelle taille on va atteindre
Et les chaînes de caractères en paramètres devraient être des const char* voire des const std::string&

[ternel]

emplace back appelle l'un des constructeurs de value_type avec les arguments que tu lui donnes.
emplace_back(my_icone) appelle donc Icone(my_icone). C'est le constructeur de copie ou de mouvement, selon que my_icone soit déplacable ou non.
Dans tous les cas, le Icone créé n'est pas celui donné en argument, mais une copie.

Donc c'est vector.back() qu'il faut modifier, et pas l'objet utilisé comme argument pour le emplace_back().

Exactement comme quand tu fais ceci:

Code :

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

1
2
3
4
5
6
std::vector<int> ints;
for (int i = 0; i < 10; ++i) {
    ints.emplace_back(i);
}
for(auto i : ints) cout << i << ' ';
cout <<endl;

Ce fragment de code affiche bien les entiers de 0 à 10. i n'est pas l'objet dans le vector.

[Kalemiro]

Je suis désolé mais je ne comprends toujours pas le souci j'a idonc refait ma boucle d'affichage comme leternel le dit:

Code :

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

1
2
3
4
5
 
for(auto icone : tabIcone)
    {
	icone.dessinIcone();
    }

sans succès

[Bousk]

Les objets de ton vecteur sont surement fuckés. Utilise le debugger et inspecte les pour voir réellement ce qu'ils contiennent.
Et encore ça c'est en supposant que oui ton code initiale pour afficher un objet Icone fonctionne, parce qu'on en sait rien ici. On voit juste un constructeur aux paramètres bancals.

[Kalemiro]

Le code pour afficher une icone marche, je l'ai dit dans le premier message mais il est pas très clair j'avoue

[ternel]

On te l'a dit le problème est probablement que l'icone dans le vecteur n'est pas ce qu'il faut.

Montre nous comment tu initialises un de ces icones et comment tu l'ajoute au vecteur.
Il nous faut assez de contexte: la fonction entiere dans les deux cas.

[Kalemiro]

Je vais mettre un peu plus de code du coup

La classe icone:

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
 
class Icone: public Dessin
{
private:
//  SDL_Surface* iconeSurface;
  std::string commande;
  std::string pathIcone;
 
public:
  Icone(SDL_Surface*, int, int, int, int, int, std::string, std::string);
  ~Icone();
 
  inline const std::string getCommande(){return commande;}
  const char* getPathIcone();
 
  void dessinIcone();
 
 
};

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
29
30
31
32
33
 
Icone::Icone(SDL_Surface* _affichage, int _r, int _g, int _b, int _x, int _y, std::string _commande, std::string _pathIcone)
        :Dessin(affichage, r, g, b, x, y), commande(_commande), pathIcone(_pathIcone)
{
	affichage=_affichage;
	x=_x;
	y=_y;
	commande = _commande;
}
 
Icone::~Icone()
{}
 
 
const char* Icone::getPathIcone() //On recupere le chemin de l'image et on le convertit en const char* pour l'utiliser avec IMG_Load
{
	const char* path = pathIcone.c_str();
	return path;
}
 
 
void Icone::dessinIcone()
{
  SDL_Surface* iconeSurface;
  SDL_Rect positionIcone;
 
  positionIcone.x=this->getX();
  positionIcone.y=this->getY();
 
  iconeSurface=IMG_Load(this->getPathIcone());
 
  SDL_BlitSurface(iconeSurface, NULL, (this->affichage), &positionIcone);
}

et je remet le remplissage du vector

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
 
	std::ifstream fichier("application.txt");
	if(fichier)
	{
 
 
		getline(fichier, strNbApp);
		if(!(std::istringstream(strNbApp) >> nbApp) ) nbApp = 0;
		for(unsigned int i = 0; i<nbApp; ++i)
		{
			getline(fichier, commande);
			getline(fichier, icone);
			tabIcone.emplace_back(affichage, 0, 0, 0, 20*i+5, (maxH/10)+20, commande, icone);
		}
	}

et la fonction de dessin:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void dessinerInterface(Rectangle partieGauche, Rectangle partieDroite, Rectangle barreHaut, std::vector<Icone> tabIcone)
{
	partieGauche.dessinRectanglePlein();
 
	partieDroite.dessinRectanglePlein();
 
	barreHaut.dessinRectanglePlein();     
 
	for(auto &icone : tabIcone)
	{
		icone.dessinIcone();
	}
}

Je suis quasi sur que lors de la création l'image est la bonne je l'ai testé avec un fonction "allégée", je me dit que c'est peut etre a cause des "this->" dans icone.cpp parce que je crois que j'avais déjà eu affaire à un problème similaire une fois que j'avais réglé en enlevant les "this->"


Edit: j'ai testé en enlevant les "this->" ca ne marche toujours pas

[ternel]

Le problème est dans le constructeur.

Code :

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

tabIcone.emplace_back(affichage, 0, 0, 0, 20*i+5, (maxH/10)+20, commande, icone);

Ceci appelle en interne Icone(affichage, 0, 0, 0, 20*i+5, (maxH/10)+20, commande, icone); (probablement via un placement new...).

Ton constructeur est défini ainsi:

Code :

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

1
2
3
4
5
6
7
8
Icone::Icone(SDL_Surface* _affichage, int _r, int _g, int _b, int _x, int _y, std::string _commande, std::string _pathIcone)
        :Dessin(affichage, r, g, b, x, y), commande(_commande), pathIcone(_pathIcone)
{
	affichage=_affichage;
	x=_x;
	y=_y;
	commande = _commande;
}

Ce code est effectivement exécuté ainsi:

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
//Icone(affichage, 0, 0, 0, 20*i+5, (maxH/10)+20, commande, icone)
 
//passage des arguments:
SDL_Surface* _affichage = affichage;
int _r = 0;
int _g = 0;
int _b = 0;
int _x = 20*i+5;
int _y = (maxH/10)+20;
std::string _commande = commande;
std::string _pathIcone = icone;
 
//pointeur this sur de la mémoire arbitraire
this = quelque chose, c'est le compilateur qui le gère.
 
//liste d'initialisation
appelle de Dessin(affichage, r, g, b, x, y) sur le début de la mémoire de this (héritage)
this->commande est construit via std::string(_commande)
this->pathIcone est construit via std::string(_pathIcone)
les autres membres de *this sont initialisé par défaut
 
//corps du constructeur
{
	affichage=_affichage;
	x=_x;
	y=_y;
	commande = _commande;
}

Le défaut, c'est que lorsque tu appelle Dessin, les arguments que tu transmets sont les membres la classe, alors qu'ils ne sont pas encore initialisés.
Tu devrais utiliser Dessin(_affichage, _r, _g, _b, _x, _y).
Tu ne devrais jamais avoir d'affectations simples dans le corps du constructeur, tout devrait idéalement passer dans la liste d'initialisation.

De plus, on a tendance à utiliser l'underscore pour les variables membres, plutot que pour les paramètres de la fonction.
Mieux encore, dans le cas d'un constructeur, les arguments peuvent avoir le même nom que le membre qu'il sert à initialiser.

Au passage, les objets comme std::string mérite des références constantes.

Ainsi, ton constructeur pourrait/devrait donc avoir cette forme:

Code :

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

1
2
3
4
Icone::Icone(SDL_Surface* affichage, int r, int g, int b, int x, int y, std::string const& commande, std::string const& pathIcone):
    Dessin(affichage, r, g, b, x, y),
    commande(commande), pathIcone(pathIcone)
{}

Le corps de ton constructeur souligne que tu avais remarqué que le constructeur de Dessin ne marchait pas, mais que tu avais contourné (partiellement) le problème.

[Médinoc]

La classe Dessin interdit-elle bien la copie maintenant?

[Kalemiro]

leternel merci je vais regarder ca, en cours j'ai déjà mit des affectations simples dans le corps du constructeur donc j'ai prit un peu la mauvaise habitude

La classe Dessin interdit-elle bien la copie maintenant?

C'est à dire ?

[Médinoc]

Ah, j'ai du perdre quelques étapes, je croyais que tes classes Dessin et Icone géraient toujours une ressource ne supportant pas la copie (et était clairement à sémantique d'entité).

Mais dans ce que je vois de ton code actuel, il n'est pas certain que ce soit le cas, tu peux donc oublier mon précédent commentaire.

---

Par contre:

• Les fonctions membres getPathIcone() et getCommande(), puisqu'elles ne modifient pas l'objet ni ne donnent d'accès en écriture dessus, devraient elles-mêmes être déclarées const:

  Code :

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

  1
  2
  inline const std::string getCommande() const {return commande;}
  const char* getPathIcone() const;

• N'ayant pas le code de dessinIcone() je ne peux pas dire si c'est également son cas, mais je le soupçonne fortement.

[Kalemiro]

Médinoc -> oui bien vu pour le const

leternel -> Même en modifiant le constructeur comme tu le fait ca ne marche pas