Discussion :

[Katian]

Bonjour,

Dans le code ci-dessous :

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
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 :

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 ?

[Médinoc]

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

[Médinoc]

Avec ceci sous Visual Studio 2013:

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
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 X :

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

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.

[Katian]

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...