Discussion :

[Smashmaster]

Bonjour/Bonsoir à tous, je suis nouveau sur ce forum .

J'ai une question concernant les attributs statiques.

J'ai une classe A qui possède un attribut statique 'stat_var'.

Code :

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

1
2
3
4
5
6
 
//fichier A.h
 
class A {
    static int stat_var;
};

Normalement les attributs d'une classe sont enregistrés dans la mémoire au moment où la classe est instanciée, mais étant donné que l'attribut est déclaré statique, on n'a pas besoin d'instancier la classe pour pouvoir accéder à l'attribut (il suffit juste de faire A::stat_var dans le main(), pas besoin d'instancier la classe A).

Voici mes questions :

Quand est-ce que les attributs statiques seront enregistrées dans la mémoire?
Quand est-ce que les attributs statiques seront supprimées de la mémoire?
Est-ce que les attributs statiques sont enregistrés dans la mémoire même si je m'en sers jamais dans le main() ?

Voilà, merci et bonne soirée à tous !

[Ekleog]

Bonjour/Bonsoir à tous, je suis nouveau sur ce forum .

Bonjour à toi de même ! Je profite de ce thread pour faire mon retour sur ces fora.

[...]

Quand est-ce que les attributs statiques seront enregistrées dans la mémoire?

Avant l'appel à la fonction main.

Quand est-ce que les attributs statiques seront supprimées de la mémoire?

Après la fin de la fonction main.

Est-ce que les attributs statiques sont enregistrés dans la mémoire même si je m'en sers jamais dans le main() ?

Oui. Il n'est en général pas gênant de perdre quelques octets pour un attribut statique. Il est possible d'utiliser de l'initialisation paresseuse dans le cas d'un objet lourd rarement utilisé, pour réduire à 4 octets (ou 8 sur un système 64 bits) le poids constant utilisé ; mais ça complique beaucoup le programme, en imposant une initialisation manuelle de la variable : (code non testé, et absolument non multi-thread : il faudrait initialiser manuellement la variable pour cela)

EDIT: Une meilleure proposition est exposée par Ehonn ci-dessous.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ma_classe {
  static std::unique_ptr<classe_lourde> obj_ = NULL;
public:
  static classe_lourde & obj() {
    if (!obj_) obj_ = new classe_lourde;
    return *obj_;
  }
  static classe_lourde const & obj() const {
    if (!obj_) *const_cast<std::unique_ptr<classe_lourde> *>(&obj_) = new classe_lourde;
    return *obj_;
  }
};
 
// Et on utilise ma_classe::obj() au lieu de ma_classe::obj

Voilà, merci et bonne soirée à tous !

En espérant ne pas m'être trompé, bonne soirée à toi !

Ekleog

[Ehonn]

Il est possible d'utiliser de l'initialisation paresseuse dans le cas d'un objet lourd rarement utilisé, pour réduire à 4 octets (ou 8 sur un système 64 bits) le poids constant utilisé ; mais ça complique beaucoup le programme, en imposant une initialisation manuelle de la variable : (code non testé, et absolument non multi-thread : il faudrait initialiser manuellement la variable pour cela)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class ma_classe {
  static std::unique_ptr<classe_lourde> obj_ = NULL;
public:
  static classe_lourde & obj() {
    if (!obj_) obj_ = new classe_lourde;
    return *obj_;
  }
  static classe_lourde const & obj() const {
    if (!obj_) *const_cast<std::unique_ptr<classe_lourde> *>(&obj_) = new classe_lourde;
    return *obj_;
  }
};

Tu réduis le poids uniquement si l'objet n'est pas utilisé. Ce poids n'est pas de 4 ou 8 mais de sizeof(void *), c'est-à-dire, la taille d'un pointeur (qui dépend du compilateur et de la machine).
Ta solution const n'est vraiment pas propre à mes yeux. Le développeur saura s'il doit fournir la version const ou non const.

Je préfère cette solution qui :
- empêche le fiasco dans l'ordre d'initialisation des variables statiques
- est thread-safe en C++11
- peut être header-only

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
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++98 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
 
 
class une_classe_t
{
public:
 
	static std::string const & static_string()
	{
		// Version simple
		//static std::string r = "une_classe_t::static_string()";
 
		// Version avec initialisation via une lamda fonction
		static std::string r = []() -> std::string
		{
			std::cout << "Création" << std::endl;
			return "une_classe_t::static_string()";
		}();
 
		return r;
	}
};
 
 
int main()
{
	std::cout << "Debut main" << std::endl;
 
	std::cout << une_classe_t::static_string() << std::endl;
	std::cout << une_classe_t::static_string() << std::endl;
 
	std::cout << "Fin main" << std::endl;
 
	return 0;
}

Voilà la sortie (le string est bien créé qu'une fois, au premier appel de la fonction)

Code :

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

1
2
3
4
5
Debut main
Création
une_classe_t::static_string()
une_classe_t::static_string()
Fin main

[Ekleog]

Tu réduis le poids uniquement si l'objet n'est pas utilisé. Ce poids n'est pas de 4 ou 8 mais de sizeof(void *), c'est-à-dire, la taille d'un pointeur (qui dépend du compilateur et de la machine).

Simplification excessive. J'ai quand même préféré indiquer le cas des machines 32- et 64-bits ; les plus courants et certainement un de ceux utilisés par l'OP.

Ta solution const n'est vraiment pas propre à mes yeux. Le développeur saura s'il doit fournir la version const ou non const.

Désolé, j'avais écrit par réflexe les deux versions typiques d'un accesseur -- mon erreur est par ailleurs affichée par l'emploi du qualificateur "const" sur une fonction "static"... Mea culpa

Je préfère cette solution qui :
- empêche le fiasco dans l'ordre d'initialisation des variables statiques

Mea culpa, essayant d'éviter au maximum les variables statiques non constantes, je n'ai même pas pensé à ce problème (par "non constantes", j'entends "qui ne sont pas des constantes numériques ou assimilées").

- est thread-safe en C++11

Pour ma défense, j'avais précisé que mon code n'est pas thread-safe.

- peut être header-only

[...]

Merci donc pour ces précisions !

Étant un peu rouillé, je suis désolé d'avoir donné des indications très largement imparfaites.

En espérant vite récupérer,

Ekleog

[Ehonn]

Simplification excessive. J'ai quand même préféré
Désolé
Mea culpa
Pour ma défense
Étant un peu rouillé, je suis désolé

Mon message n'a rien de personnel Je cherche juste à montrer la solution que j'utilise car je la trouve adapté à beaucoup de situations et simple.
Désolé si mon message était un peu trop formel :s (j'ai tendance à oublier qu'à l'écrit c'est plus facile de mal interpréter les "sentiments" d'un message).

[Ekleog]

À mon tour de m'excuser alors : j'ai certainement mal choisi mes termes, et ne m'étais pas senti attaqué. Je profitais juste de ces expressions pour exprimer que j'avais tort et toi raison.

Et les "Désolé" étaient adressés à l'OP.

Ça fait plus ou moins deux ans que j'ai à peine participé à des fora, il faudra donc que je me ré-habitue au ton qui convient.

En tout cas, j'espère que cela répond à tes questions, Smashmaster !

[Smashmaster]

Merci pour vos réponses très rapides Ekleog et Ehonn, et merci pour vos codes sources, j'ai tout compris maintenant .

Je marque le sujet comme résolu.

Bonne soirée à vous tous !

Smashmaster.

[Bousk]

Une fonction static ne peut pas être const

Le meilleur moyen et plus simple reste ainsi

Code :

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

1
2
3
4
5
template<class T>class Singleton
{
static T& Get() { static T t; return t; }
static T* Ptr() { return &Get(); }
};

la variable ne sera initialisée que si l'on utilise Get
on ne fait pas de new pour ne pas avoir à faire de Release

[Ekleog]

Une fonction static ne peut pas être const

Hmmm... Lecture trop rapide ? Je m'auto-cite :

Désolé, j'avais écrit par réflexe les deux versions typiques d'un accesseur -- mon erreur est par ailleurs affichée par l'emploi du qualificateur "const" sur une fonction "static"... Mea culpa