c++

Mémoire et allocation

Variable globale
- Déclarée en dehors de tout bloc d’instruction
- Visible dans tout le fichier (en dessous d’elle)
- Peut être visible à l’extérieur du fichier avec extern
Variable locale
- Déclarée dans un bloc d’instructions
- Détruite immédiatement après le bloc ou conservées si déclarée avec static
- Visibilité dans le bloc uniquement (si static, peut être accessible via un pointeur)
- “Normale”
  - Créée sur la pile (stack)
  - Gérée automatiquement
Allocation Dynamique
- Créée sur le tas (heap)
- Créée avec les fonctions :
  - ::operator new(n)
    - cherche et trouve n octets consécutifs non utilisés dans la mémoire
    - retourne un pointeur vers le premier octet
  - new (ptr) T()
    - Attention : T n’est pas forcément initialisé à ce stade
    - Échoue si la mémoire n'est pas allouée préalablement
  - new(T()) fait les deux opérations précédentes dans l’ordre
- Détruites avec les fonctions :
  - ::operator delete(ptr) libère les n octets alloués à partir du pointeur ptr
  - ptr->~T() ou std::destroy_at(ptr) - détruit l’objet T pointé par ptr
  - delete ptr fait les deux opérations précédentes dans l’ordre inverse
- Gérées “manuellement”
Les variables de portée de classes / attributs / membres de données
- “Normales”
  - Déclarés (puis initialisés ou non) lors d’une instanciation d’une classe
  - Accès en lecture / écriture dans toutes les fonctions membres de l’instance à laquelle elles appartiennent
  - Accès depuis l’extérieur via l’instance avec .variables ou .fonction() si déclarée sous public:
  - Durée de vie identique à celle de son instance
- Statiques
  - Définies une seule fois en dehors de la classe (ou dans la classe avec le préfixe inline)
  - Accès depuis l’extérieur via l’instance avec .variables ou .fonction() si déclarée sous public:
  - Accès via la classe avec Classe::variable ou Classe::fonction()
  - Vit généralement tout le long du programme
Masquage (shadowing)
- Si une variable est déclarée avec le même nom qu’une autre variable en dehors du bloc, elle masque la variable hors du bloc.
- Les deux variables coexistent et sont conservées, mais à l’appel, seule la dernière déclarée est accessible.
- Uscase : fonctions récursives.

Liens (foireux) entre C et C++

C	C++	tâche
malloc()	::operator new(n)	Allocation de mémoire "brute"
calloc()		(calloc() c'est malloc() avec 2 arguments...)
memset()	new(ptr) T()	Initialisation de valeurs dans les octets alloués
memcopy()
free()	::operator delete(ptr)	Libération de octets alloués

Portée		Allocation	Durée de vie	Visibility
Life	int a;	Data segment	Program	All
static int a;	Data segment	Program	Fichier
new int a;	Heap	Manual	Fichier via ptr
extern int a;
Local	{ int a; }	Stack	Bloc	Bloc
{ static int a; }	Data segment	Program	Bloc
{ new int a; }	Heap	Manuel	Bloc via ptr
{ extern int a; }

				16
0000
uint8_t	char		0x41	256
0100 0001
uint16_t	short		0x0000	65'536
0000 0000 . 0000 0000
uint32_t	int			4 mrd
1100 0000 . 1010 1000 . 0000 0000 . 0000 0001
uint64_t	long long
0000000000000000000000000000000000000000000000000000000000000000

	sign exponent mantissa
float	1 8 23 - 0 1000000 0 1001001 00001111 11011011	\[ \gray{±}10^{\gray{±}38} \]
double	1 11 52 - 0 1000000 0000 1001 00100001 11111011 01010100 01000100 00101101 00011000	\[ \gray{±}10^{\gray{±}308} \]

type	\[ 2^{mantissa + 1} \]		char	short	int	long long
float	\[ 2^{23 + 1} \]	16'777'216	✔	✔
double	\[ 9^{52 + 1} \]	\[ \sim 9^{15} \]	✔	✔	✔

a = 0x1234, short, 2 bytes
b = 0x11223344, int, 4 bytes
c = 0x56, char, 1 byte
adresses en 8 bytes

index			0	1	2	3	4
vector			'M'	'i'	'n'	'e'	't'
value		v.front()				v.back()
iterator		v.begin()					v.end()
iterator	v.rend()					v.rbegin()

Adresse	Valeur du byte	Variable
0x1af47ffee4933868	0x12	a(1)
0x1af47ffee4933869	0x34	a(2)
0x1af47ffee493386a	0x11	b(1)
0x1af47ffee493386b	0x22	b(2)
0x1af47ffee493386c	0x33	b(3)
0x1af47ffee493386d	0x44	b(4)
0x1af47ffee493386e	0x56	c

item	sigle associé	possibilité	exemple
Adresse	&	Accès en lecture via &a ou p	0x1af47ffee4933868
Valeur	*	Accès en lecture et/ou écriture via a ou *p	0110 1000 0010 1010

temps	instruction	0x12	0x13	0x14	0x15	0x15
t1	int a = 10;	10	-	-	-	-
t2	int* p = &a;	10	0x12	-	-	-
t3	*p = 7;	7	0x12	-	-	-
t4	int b = 12;	7	0x12	12	-	-
t5	a = 99;	99	0x12	12	-	-

temps	instruction	0x12	0x13	0x14	0x15	0x16
t1	int a = 10;	(a) 10	-	-	-	-
t2	int* p = &a;	(a) 10	(*p) 0x12	-	-	-
t3	*p = 7;	(a) 7	(*p) 0x12	-	-	-
t4	int b = 12;	(a) 7	(*p) 0x12	(b) 12	-	-
t5	a = 99;	(a) 99	(*p) 0x12	(b) 12	-	-
t6	const int c = 5;	(a) 99	(*p) 0x12	(b) 12	■ (c) 5	-
t7	int* const q = &b;	(a) 99	(*p) 0x12	(b) 12	■ (q) 0x14	■ (c) 5
t8	*q = 15;	(a) 99	(*p) 0x12	(b) 15	■ (q) 0x14	■ (c) 5
t9	int& r = a;	(a r) 99	(*p) 0x12	(b) 15	■ (q) 0x14	■ (c) 5
t10	r = 20;	(a r) 20	(*p) 0x12	(b) 15	■ (q) 0x14	■ (c) 5

notes Arthur sur C++

Mémoire et allocation

Variable globale

Variable locale

Allocation Dynamique

Les variables de portée de classes / attributs / membres de données

Masquage (shadowing)

Liens (foireux) entre C et C++

Scope

Iterators

Types

Integer to Real lossless conversion

Exemple de structure de mémoire

Références et pointeurs

Exemple de l'évolution de l'état d'un système 2

Pointeurs

Note	et	ont exactement le même comportement
int a = 1; int& b = a;	Un grand bateau	le sens est le même
int b = 1; int& a = b;	Un bateau grand	le sens est le même

a	*p	explication
const int a;	const int* const p = &a;	Rien ne peut changer
_____ int a;	const int* const p = &a;	La variable peut être modifiée mais pas via le pointeur
const int a;	const int* _____ p = &a;	Le pointeur peut être redirigé mais ne peut pas modifier la valeur de l’entier constant
_____ int a;	const int* _____ p = &a;	Le pointeur peut être redirigé et ne peut pas modifier pas la valeur de l’entier qui peut être modifiée ailleurs.
const int a;	_____ int* const p = &a;	Un pointeur vers un entier non constant ne peut pas pointer vers une constante.
_____ int a;	_____ int* const p = &a;	Un pointeur constant vers un entier modifiable ne peut pas être redirigé mais peut modifier la valeur pointée.
const int a;	_____ int* _____ p = &a;	Un pointeur modifiable vers un entier non constant ne peut pas pointer vers une constante.
_____ int a;	_____ int* _____ p = &a;	Tout est modifiable.