Discussion :

[ChPr]

Bonjour à toutes et à tous,

Les pointeurs en C++ : ça me traumatise

Je voudrais passer en paramètre d'une méthode una autre méthode. Je n'arrive pas à imaginer la syntaxe à employer.

Soit le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void a() {}
void b() {}
 
void c(// Qu'écrire ici pour utiliser a ou b) {
  // Qu'écrire ici pour que a ou b soit exécutée;
}
 
...
 
// appel de c pour utiliser a ou b
 
  c(// Qu'écrire ici pour utiliser a);
  c(// Qu'écrire ici pour utiliser b);

Je suppose que a et b doivent avoir le même prototype.

Merci pour votre aide.

Pierre

[the Hound]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void a() {}
void b() {}
 
// Grosso modo
void c(std::function<void()> f) {
  f();
}
 
...
 
// appel de c pour utiliser a ou b
 
  c(&a);
  c(&b);

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void a() {}
void b() {}
 
void c(void (*f)()) {
  f();
}
 
...
 
// appel de c pour utiliser a ou b
 
  c(&a);
  c(&b);

[Flob90]

Bonjour,

Laisse le compilateur te déterminer les types :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
template<class F>
void foo(F&& fun)
{
  //ici tu utilises fun comme une fonction :
  fun(0,1);
}
 
void bar(int,int){}
 
//Pour passer bar à foo :
foo(bar);

C++11, en C++03 enlève juste la &&.

[Médinoc]

Si tu n'as pas C++11, seule la seconde solution marche, mais pour elle je conseille d'y ajouter un typedef pour manipuler le pointeur de fonction plus facilement:

Code C++ :

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

1
2
3
4
5
typedef void (*void_func_ptr)();
 
void c(void_func_ptr f) {
  f();
}

Note que cela marche pour les fonctions libres, ou les fonctions statiques d'une classe. Pour les fonctions membres non-statiques, c'est plus compliqué et je ne me souviens jamais de la syntaxe appropriée par cœur, obligé de chercher sur le net à chaque fois.

[ChPr]

Merci beaucoup the Hound

Gela se compile très bien.

Maintenant, je mets des variables dans a et b tel que :

Code :

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

1
2
3
4
5
6
void a(int x) {}
void b(int x) {}
 
void c(void (*f)(int x)) {
  f(x);
}

mais j'obtiens une erreur :

error: 'x' was not declared in this scope

Désolé, je suis vraiment lourd.

Cordialement.

Pierre

[the Hound]

Pour les fonctions membres non-statiques, c'est plus compliqué et je ne me souviens jamais de la syntaxe appropriée par cœur, obligé de chercher sur le net à chaque fois.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class T {
  public:
    void toto(int);
};
 
void foo(void (T::*f)(int)) {
  T instance;
  (instance.*f)(42); // Pas sûr de mon coup
}
 
foo(&T::toto);

[the Hound]

mais j'obtiens une erreur :

error: 'x' was not declared in this scope

C'est parce que ... tu n'as pas déclaré de x.
Dans void c(void (*f)(int x)), le nom x est donné à titre indicatif mais le compilo n'y prête aucune attention.
Tout ce qu'il sait et a besoin de savoir c'est que f renvoie void et prend un int.
La seule variable qui est déclarée dans ta fonction c'est donc f, x n'existe pas.

[ChPr]

Il faut donc que j'écrive quelque chose dans le genre :

Code :

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

1
2
3
4
5
6
7
8
void a(int x) {
}
void b(int x) {
}
 
void c(int v, void (*f)(int x)) {
  f(v);
}

v sera la valeur passée aux fonctions a ou b ?

(je commence à y voir un peu plus clair, mais qu'est ce que j'ai du mal avec la syntaxe du C . Faut que je m'y mette)

Cordialement.

Pierre

[Médinoc]

Oui, c'est exactement ça.

[Neckara]

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
template<class F>
void foo(F&& fun)
{
  //ici tu utilises fun comme une fonction :
  fun(0,1);
}
 
void bar(int,int){}
 
//Pour passer bar à foo :
foo(bar);

Pourquoi utiliser la move semantic et pas une référence ?

[the Hound]

Pourquoi utiliser la move semantic et pas une référence ?

J'imagine que ça permet d'utiliser des foncteurs créés temporairement.
Remarque au passage, la solution à base de template ne peut fonctionner que si l'appel de fonction se fait dans la même unité de compilation que celle où le template est défini.

[Neckara]

J'imagine que ça permet d'utiliser des foncteurs créés temporairement.

Le problème c'est qu'on ne pourra pas utiliser une std::function plusieurs fois.

Est-ce qu'une référence constante ne marche pas pour les objets temporaires ?

[Ehonn]

Remarque au passage, la solution à base de template ne peut fonctionner que si l'appel de fonction se fait dans la même unité de compilation que celle où le template est défini.

J'ai du mal à voir le souci. Peux-tu donner un exemple où cela ne fonctionne pas ?

Est-ce qu'une référence constante ne marche pas pour les objets temporaires ?

Si, mais une référence sur membre constant t'interdit d'utiliser un foncteur avec l'opérateur () non const.
Dans ce cas, il faut la move semantique ou faire une copie.

[Neckara]

Si, mais une référence sur membre constant t'interdit d'utiliser un foncteur avec l'opérateur () const.

Tu ne veux pas plutôt dire qu'il interdit d'utiliser : operator(); vu qu'il attend un operator() const; ?

Mais dans ce cas, là, pourquoi passer par la move semantic (C++11) des foncteurs alors qu'en C++11 on utilise des std::function ?

[Ehonn]

Tu ne veux pas plutôt dire qu'il interdit d'utiliser : operator(); vu qu'il attend un operator() const; ?

Déjà corrigé avant ton message

[Médinoc]

Les foncteurs ne sont-ils pas généralement passés par valeur, dans la STL?

[Ehonn]

Avec la solution template, on pourra passer une lvalue car le template sera remplacé par T &.
Et du coup, le compilateur passera une sorte de T & && (en pratique il passera T &) et il n'y aura pas de véritable déplacement. (Je veux bien de vrais explications là-dessus )

Voici un exemple :

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
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
#include <type_traits>
 
 
class A
{
public:
 
	void operator()() { std::cout << "A::()()" << std::endl; }
};
 
template <class func_t>
void call(func_t && f)
{
	std::cout << "func_t is a &  = " << std::is_reference<func_t>::value << std::endl;
	std::cout << "func_t is a && = " << std::is_rvalue_reference<func_t>::value << std::endl;
	std::cout << "     f is a &  = " << std::is_reference<decltype(f)>::value << std::endl;
	std::cout << "     f is a && = " << std::is_rvalue_reference<decltype(f)>::value << std::endl;
	f();
}
 
 
int main()
{
	A a;
	call(a);
	std::cout << std::endl;
 
	call(A());
	std::cout << std::endl;
 
	return 0;   
}

Et voici la sortie :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
$ g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
func_t is a &  = 1
func_t is a && = 0
     f is a &  = 1
     f is a && = 0
A::()()
 
func_t is a &  = 0
func_t is a && = 0
     f is a &  = 1
     f is a && = 1
A::()()

Si on n'avait pas de template mais directement ce code là :

Code :

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

1
2
3
4
5
6
void call(A && f)
{
	std::cout << "&  = " << std::is_reference<decltype(f)>::value << std::endl;
	std::cout << "&& = " << std::is_rvalue_reference<decltype(f)>::value << std::endl;
	f();
}

On aurait eu une erreur de compilation car la fonction prend uniquement une rvalue et non une lvalue.

Code :

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

error: cannot bind ‘A’ lvalue to ‘A&&’

[Flob90]

@Neckara: Avant le C++11 la manière de prendre un foncteur en paramètre c'était par copie, pour permettre la prise de temporaire et de foncteurs non constants. Le C++11 nous apporte de quoi faire la même chose sans payer la copie, je l'utilise.

@The Hound: Je ne comprends pas ce que tu veux dire avec ton histoire d'unité de compilation ? Une fonction template n'est pas nécessairement définit dans une seule unité de compilation. Tu parles de l'appel de quelle fonction ? De la template ou du foncteur que l'on passe ?

@Médinoc: Ça dépend des éléments, la partie algorithme de la bibliothèque standard utilise des passages par copie, mais bind/thread utilise ce que je propose. Je ne sais pas si le passage par copie dans les algorithmes a été conservé pour des raisons propres ou juste pour éviter de les modifier.

@Ehonn: C'est le fonctionnement de la déduction des paramètres template. Quand tu as template<class T> void foo(T&&); lors d'un appel foo(i) un ensemble de règles conduit à la déduction du type T dans ce cas la présence de && conduit à :

• T=decltype(a)& si a est une lvalue, l'appel est donc foo<decltype(a)&>(i);.
• T=decltype(a) si a est une rvalue, l'appel est donc foo<decltype(a)>(i);.

Ensuite une dernière règle entre en jeux. Il est interdit de former des références de références, mais quand cella se produit dans ce cas (c'est plus général, ça inclut la situation où ça se produirait avec typedef ou decltype aussi), alors :

• T rq & = T&
• T rq && = T rq

où rq est soit & soit &&. On obtient donc :

• void foo(declatyp(a)&); si a est une lvalue.
• void foo(decltype(a)&&); si a est une rvalue.

(Normes : 8.3.2 et 14.8.2.1)