Discussion :

[jackk]

Bonjour,

dans une annale d'épreuve d'info, je suis tombé sur la déclaration d'une classe en C++ dans laquelle se trouvaient des méthodes statiques privées. Je pense qu'il s'agit d'une erreur du sujet, ou alors une subtilité m'échappe.

Pouvez-vous confirmer?

Merci.

[Arzar]

Bonjour,

Ce n'est pas très courant en effet, mais pourquoi pas après tout ?

On pourrait imaginer une fonction membre statique publique assez complexe qui appellerait en fait quelques fonctions helper qui seraient des fonctions membres statiques privées. Le but serait d'éviter que ces sous-fonctions soient appelées directement hors de la classe.

[Neckara]

J'ai peut être un exemple :

Tu as une classe A et une classe B.

La classe B permet l'accès à une table d'une base de données.

Toutes les instances de la classe A ont besoin d'une instance de la classe B pour lire/écrire dans cette table.

Mais il est inutile d'avoir une instance de la classe B pour chaque instance de la classe A, une seule instance de B suffit.

On va donc faire un attribut de classe (= attribut statique) dans A comprenant un pointeur sur une instance de B (on ne peut pas le faire dans B car d'autres classes auraient peut être besoin d'autres instances).
Dès lors on peut décider de créer une méthode statique getInstanceB() qui créé une instance de B si l'attribut de classe est à NULL, qui met son adresse dans l'attribut de classe puis retourne l'adresse.

On peut même mettre en place un compteur pour savoir combien de classes utilisent B (pour éventuellement la détruire quand aucune classe l'utilise). Ou s'en servir pour mettre en place des Mutex si on veut qu'une seule instance de A puisse accèder à l'instance de B à la fois.


A partir de là, l'instance de B ne doit être utilisée que par des instances de A. On ne veut pas que les autres classes puissent écrire dans la table ou incrémente/décrément le compteur ou prenne le Mutex.

Dans ce cas là, l'attribut et la méthode statiques seront privé.

En gros :

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
 
//.h
class B;
 
class A
{
        private static B * table;
        private static B * getInstance();
        A();
};
 
// .cpp
 
private static A::B * table = NULL; //je ne suis pas sûr de la syntaxe
private static B * A::getInstance()
{
         if(!table)
                table = new B('localhost', 'password', 'login', 'table');
         //éventuellement incrémentation d'un compteur statique
         //éventuellement un mutex (statique)
         return table;
}
 
 
//éventuellement :
private static void A::fermerTable()
{
       //décrémentation d'un compteur statique
            //si le compteur est à 0, on détruit l'instance de B et on met table à NULL
       //ou on peut rendre un jeton (Mutex)
}

Mais si on réfléchit bien, on pourrait utiliser un méthode private pour faire ceci.

Mais A à un amis C, et C a la possibilité d'écrire lui-même dans la table.
C doit pouvoir écrire dans la table sans qu'une instance de A existe, on a donc besoin d'une méthode statique privée.

[jackk]

On pourrait imaginer une fonction membre statique publique assez complexe qui appellerait en fait quelques fonctions helper qui seraient des fonctions membres statiques privées. Le but serait d'éviter que ces sous-fonctions soient appelées directement hors de la classe.

Ca fonctionnerait aussi bien en mettant les fonction helper privée sans être statiques il me semble.

Mais A à un amis C, et C a la possibilité d'écrire lui-même dans la table.
C doit pouvoir écrire dans la table sans qu'une instance de A existe, on a donc besoin d'une méthode statique privée.

Merci pour l'exemple. Il fallait y penser. Il semble que ça puisse être le cas. Voici le 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
1. #ifndef __SOCKET_H__
2. #define __SOCKET_H__
3. #include <WinSock2.h>
4. #include <string>
5. typedef std::string String;
// Superclasse
6. class Socket
7. {
8.   public:
9.    enum TYPE { STREAM=SOCK_STREAM, DATAGRAM=SOCK_DGRAM };
10.   Socket(const Socket&);
11.   virtual ~CSocket();
12.   Socket& operator=(const Socket& sock);
13.   String receiveLine();
14.   String receiveBytes();
15.   int receive(void* buf, unsigned size);
16.   void close();
17.   void sendLine (String s);
18.   void sendBytes(const String& s);
19.   void sendBytes(const unsigned char* buff);
20.   void send (const void* buff, unsigned n);
21.  protected:
22.   friend class SocketServer;
23.   Socket(SOCKET s);
24.   Socket();
25.   SOCKET s_; // le socket de la winsock
26.   int* refCounter_;
27.  private:
28.   static void start(); // initialise la librairie des sockets
29.   static void end(); // termine l'utilisation des winsock
30   static int nofSockets_; // nombre de sockets
31. };
32. #endif //__SOCKET_H__

[Neckara]

Je ne sais pas exactement ce que fait tes fonctions mais je suppose que :



static void start();si nofSockets_ est à 0 initialise la bibliothèque puis l'incrémente (il faudrait regarder ce que fais exactement ta fonction.



static void end();Décrémente nofSockets_ et s'il est à 0 termine l'utilisation des winsock.


Ces méthodes doivent pouvoir être utilisé par la classe Socket ET la classe ServerSocket sans qu'une instance de la classe Socket existe.

C'est une espèce de "singleton privé".

[koala01]

Salut,

En fait, une fonction statique est simplement une fonction qui ne dépend d'aucune instance de la classe pour être appelée.

Alors, imaginons que tu aies une fonction publique et statique complexe (comprends : qui se retrouve à avoir plusieurs responsabilités distinctes pour arriver à produire le service qu'on en attend):

En vertu du principe de la responsabilité unique, tu vas essayer de factoriser les différentes responsabilités dans une série d'autres fonctions, qui ne dépendent pas forcément d'une instance particulière de ta classe (et qui peuvent donc être statiques).

Mais, Demeter aidant, tu peux parfaitement estimer qu'une (ou plusieurs) de ces fonctions n'ont aucune raison d'être exposées, et tu décideras donc sans doute de les rendre privées.

Il n'y a donc absolument rien de choquant à se retrouver avec des fonctions statiques privées, d'autant plus que l'on pourrait également envisager le fait de placer une amitié bien réfléchie pour, malgré tout, permettre à une seule et unique classe d'accéder à ces fonctions

[jackk]

Je ne sais pas exactement ce que fait tes fonctions mais je suppose que :

Voilà tout ce que l'on sait sur cette partie du problème, ainsi que la question posée:

La librairie winsock impose les contraintes suivantes
• La librairie ne doit être initialisée qu’une seule fois dans un même processus
• Lorsque les sockets ne sont plus utilisés dans un processus, la fonction WSACleanup doit être appelée
Donner le pseudo code du/des algorithme(s) à mettre en place pour respecter ces contraintes lors :
1. de la création d’un objet de la classe Socket
2. de la destruction d’un objet de la classe
Préciser dans quelle(s) fonction(s) sont exécutés ces algorithmes

Autant je comprends la présence de nofSockets_ déclaré en membre statique privé, autant je ne comprends toujours pas comment va se faire l'appel à start() et stop().

[jackk]

Alors, imaginons que tu aies une fonction publique et statique complexe (comprends : qui se retrouve à avoir plusieurs responsabilités distinctes pour arriver à produire le service qu'on en attend):

En vertu du principe de la responsabilité unique, tu vas essayer de factoriser les différentes responsabilités dans une série d'autres fonctions, qui ne dépendent pas forcément d'une instance particulière de ta classe (et qui peuvent donc être statiques).

Oui, je comprends bien qu'elles peuvent être statiques, mais comme ce n'est pas obligatoire, pourquoi les qualifier de statiques?

Merci en tout cas de vos interventions

[koala01]

Oui, je comprends bien qu'elles peuvent être statiques, mais comme ce n'est pas obligatoire, pourquoi les qualifier de statiques?

Merci en tout cas de vos interventions

Parce qu'elles sont peut etre elles-même appelées depuis une fonction statique et donc indépendante de toute instance de la classe, tout simplement

[jackk]

Parce qu'elles sont peut etre elles-même appelées depuis une fonction statique et donc indépendante de toute instance de la classe, tout simplement

Et ça ne fonctionnerait pas si elles n'étaient pas statiques. Une fonction statique peut bien appeler une fonction non statique de la même classe.

A+

[Neckara]

Certes, une fonction statique peut appeler une méthode non statique de la classe si et seulement si la fonction statique a un pointeur ou une référence (passé en paramètre ou en attribut statique) d'une instance de la classe.

Il faut donc qu'il existe au moins une instance de la classe pour utiliser la méthode non-statique.

Or SocketServer doit pouvoir ouvrir un socket sans qu'une instance de Socket existe forcément.

[Arzar]

Et ça ne fonctionnerait pas si elles n'étaient pas statiques. Une fonction statique peut bien appeler une fonction non statique de la même classe.

Non, certainement pas. Une fonction statique n'est pas liée à une instance de la classe, si une fonction statique était capable d’appeler directement une fonction non statique, quelle instance devrait-elle choisir !?

En clair, que ferait 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
struct C
{
   int i ;
   void A(){ i = 2}
   void StaticA(){A();}
}
 
int main()
{
   C c1, c2, c3;
   C::StaticA();
}

Une fois appelé StaticA(), quelles seraient les données membres "i" mises à jours ? Celles de c1, de c2 ou de c3 ? Aucune ? Tous les i de toutes les instances de C dans tous le programme ?

[jackk]

Parfait!

Merci à vous.

[Klaim]

Une derniere note:

dans le cas ou on penserai a une fonction statique privee, si la classe n'est pas definie entierement dans un header, j'ai tendance a plutot utiliser une fonction dans un namespace anonyme dans le cpp:

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
 
// header
class Machin
{
public:
 
     void do_it();
 
};
 
 
// cpp
 
namespace 
{
 
     int computation( int k )
     { 
            //...
     }
 
} 
 
 
void Machin::do_it()
{
     int u = 42;
     //.... 
     auto z = computation(u);
 
     //....
}

Pourquoi?

1. (si j'ai bien compris) le namespace anonyme garanti que tout ce qu'il y q dedans n'est pas visible a l'exterieur de l'unite de compilation (le cpp), du coup c'est encore plus isole que si c'etait un membre prive, puisqu'il n'apparait pas dans le header et ne genere pas de symbole utilise au link.
2. je peu changer la signature de tout ce qui n'est visible que dans le cpp autant que je veux sans impacter le reste du code, meme sans toucher le header, ce qui est bien moins de travail que si c'etais des membres prives ou pas.

Le seul souci c'est que cela ne s'applique que aux classes ou l'on peut isoler la definition, donc pas les templates, et pas les fonctions qui doivent etre accessible par les classes enfant.
dans ces dernier cas, la fonction statique prive semble une bonne solution pour eviter de rendre la fonction accessible aussi a l'exterieur, tout en exposant tout son code.

[Neckara]

Le seul souci c'est que cela ne s'applique que aux classes ou l'on peut isoler la definition, donc pas les templates, et pas les fonctions qui doivent etre accessible par les classes enfant.

Si la méthode doit être accessible via une classe enfant, ce ne sera plus une méthode privée mais plutôt une méthode protected (?)

Tu ne voulais pas plutôt dire accessibles aux classes amies?

[Klaim]

Si la méthode doit être accessible via une classe enfant, ce ne sera plus une méthode privée mais plutôt une méthode protected (?)

Tu ne voulais pas plutôt dire accessibles aux classes amies?

Les deux!