Discussion :

[Nekkro]

Bonjour,

J'ai une structure définie comme ceci :

Code :

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

1
2
3
4
5
struct X
{
    std::ofstream file;
    // ...
};

et une classe Y qui stocke des X :

Code :

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

1
2
3
4
5
class Y
{
    private:
        std::unordered_map<std::string, X> data;
};

Mon soucis, c'est que lorsque je veux créer un nouveau X et le ranger dans data, le compilateur m'en empêche :

error: use of deleted function 'X& X::operator=(const X&)'
note: 'X& X::operator=(const X&)' is implicitly deleted because the default definition would be ill-formed:
error: use of deleted function 'std::basic_ofstream<char>& std::basic_ofstream<char>::operator=(const std::basic_ofstream<char>&)'

Comment puis-je m'en sortir ? J'aimerais pouvoir faire ceci :

Code :

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

1
2
Y y;
y.add_X ("ID", X(/* ... */));

Comment puis-je le créer sans copie ? (j'utilise un mingw64 avec gcc 4.7).

[Ekleog]

Il faudra utiliser un pointeur quelque part. Soit pour stocker le fstream dans X, soit pour stocker le X dans la map.

[JolyLoic]

Ton gcc gère la move semantic. Il est impossible de copier un fstream, mais il est possible de le déplacer.

Déjà pour activer les nouveautés du C++11, il faut compiler avec le flag -std=c++11

Ensuite, il faut que ton objet contenant un flux soit lui même déplaçable. Et finalement, pour mettre dans ta map, que tu ne génère pas de copie, mais un déplacement.

Peut-être que si tu montre un peu plus de code il sera possible de voir où ça coince ?

[Nekkro]

Je compile déjà en C++11, pour pouvoir utiliser les unordered_map sans boost.

Voici la classe X (partiellement) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
struct LogLevel
{
	LogLevel (const std::string & file_name, const std::string & msg_header = "[TRACE]", const std::string & date_format = "[%d/%m/%y - %H:%M]"):
		file (file_name, std::ios::app), header (msg_header), file_name (file_name), date_format (date_format) {}
 
	~LogLevel () { if (file.is_open()) file.close(); }
 
	std::ofstream file;
	std::string   header,
	              file_name,
	              date_format;
};

Et la classe Y (partiellement) :

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
class Logger
{
	public: // -- CONSTRUCTORS
		Logger () = default;
		Logger (std::initializer_list <LogLevel> levels);
 
	public: // -- DATA MANAGEMENT
		void register_level (const std::unordered_map<std::string, LogLevel> & levels)
		{
			for (auto it = levels.begin() ; it != levels.end() ; ++it)
				this->levels[it->first] = LogLevel (it->second.file_name, it->second.header, it->second.date_format); // Problème ici
		}
 
	private: // -- DATA
		std::unordered_map <std::string, LogLevel> levels;
};

J'aimerais pouvoir faire ça au final :

Code :

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

1
2
3
4
logger.register_level (
	{"UN_NIVEAU", LogLevel ("./logs/")},
	{"UN_AUTRE", LogLevel ("./logs/other/")}
);

J'ai pensé utiliser un emplace, mais j'ai des tas d'autres erreurs.

[JolyLoic]

Je n'ai pas trop l'habitude de la move semantic, devant compiler sur des antiquités, mais je dirais à vue de nez :

- Le destructeur dans LogLevel empêche la génération automatique d'un mode constructor de déplacement ou d'un opérateur= par déplacement. Donc soit tu supprimes ce destructeur (qui de toute façon n'a pas l'air utile, a moins que le vrai code fasse d'autres choses), soit tu déclares et défini ces deux opérations (éventuellement avec du =default, pour ne pas avoir à les implémenter). Ta classe est désormais movable

- Comme dans ta ligne this->levels[it->first] = LogLevel (it->second.file_name, it->second.header, it->second.date_format);, ce que tu ajoutes dans ta map est un temporaire, le compilateur devrait choisir la version qui déplace, donc ton code devrait compiler.

- Par contre, avec ce code, tu te retrouves à ouvrir deux fois le fichier de log simultanément, la seconde ouverture va probablement échouer, et donc le flux être dans un état d'erreur, et c'est celle là qui importe... Il serait donc probablement préférable de modifier ta fonction pour qu'elle prenne tes données par r-value ref aussi, prenant alors possession de celles ci, et t'obligeant lors de l'appel à lui passer des données temporaires qui ne seront plus utilisées après.

[Nekkro]

Je te remercie de tes réponses, cependant :

- La mise en commentaire de mon constructeur ne change strictement rien. Par ailleurs, j'ai lu à plusieurs reprises que le destructeur d'un of/if/fstream ne fermait pas le fichier, et que donc il fallait le faire manuellement.
J'ai donc ajouté les deux operations en mode = default; mais elles sont implicitement deleted par mon compilateur car il semblerait que mon ofstream n'ait pas de sémantique de déplacement.

- A cette ligne précise, mon compilateur persiste à vouloir utiliser l'operator= (const ofstream &) plus que la version move, je suppose donc qu'elle n'existe pas.

- De quelle façon puis-je arriver à ce résultat ? J'ai besoin de passer par le constructeur par initializer_list de mon unordered_map pour faire ce dont j'ai besoin, donc je ne peux pas me passer de celle-ci.