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