Discussion :

[cosmoff]

Bonjour,
voila quand on sort d'une fonction, toutes les variables créent dans cette fonction sont détruites, mais pourquoi on les détruit ? juste pour optimiser l'espace mémoire dans la RAM ?
et ma deuxieme question via ce code tres simple :

Code :

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

1
2
3
4
5
6
7
8
9
10
int plusDeux(int i){
	return i+2;
}
 
int main(int argc, char const *argv[])
{
	int a = 55;
	a = plusDeux(a);
	cout <<"la valeur de a est : "<<a<<endl;
}

quand mon processeur va dans la fonction plusDeux(int), vu qu'il sort de la fonction main(), alors toute les variables dans le main donc la variable 'a' devrait etre détruit et donc en sortie de la fonction plusDeux(int), mon processeur détruit la variable 'i' et mon processeur ne devrait plus savoir combien valait 'a' car elle a été détruit pourtant si :s

Merci d'avance pour vos éclaircissement

[Matt_Houston]

voila quand on sort d'une fonction, toutes les variables créent dans cette fonction sont détruites, mais pourquoi on les détruit ? juste pour optimiser l'espace mémoire dans la RAM ?

Je te retourne la question : pourquoi les conserverait-on ? Note que le terme détruire ici implique seulement de reculer le pointeur de pile (une zone mémoire exclusive à chaque thread), ce qui a pour effet de marquer l'espace réservé par la portée que l'on vient de quitter comme disponible. Exemple très simplifié :

Code :

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

1
2
3
4
5
6
7
8
9
10
void f() {
    // ici le pointeur de pile vaut.. mettons x
    int i; // i est alloué sur la pile, son adresse vaut x
    // le pointeur de pile vaut maintenant x + sizeof i
    {
        short j; // l'adresse de j vaut x + sizeof i
        // le pointeur de pile vaut maintenant x + sizeof i + sizeof j
    } // on sort du bloc où a été déclaré j qui est "détruit" : on dépile sizeof j octets
    // le pointeur de pile vaut maintenant x + sizeof i
}

quand mon processeur va dans la fonction plusDeux(int), vu qu'il sort de la fonction main(), alors toute les variables dans le main donc la variable 'a' devrait etre détruit et donc en sortie de la fonction plusDeux(int), mon processeur détruit la variable 'i' et mon processeur ne devrait plus savoir combien valait 'a' car elle a été détruit pourtant si :s

On ne sort pas de la fonction appelante, son exécution n'est pas terminée : on change de contexte.

Lorsqu'une fonction est appelée, on empile des informations de contexte sur la portée courante (toujours sur la même pile dont je causais précédemment) ainsi que les paramètres passés à la fonction appelée (dans ton cas, a) puis on déplace le pointeur d'instruction vers son code. Lorsque cette fonction termine, on dépile le contexte, on replace le pointeur d'instruction dans la fonction appelante et on reprend l'exécution du code qui suit l'appel.

On nomme habituellement cet enchevêtrement de contextes la pile d'appel (call stack). Un débugger permet de remonter cette pile à tout moment afin de consulter n'importe quel contexte parent.

[cosmoff]

Merci pour ta réponse très complète.

Voyons si j'ai bien compris :
quand je lance mon programme, alors tout mon programme va dans la RAM. chaque fonctions (c'est ce que tu appelles thread ?) lui est attribué une pile. Ainsi mon main() possède une pille et ma fonction plusDeux() possede une autre pile. Quand mon pointeur d'instruction arrive à la fonction plusDeux(), il fait un saut en mémoire pour arriver à l'adresse ou se trouve la fonction. le parametre 'a' qui était dans la fonction plusDeux( a ) est ajouté à la pile de ma fonction (int i = a). le processeur traite ma fonction, puis arrivant à la fin il déloue en mémoire la pile (donc les valeurs sont toujours écrit dans la case mémoire mais je ne peux juste plus y acceder ?), ainsi la pile est vide, puis il fait un saut dans la mémoire pour revenir a l'adresse mémoire du main() (plus précisément juste aprés la fonction plusDeux() puis modifie la variable 'a' a cause du return dans la pile du main().

est ce l'idée ?

[Pyramidev]

Ainsi mon main() possède une pille et ma fonction plusDeux() possede une autre pile.

Non. Dans ton exemple, les deux sont appelés pour la même pile.

Pour voir sous le capot, je conseille cette excellente suite d'articles : Programme d'étude sur le C++ bas niveau.
Ces articles montrent ce que devient le code C++ quand il est traduit en assembleur. Ils sont accessibles y compris pour les lecteurs qui n'ont jamais étudié l'assembleur.

[Matt_Houston]

Non : une fonction n'est qu'une suite d'instructions modulaire, qu'on revient visiter régulièrement avec un état de pile possiblement différent : adresse de la prochaine instruction dans la portée appelante, valeurs des paramètres..

Un thread est une séquence de l'exécution d'un programme avec des paramètres et un contexte propres à celle-ci. La notion de fonction n'intervient pas : on utilise une seule et même pile par thread.

Tu peux, par exemple, avoir deux threads qui exécutent en parallèle le même programme de calcul de la suite de Fibonacci, le premier jusqu'au dixième élément, le second jusqu'au millième élément. Ils lisent le même code (comme une recette) mais chacun son rythme, et lui font traiter des contextes distincts (comme des ingrédients).

EDIT: les excellents articles cités par Pyramidev contiennent notamment ce qu'il manque à ce fil : des diagrammes !

[Christophe]

Au niveau du C, tu n'as pas à te préoccuper de la pile.

Ce qui est important est de comprendre ce qui s’appelle la portée d'une variable.

Tu as les variables globales, déclarées en dehors des fonctions (en début de code source hors des fonctions)
Tu as les variables locales, le variables déclarées dans une fonction sont accessibles dans la fonction uniquement.

Les variables locales ne sont pas accessibles dans les fonctions appelées depuis une fonction. Par contre si tu fais un appel du genre

Code :

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

ma_fonction(valeur)

; et que le prototype de la fonction est

Code :

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

ma_fonction(int nombre)

, le contenu de "valeur" sera recopié dans "nombre", nombre étant accessible dans ma_fonction. C'est ce qu'on appelle un passage de paramètre par valeur ou recopie. "valeur" n'est pas accessible dans ma_fonction, tout comme sa copie "nombre" n'est accessible que depuis l'intérieur de ma_fonction.