Discussion :

[ledjlale]

J'aimerais utiliser un objet fils par polymorphisme, donné par une fonction générique (utilisé en virtual).
En gros, je cherche à creer un objet B dans un f(), qui serait utilisé uniquement dans l'instruction appelante.
Mais je ne sais pas si l'objet créé statiquement dans f sera effacé de la mémoire apres l'instruction, ou vraiment à la sortie de f(). Un new reglerais le probleme, mais cela m'oblige soit à passer par des smart-pointer, soit à faire des delete apres l'instruction ce que je ne veux pas faire.
ex:

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
 
A * f() // fonction créant un objet temporaire de type B
{
  B b;    // Creation d'un objet fils en statique
  b.setVal(1); // Initialisation de b
  return &b;  // Que devient b? (1)
}
 
int main()
{
...
   f()->func(); // func est, une fonction virtuelle. Ce serait donc la fonction d'un B ici. 
// Que devient b lors de l'appel de func()? (2)
...
}

Vu que l'on sort de la fonction f() avant l'appel de func(), b est effacé de la mémoire. Ce qui devrait normalement faire cracher le programme en mode debug. Or, j'ai pu constater que non. D'où ma question.

[Médinoc]

B est détruit, donc si ça ne crashe pas c'est que tu n'as pas de chance.

[ledjlale]

Voici un exemple de code. En réalisant l'allocation, tout se passe comme je veux.
Mais si on revient à une allocation statique, on remarque que la fonction print() appelée est celle de B mais avec un objet vierge (i=indefini). Ca confirme ce que tu viens de dire, et donc que ça fait n'importe quoi (la fonction de A est appelée quelques fois). Mais alors pourquoi il n'y a pas d'erreur en mode DEBUG?

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
 
#include <iostream>
#include <string>
class A
{
public:
	A(){}
	virtual A * f(){ return NULL;}
	virtual int print(){return 0;}
};
class B : public A
{
	int i;
public:
	virtual A * f()
	{
		//B b;
		//b.i = 40;
		B * b = new B();
		b->i = 40;
		return b;
	}
	virtual int print()
	{
		return i;
	}
};
int main()
{
	B b;
	std::cout << b.f()->print();
	return 0;
}

Et avez-vous des idées pour mettre en place ce genre d'utilisation, sans faire appel à des new et autres smart-pointer?

[Médinoc]

Le mode Debug n'est pas la panacée, et ne détecte pas tout.

[Médinoc]

Et je pense que tu n'auras pas le choix. Il faudra un new, et un pointeur intelligent.

Pour le cas présent, retourner un std::auto_ptr<> peut très bien faire l'affaire,
même si je suis plutôt du genre à préférer le comptage de références intrusif...

[ledjlale]

Je croyais qu'il vérifiait les accés mémoires quand on essayait d'en manipuler sans avoir au préalable reserver les accés :/

[Médinoc]

Sauf que là, tu as accès à la mémoire en question, puisqu'elle est sur la pile.

La CRT de débogage pourrait faire un test pour savoir si le pointeur pointe vers une partie "invalide" de la pile, mais je suppose que soit ils n'y ont pas pensé, soit ça boufferait trop, soit que sais-je...

[ledjlale]

Par vérification, je voulais parler d'un test d'invalidité (ce que tu dis apres quoi).
Merci beaucoup, je vais tenter d'utiliser les auto_ptr.

Pour ceux que ça interesse (au cas où), voici l'exemple avec les auto_ptr

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
34
 
#include <iostream>
#include <string>
#include <memory>
class A
{
public:
	A(){}
	virtual std::auto_ptr<A> f(){std::auto_ptr<A> p(NULL); return p;}
	virtual int print(){return 0;}
};
class B : public A
{
	int i;
public:
	virtual std::auto_ptr<A> f()
	{
		std::auto_ptr<A> p;
		B * b = new B();
		b->i = 40;
		p = std::auto_ptr<A>(b);
		return p;
	}
	virtual int print()
	{
		return i;
	}
};
int main()
{
	B b;
	std::cout << b.f()->print();
	return 0;
}