Discussion :

[albat0r]

Bonjour, j'aimerais par l'utilisation d'un foncteur pouvoir passer en argument à une autre fonction ce foncteur auquel je passe les arguments du constructeur et qui me retourne directement la valeur de retour de la surcharge de l'opérateur () . Je suis presque sur de l'avoir déjà vu quelques part et j'essaye d'utiliser ceci à mon tour de cette façon ( réduit au plus simple possible )

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
 
#include <iostream>
 
using namespace std;
 
 
class P {
 
public :
    P(char *data) : c_(data) { }
    ~P() { }
 
    string operator() () const
    {
        string str = c_;
        return str;
    }
 
private :
    char *c_;
 
};
 
class A {
 
public :
    A() { }
    ~A() { }
 
    void print( string s)
    {
        cout << s << endl;
    }
 
};
 
int main()
{
	A a;
	a.print(P("hello world"));
	return 0;
}

Bien sur la compilation échoue sur l'appelle de la méthode print qui n'attend pas un objet de type P pourtant je suis presque sur d'avoir vu une méthode qui permettait ce genre d'écriture.
Si quelqu'un pouvait éclairer ma lanterne je lui en serais reconnaissant.

[Laurent Gomila]

Je ne sais pas trop ce que tu veux faire, mais tu as deux solutions :

1- Tel que ton code est écrit, il faut appeler l'opérateur ()

Code :

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

a.print(P("hello world")());

2- Si tu ne veux pas d'appel explicite, ce n'est pas un opérateur () qu'il te faut mais un opérateur de conversion

Code :

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

1
2
3
4
5
operator string() const
{
    string str = c_;
    return str;
}

[albat0r]

Merci beaucoup de ta réponse, en fait je pensais utiliser ce systeme pour des "packets". J'avais tenté auparavant l'operateur de conversion et mon exemple était ptête pas bien choisi en fait je suis en train de confronter plus un problème lié au templates ; mon idée de base et de pouvoir renvoyer différent packets avec l'opérateur de conversion dans des boost::array mais certain des packets peuvent avoir une taille différente.

le code de mes rêves serait le suivant, mais il ne peut pas fonctionner; je remet en question ce systeme pour le changer peut être encapsulé le boost::array qui me sert de buffer... encore plus qu'une solution, si vous avez des conseils à me donner je suis preneur.

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
#include <iostream>
#include <boost/array.hpp>
 
using namespace std;
 
 
class P {
 
public :
    P(int i) : size_(i) { }
    ~P() { }
 
    template< typename Pod_Type, size_t N >
    operator boost::array<char, 10>() const
    {
        // La taille du buffer dépend des données passées au constructeur
 
        //int taille = 5*2*size_; // calcul débile
        // mais impossible de retourner un boost::array de taille variable car const
        boost::array<char,10> a;
        return a;
    }
 
private :
    int size_;
 
};
 
class A {
 
public :
    A() { }
    ~A() { }
 
    template< typename Pod_Type, size_t N >
    void print( boost::array<Pod_Type, N>& array)
    {
        cout << array.data() << endl;
    }
 
};
 
int main()
{
	A a;
	a.print(P(10));
	return 0;
}

[koala01]

Salut,

Ceci dit, il serait beaucoup plus facile, à mon idée, de fournir directement un const std::string& au constructeur de ta classe...

En effet, un code du genre de

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
 
#include <string>
#include <iostream>
 
class a
{
    public:
        a(const std::string& data):_data(data){}
        ~a(){}
        const std::string& Data(){return _data;}
    private:
        std::string _data;
};
 
int main()
{
    char data[]="hello world";
    a essai(data);
    std::cout<<essai.Data()<<std::endl;
    return 0;
}

fonctinone sans problème

Quitte à utiliser la fonction membre c_str() des std::string si, à un moment donné, tu dois disposer d'une chaine "C style"

[albat0r]

En réalité mon problème était plus pour simplifier au maximum l'écriture l'idée était de faire un appelle à une fonction qui permet l'envoie et de lui passer en parramètre le packet particulier par exemple :

envoie( MonPacket( param1, param2));

et de pouvoir faire ça avec tous les packet différents chacun proposant un opérateur de convertion vers un boost::array qui me sert de buffer pour stocker le packet.
Le problème survient je pense parceque la fonction envoie attend en paramettre un boost::array mais ne connais pas les paramètre du template à l'avance donc ça ne peut pas fonctionner. Il faut que je repense ce systeme mais j'aimerai garder une écriture simple.

[Laurent Gomila]

Pourquoi ne pas renvoyer un vrai tableau dynamique (std::vector) ?

Et puis... Le fait de construire un temporaire avec un paramètre et de définir un opérateur de cast pour renvoyer autre chose, c'est une manière vraiment tordue d'écrire ce qui revient en fait à un bête appel de fonction. Non ?

[albat0r]

Je me suis creusé un peu la tête et je vais adopter une autre solution surement inspiré des shared_const_buffer proposé dans les exemples attaché à la lib asio de boost qui utilise d'ailleur des std::vector.

Merci de vos réponses.