std::function et durée de vie d'une instance

Version imprimable

Bonjour,

Dans le code ci-dessous :
Code:

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 35 36 using fun = std::function<void(int)>; class Class_ { public: Class_() { std::cout << "ctor" << std::endl; } ~Class_() { std::cout << "dtor" << std::endl; } void operator()(int x_) { std::cout << "x " << x_ << std::endl; } }; void show(const fun& f_) { f_(1); } void test_function2() { fun fff; { Class_ ccc; fff = ccc; } show(fff); }
... j'appelle la fonction test_function2() et voila l'affichage :

Citation:

ctor
dtor
dtor
x 1
dtor

Mes questions :
1 - Ce code est-il correct ? j'ai voulu testé std::function en limitant la portée de l'instance ccc, je ne pensais pas que ça pourrait fonctionner...
2 - pourquoi le destructeur est appelé 3 fois ?

22/11/2017, 10h36
Médinoc

Tu ne loggues que le constructeur par défaut, mais pas celui de copie, de déplacement, l'opérateur d'affectation...

Avec ceci sous Visual Studio 2013:

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include <atomic>
#include <iostream>
#include <functional>
 
namespace TestLogCtor
{
 
	//
	//----------------------------------------------------------------------------
	//CountAndLog class
 
	class CountAndLog
	{
		static std::atomic<int> idGenerator;
	public:
		const int id;
		CountAndLog() : id(idGenerator.fetch_add(1)) { Log("ctor"); }
		CountAndLog(CountAndLog const &src) : id(idGenerator.fetch_add(1)) { Log("cctor", src.id); }
		CountAndLog(CountAndLog &&src) : id(idGenerator.fetch_add(1)) { Log("mctor", src.id); }
		~CountAndLog() { Log("dtor"); }
		CountAndLog& operator=(CountAndLog const &src) { Log("op=", src.id); }
		CountAndLog& operator=(CountAndLog &&src) { Log("mop=", src.id); }
	private:
		void Log(const char *text);
		void Log(const char *text, int idFrom);
	};
 
	std::atomic<int> CountAndLog::idGenerator;
 
	void CountAndLog::Log(const char *text)
	{
		std::cout << "CountAndLog #" << id << ": " << text << std::endl;
	}
	void CountAndLog::Log(const char *text, int idFrom)
	{
		std::cout << "CountAndLog #" << id << ": " << text << " from #" << idFrom << std::endl;
	}
 
	//
	//----------------------------------------------------------------------------
	//Rest of the test
 
	using fun = std::function<void(int)>;
 
	class SomeClass : private CountAndLog
	{
	public:
		void operator()(int x_)
		{
			std::cout << "x " << x_ << std::endl;
		}
	};
 
	void show(const fun& f_)
	{
		f_(1);
	}
 
	void test_function2()
	{
		fun fff;
 
		{
			SomeClass ccc;
			fff = ccc;
		}
 
		show(fff);
	}
 
}//namespace TestLogCtor

J'obtiens la sortie suivante, aussi bien en Debug qu'en Release:

Code:

1
2
3
4
5
CountAndLog #0: ctor
CountAndLog #1: cctor from #0
CountAndLog #0: dtor
x 1
CountAndLog #1: dtor

Je ne sais pas pourquoi l'objet est loggué comme détruit trois fois dans ton test, mais je soupçonne qu'il y a une copie supplémentaire quelque part.

22/11/2017, 11h00
Katian

Citation:

Envoyé par Médinoc

Tu ne loggues que le constructeur par défaut, mais pas celui de copie, de déplacement, l'opérateur d'affectation...

Évidement ! merci d'avoir pris le temps de me répondre, tout à coup me reviens en tête "la forme canonique de Coplien", et tout rentre dans l'ordre... :roll: