#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
class A {
public:
// Classe exemple pour symboliser le fait que je souhaite utiliser
// une classe que j'ai fait moi-même et pas tout simplement un vector<string> par exemple
std::string name;
A(const std::string &name) : name(name) {}
virtual ~A() {}
};
class B {
std::vector<A> listB;
public:
// Je mets "hello world" dans mon itérateur
B() {
this->listB.push_back(A("hello"));
this->listB.push_back(A(" "));
this->listB.push_back(A("world"));
}
// Procédure qui prend en paramètre un string et le met en majuscule, la question n'est pas de vérifier qu'elle fonctionne
void stringToUpperCase(std::string & str) {
std::transform(str.begin(), str.end(), str.begin(), ::toupper);
}
// Procédure qui prend en paramètre un string et le met en minuscule, la question n'est pas de vérifier qu'elle fonctionne
void stringToLowerCase(std::string & str) {
std::transform(str.begin(), str.end(), str.begin(), ::tolower);
}
// Je définis ici le type fctDoStuffOnList qui prend en paramètre un string &, qui ne retourne rien (void)
typedef void(B::*fctDoStuffOnList)(std::string &);
// Procédure qui parcourt le vector et applique à chaque objet un traitement (donné en paramètre)
// Ici, fct est un pointeur de fonction
void doStuff(fctDoStuffOnList fct) {
std::vector<A>::iterator it;
for (it = listB.begin(); it < listB.end(); it++) {
// La ligne suivante me fait une erreur :
// "l'expression qui précède les parenthèses de l'appel apparent doit avoir le type de fonction (pointeur-à-)"
[color=red](this->*[/color]fct[color=red])[/color](it->name);
// J'affiche l'objet traité
std::cout << it->name;
}
std::cout << std::endl;
}
virtual ~B() {}
};
int main() {
B test;
// Appel à test.doStuff avec en paramètre B::stringToUpperCase
test.doStuff(&B::stringToUpperCase);
system("pause");
exit(0);
}