Discussion :

[Rimidalv]

Bonjour,
Reste une fuite de mémoire après la fin du programme?
Merci
Pointer ?
COBOL Programer

[bacelar]

Ca dépend ce qu'on appelle fuite, et ce qu'on appelle mémoire.

La valeur de retour de l'exécution d'un programme, c'est une fuite ou pas ?
Une mémoire partagée entre 2 processus, c'est de la mémoire ou pas ?
Fin de programme, c'est à la sortie de la fonction point d'entré du programme ou lorsque le Kernel récupère la mémoire du descripteur du processus ?

etc...

Pointer quoi ?

En plus c'est très variable, en fonction de l'OS, pas du langage C++.

Pouvez-vous être plus spécifique, SVP ?

[Rimidalv]

Ca dépend ce qu'on appelle fuite, et ce qu'on appelle mémoire.

La valeur de retour de l'exécution d'un programme, c'est une fuite ou pas ?
Une mémoire partagée entre 2 processus, c'est de la mémoire ou pas ?
Fin de programme, c'est à la sortie de la fonction point d'entré du programme ou lorsque le Kernel récupère la mémoire du descripteur du processus ?

etc...

Pointer quoi ?

En plus c'est très variable, en fonction de l'OS, pas du langage C++.

Pouvez-vous être plus spécifique, SVP ?

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
class Je{
	int x;
	Je* nous;
public:
	Je(int xx) : x{ xx } {
		 nous = new Je(3);   // ?
	}
	~Je() { /* delete nous;*/ }
	int get_x();
	Je& get_nous();
	friend std::ostream& operator<<(std::ostream& os, Je&);
 
};
std::ostream& operator<<(std::ostream& os, Je* nou) {
	os << "nous: " << nou->get_x() << std::endl;
	return os;
}
Je& Je::get_nous() {
	return *nous;
}
int Je::get_x() {
	return x;
}
 
int main() {
	Je *ich = new Je(5);
	std::cout << ich->get_x() << std::endl;
	//delete ich; ?
	//ou
	std::cout << ich->get_nous();	//?
}

[Rimidalv]

La fuite de données a-t-elle quelque chose à voir avec la RAM? Cela restera-t-il pour toujours? Heap?

[dalfab]

Bonjour,

Une fuite mémoire est une perte pendant que l'application s'exécute. Dés que l'application se termine toute la mémoire utilisée (y compris celle "perdue") est rendue au système.

Ton programme a en effet bourré de fuites mémoires. A chaque new doit correspondre exactement un delete.
Il existe pourtant un moyen simple pour ne pas avoir de fuite, il suffit de ne jamais jamais utiliser new. Il existe des tas de moyens pour cela. Par exemple le code peut devenir:

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
class Je {
	int  x;
	std::unique_ptr<Je>  nous;
public:
	Je(int xx) : x{xx} {
		 nous = std::make_unique<Je>(3);
	}
	~Je() = default;
	int  get_x()const;
	Je const&  get_nous()const;
	friend std::ostream&  operator<<(std::ostream&, Je const&);
};
std::ostream&  operator<<(std::ostream& os, Je const& nou) {
	os << "nous: " << nou->get_x() << std::endl;
	return  os;
}
Je const&  Je::get_nous()const {
	return  *nous;
}
int  Je::get_x()const {
	return  x;
}
 
int  main() {
	auto  ich = std::make_unique<Je>(5);
	std::cout << ich->get_x() << std::endl;
	std::cout << ich->get_nous();
}

Mais ce code, comme le tiens, va tenter de créer une infinité de Je. Car créer un Je demande à créer un Je qui demande à créer un Je qui demande à créer un Je qui ...

[bacelar]

@dalfab simplifie un peu la chose.

Mais comme le PO semble un peu "un pied tendre" dans le domaine, il a peut-être raison de faire comme ça.

Dans un OS "moderne grand public", ce que fait décrit @dalfab est plutôt la norme.

Mais attention "fuite de mémoire" et "fuite de données" n'ont de rapport que de manière très très indirecte.

@Rimidalv, votre code, en plus d'être complètement bogué (cf. message de @dalfab) est un mélange de vieux code très archaïque (utilisation de pointeur nus) et de pratiques relativement récentes (initialisation via accolade).
Je vous conseille de n'utiliser que des sources qui n'utilisent que du codage moderne, pour ne pas avoir à gérer des problèmes qui ne le sont plus ou beaucoup moins présents avec les "nouvelles" pratiques.

Les cas les plus communs de fuite mémoire sont largement réduits en utilisant les smart-pointers, comme avec le code de @dalfab.

"fuite de mémoire" : moins lié à la RAM (composant physique), que lié à "l'encombrement" de l'espace d'adressage du processus, on peut très bien "encombrer" l'espace d'adressage sans utiliser plus de RAM (mémoires partagées, fichiers mappés en mémoire, etc...)

Cela restera-t-il pour toujours?

Au niveau mémoire vive, pas grand-chose ne résiste au Saint Redémarrage.

Heap?

Quand vous ne faites pas d'allocations "automatiques", oui c'est plutôt le (ou un, c'est paramétrable) tas (heap) qui est utilisé plutôt que la pile (stack).

En tant que programmeur aguerri (cf. COBOL Programer), vos questions semblent un peu candides.
Peut-être que des questions plus précises seraient plus "efficaces".

[Rimidalv]

Merci &bacelar & @dalfab,
Merci, j’ai appris C ++ avec Thinking in C++ Volume II, et mes connaissances sont pleines de trous.

[Rimidalv]

Merci beaucoup, Merci, cela m’a beaucoup aidé.

[Rimidalv]

Il est également possible d'utiliser les deux variantes. Bonne nuit.