retour multiple sur une lambda

**bowow** · 08/06/2017, 14h05

Bonjour,

J'aimerais effectuer un test d'égalité sur deux valeurs dans une MAP.

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
#pragma once
 
#include <string>
#include <map>
#include <vector>
#include <algorithm>
 
struct data
{
	int value;
	std::string String;
};
 
struct header
{
	int v;
	std::string s;
};
 
class example
{
	private:
	header h_;
	data d_;
	std::map<header, std::vector<data>> container;
 
	public:
	example(const header& h, const data& d) : h_(h), d_(d) {}
 
	void processing(const int v)
	{
		auto it = std::find_if(std::begin(container), std::end(container), [&](const header& h, const data& d) -> bool { return (h_.v == h.v && d_.value == d.value); });
		if (it != std::end(container))
		{
			it->second.emplace_back(d_);
		}
		else 
		{
			container[h_].emplace_back(d_);
		}
	}
};

Je pense que les lambdas autorisent le retour multiple, à coup de surcharge de l'opérateur () et une bonne utilisation de std::pair/make_pair, non?

Merci d'avance pour vos réponses.

**ternel** · 08/06/2017, 14h27

A tout hasard, pourquoi une map de vector plutot qu'une multimap?

Tu aimerais? C'est bien.

Qu'entends tu par "les retours multiples"?
Une fonction, fusse-t-elle membre d'une classe locale construite par le compilateur (c'est ainsi qu'est compilée une lambda) ne peut retourner qu'une seule chose.
Attention, commes les règles sur les lambdas ont un peu changé entre C++11 et C++14 (puis C++17, à venir), précise-nous quelle est la version dont tu te sers.

Quoiqu'il en soit, find_if attend une lambda qui prend un unique argument, du type des éléments itérés (ou idéalement, d'une référence constante dessus).
En gros, find_if(it1, it2, lambda) n'est valable que si bool b = lambda(*it1); est valide.
Ce n'est pas du tout le cas dans ton code.

Pour le coup, comme tu fournis begin(container) comme itérateur, ton value_type est une pair<header const, std::vector<data>> const&.

Et du coup, je ne comprends pas le lien entre ta question et ton code.

J'ai l'impression que tu n'as pas saisi ce qu'est une lambda. Explique nous ce que c'est, qu'on te corrige si tu te trompes.

**Bousk** · 08/06/2017, 15h29

Où est ta lambda ?
Où sont les multiples retours ?

Ton test est inutile et l'opérateur [] de map crée l'élément s'il n'existe pas, tu devrais donc appeler container[h_].emplace_back(d_); dans tous les cas et basta.

**bowow** · 08/06/2017, 18h34

Je n'ai vraiment pas bien exposé mon problème, c'est le cas de le dire ..

Bon en fait, je suis parti dans le gros n'importe quoi d'anthologie. Le crash du compilateur était incompréhensible pour moi.
Mon problème était que je plaçais une structure en tant que KEY dans une MAP et il n'aimait pas.

Après recherche, on est obligé d'utiliser la surcharge de l'opérateur < comme dans l'exemple si contre:

Je repose un nouveau code:

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
#pragma once
 
#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <algorithm>
 
struct header
{
	int hvalue;
	std::string hstring;
 
	bool operator<(const header &h) const {
		return hvalue < h.hvalue || (hvalue == h.hvalue && hstring.compare(h.hstring));
	}
 
};
 
struct body
{
	int bvalue;
	std::string bstring;
};
 
class basic
{
	private:
	header header_;
	body body_;
	std::map<header, std::vector<body>> container;
 
	public:
	basic() = default;
	basic(header& h, body& b) : header_(h), body_(b) {}
	basic(const basic& c) = default;
	basic(basic&& m) = default;
	basic& operator=(const basic& o) = default;
	~basic() = default;
 
	void processing(int v) { container[header_].emplace_back(body_); }
};

PS: Je donne ce code à titre d'exemple. Les structures peuvent contenir 5 à 10 variables.
On est obligé d'effectuer le test sur tous les attributs?

Qu'en pensez-vous ?
Est ce une bonne idée de procéder ainsi ?
Merci.

**JolyLoic** · 08/06/2017, 23h46

Pour l'instant, un des moyens les plus simple pour comparer deux structures avec beaucoup de membre est de faire :

Code :

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

return std::tie(s1.m1, s1.m2, s1.m3, s1.m4) < std::tie(s2.m1, s2.m2, s2.m3, s2.m4) ;

**Bousk** · 09/06/2017, 09h42

Envoyé par bowow

On est obligé d'effectuer le test sur tous les attributs?

Y'a aucune obligation, tu fais le code qui doit être logiquement fait dans ton cas.

Si ta structure a une variable de cache, y'a peu de chance qu'elle serve dans quelconque comparaison.
Quant à utiliser une structure en clé de map, si ça a du sens, alors tu le fais. Si tu te poses la question, pourquoi avoir fait ça en premier lieu ?

**Pyramidev** · 09/06/2017, 18h05

Envoyé par bowow

Code :

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

1
2
3
4
5
6
7
8
9
10
struct header
{
	int hvalue;
	std::string hstring;
 
	bool operator<(const header &h) const {
		return hvalue < h.hvalue || (hvalue == h.hvalue && hstring.compare(h.hstring));
	}
 
};

Attention ! Ta comparaison est mal implémentée.
hstring.compare(h.hstring) ne renvoie pas true si hstring < h.hstring et false dans le cas contraire. Elle renvoie un entier selon la même logique que std::strcmp.
Jette un œil à la doc de std::basic_string::compare.

retour multiple sur une lambda

C++

Vue hybride

Discussions similaires

Partager

Partager