Bonjour,

En révisant les initialisations d'attributs, je me suis rendu compte que l'on pouvait initialiser autrement que dans le constructeur de la classe, et à ma grande surprise, je me suis aperçu que la méthode fonctionne.

Voici le code qui compile sans problèmes :

#include <iostream>
using namespace std;

class MaClasse
{
public:
	static void afficheCompteur();
private:
	static const int compteur = 4;
};

void MaClasse::afficheCompteur()
{
	cout << "Nombre d'inscrits : " << MaClasse::compteur << endl;
}


int main()
{
	MaClasse::afficheCompteur();

	system("pause");
	return 0;
}

Et le résultat dans la console : 

Nombre d'inscrits : 4
Appuyez sur une touche pour continuer...

Merci pour vos explications sur le sujet, et quels sont les avantages ou inconvénients de cette manière de coder.

https://en.cppreference.com/w/cpp/language/static

Section "Constant static members"

>quels sont les avantages ou inconvénients de cette manière de coder.

"Les avantages ou inconvénients" par rapport à quoi ???

Un compteur "const", c'est conceptuel, non ?

Le seul "désavantage" que je vois, c'est using namespace std;

Ensuite, il n'y a rien de très nouveau ni d'exceptionnel dans ton code. Initialiser un attribut, c'est juste initialiser un état pour l'objet futur, comme on le ferait pour une variable (ou constante dans ce cas).

Le constructeur est utile pour initialiser des champs internes par rapport à des données externes, mais les attributs d'un objet ne sont pas nécessairement initialisés par le constructeur.

Il n'y a donc ni avantage ni inconvénient d'utiliser l'un ou l'autre. Si tu utilises le constructeur pour initialiser tous tes champs avec des valeurs connues du compilateur, c'est possible, mais ça ne sert à rien.

Utilise le constructeur lorsque tu as besoin que ton objet possède une instance dont l'état est propre à lui-même dès sa création en tant qu'objet.

Par exemple :

class Foo {
    private:
        int MyVar = 9;
};

Foo foo;

Ici, l'objet possède les mêmes caractéristiques (attributs) que la classe qui le définit.

class Foo {
    private:
        int MyVar;
    public:
        Foo(int value) { MyVar = value; }
};

Foo foo(9);

Par contre ici, l'objet possède un état différent que la classe qui le définit, et ce, grâce au constructeur.

Concernant le static, il n'est pas très utile dans ce cas-ci. On utilise static pour définir une donnée accessible sans posséder d'objet au préalable, ou, plus conceptuellement parlant, pour définir une variable (ou fonction) qui est connue par le compilateur, c'est-à-dire explicitement définie dans le programme (sinon on peut avoir des problèmes dans l'éditeur de liens). Le const, quant à lui, servira, pour la classe, à ne pas modifier cet état quel que soit l'endroit où la donnée constante sera utilisée, afin, dans ce cas-là, de ne pas avoir des instances différentes par objet si on modifie extérieurement l'attribut.

-
Edité par vanaur 13 septembre 2018 à 19:01:11

Merci pour vos réponses.

Ce qui m'étonnais, c'est que je pensais que l'initialisation se faisait seulement à l'intérieur du constructeur, et je ne comprenais pas pourquoi mon code compilait, d'où ma question. Vous m'avez donc appris que cela pouvait exister et être utilisé en fonction du besoin. Personnellement, je n'ai jamais rencontré cette manière de faire, ou alors je manque d'expérience... 

Pour ce qui est du static et du const,  ils ne sont pas pertinents pour cet exemple.

Merci encore.

-
Edité par Gabriel0111 13 septembre 2018 à 20:43:04

Attention quand même à un détail important, dans la vraie vie, c'est le constructeur qui va le plus souvent se charger d'initialiser les variables membres.

-
Edité par int21h 13 septembre 2018 à 23:55:53