C'est un algorithme utilisé pour vérifier l’existence d’un élément, la position d’un élément, ou le nombre d’éléments selon un critère dans un tableau, liste, fichier, etc.
10 éléments.
int * tab = new int[10];
O(log(n)).
1) De temps 2) D’espace
Utilisez '*tab[i] = valeur;' après avoir alloué de la mémoire avec 'new'.
On utilise l'opérateur d'accès « . » pour accéder aux méthodes ou propriétés, par exemple : e.attaquer();
L'allocation dynamique en C++ permet de réserver de la mémoire pendant l'exécution d'un programme, plutôt qu'à la compilation.
Habituellement, la classe qui alloue la mémoire s'occupe de la libérer.
Le tri par sélection est considéré comme le pire algorithme car il compare systématiquement toutes les entrées restantes à chaque tour.
Il faudra mettre les parenthèses lors de l'allocation dynamique.
pData reçoit l'adresse du premier élément du tableau.
Le destructeur est appelé à la sortie d'une méthode lorsque la mémoire de la variable locale est libérée.
La zone allouée aux données se décompose en plusieurs zones.
Dans un contexte où la mémoire n’est pas vraiment un obstacle.
On utilise l'instruction 'delete' suivie du pointeur, par exemple: delete ptrEnnemi.
Les principaux types d'algorithmes de tri incluent le tri à bulles, le tri par insertion, le tri par sélection, le tri fusion et le tri rapide.
Tri fusion, tri rapide, etc.
La mémoire est consécutive en mémoire comme un tableau standard.
1) Stocker des références vers des entiers : int * tab[10]; int a = 12; tab[0] = &a;
Le nombre d’opérations élémentaires effectuées par un algorithme.
L'étoile est utilisée pour accéder à la valeur pointée par le pointeur, ce qui est crucial pour éviter des erreurs.
Les données doivent être triées.
Habituellement, on ne touche pas à cette référence, on laisse la stack faire son travail !
Il apparaît en haut à gauche dans la vidéo mentionnée.
C'est un tableau statique de 10 pointeurs vers des entiers.
La formule est n(n-1)/2, ce qui indique une complexité quadratique.
La classe « A » possède un pointeur sur un objet de la classe « B » parmi ses attributs mais n’est pas responsable de la destruction de celui-ci.
Tout est sur la stack.
45 comparaisons
Le fichier .cpp contient la définition de la classe, incluant les définitions des attributs statiques et le corps des méthodes.
Contrairement à C# et Java, C++ nécessite deux fichiers pour séparer les déclarations (dans le fichier .h) des définitions (dans le fichier .cpp).
valeurDeA aura la même valeur que 'a', soit 52.
Un pointeur est une adresse qui stocke l'emplacement d'une variable en mémoire.
On peut réaliser des exercices tels que la création de tableaux dynamiques, la gestion de classes avec des pointeurs, et l'implémentation de destructeurs pour éviter les fuites de mémoire.
Les trois visibilités sont : public, protected et private.
C'est un algorithme récursif qui implique des opérations de scindage, de tri et de fusion.
Comparaison, Affectation, Opérations arithmétiques.
Elle alloue un bloc mémoire pouvant contenir un entier et la variable p reçoit l'adresse du premier octet de ce bloc.
Les algorithmes de tri sont classés en deux catégories : les lents et les rapides.
Algorithmes de tri.
O(n), exemple : Tri par sélection.
Le destructeur est une méthode spéciale préfixée du symbole « ~ » qui est appelée avant la suppression définitive de l'instance en mémoire.
Utiliser une boucle détruit la structure puisque la désallocation doit être consécutive.
La mémoire allouée par 'new int' n'est pas libérée, ce qui cause une fuite de mémoire.
Par valeur et par référence.
Les variables locales sont stockées dans la 'stack'.
Mettre le pointeur à nullptr ne libère pas la mémoire et peut provoquer une fuite de mémoire.
Le code compilé se trouve dans la section 'code'.
Cela ne libérera que le premier élément du tableau et créera une fuite de mémoire.
O(n), exemple : Recherche linéaire.
'cptInstance' est une variable statique qui est partagée entre toutes les instances de la classe Ennemi et est stockée dans la zone de données.
Les membres sont accessibles à l’extérieur et à l’intérieur de la classe.
Cette instruction ne fonctionne pas ici car elle était valide uniquement lorsqu'on avait l'adresse du premier octet vers un tableau dynamique.
La complexité de la fusion de deux ensembles est O(n), ce qui signifie qu'elle s'effectue en n opérations.
Chaque instruction 'new' crée une nouvelle instance de la classe Ennemi.
Non, un algorithme peut être 'compliqué' comme un algorithme récursif, mais avoir une faible complexité.
Chercher la valeur telle que : 2 x = N, en doublant nos unités jusqu’à l’obtention du nombre N.
Ennemi * prtEnnemi = new Ennemi();
O(n*log(n)), exemple : Tri fusion.
Elle reçoit l'adresse du premier bloc de la structure de la classe Ennemi.
L'objet Ennemi est détruit et le destructeur de la classe Ennemi est appelé.
On peut utiliser un tableau de pointeurs, par exemple : int * tab[10]; puis allouer dynamiquement avec tab[0] = new int; et assigner une valeur avec *tab[0] = 12.
Cela appelle la méthode attaquer() sur la première instance de la classe Ennemi dans le tableau.
La variable tabEnnemis reçoit l'adresse du premier bloc alloué en mémoire.
Il faut suivre les règles pour le stockage et la suppression des blocs alloués.
O(n*log(n)), ce qui indique une complexité linéarithmique.
'e1' est un pointeur vers un objet de la classe Ennemi, alloué dynamiquement dans le Tas.
O(log(n)), exemple : Recherche dichotomique.
Un objet est une 'instance' d’une classe, représentant un élément tangible, par exemple, Fido est un objet de la classe Chien.
Illustrer le comportement désiré et fournir des indices précieux sur le design à effectuer.
Le tri-fusion est un algorithme de tri qui divise les données en sous-ensembles, les trie individuellement, puis les fusionne pour obtenir un ensemble trié.
Des adresses vers des instances de la classe Ennemi.
La complexité se joue au niveau des comparaisons, des affectations et de l'arithmétique.
On utilise l'opérateur [] avec la syntaxe : int* pData = new int[10];
Ennemi * tabEnnemis[10];
L'opérateur d'accès est « -> ».
'int tab[10];' est un tableau statique de 10 entiers, tandis que 'int * tab[10];' est un tableau statique de 10 pointeurs vers des entiers.
À la sortie de la méthode, la stack est libérée des variables locales, et le destructeur de la classe correspondante est appelé.
Avec le symbole 'O'.
L'exécution va s'arrêter avec une erreur de mémoire.
O(n).
0x00effc08
*((unsigned char *)&a)
La variable 'nombre1' est stockée dans la zone de données, car elle est déclarée globalement.
Un attribut, aussi appelé membre ou propriété d’une classe, contient un élément d’information d’une classe (dans une variable).
Utilisez 'delete tab[j];' pour chaque élément après utilisation.
La complexité est relative au contexte ; par exemple, sur une plateforme avec peu de mémoire, les algorithmes seront plus complexes que sur une plateforme avec plus de ressources.
Une classe garde la référence d’une autre classe dans une de ses variables, et on ne touche pas à cette référence, laissant la stack faire son travail.
Le nombre de comparaisons effectuées est un critère de performance très important.
&a est la référence (l’adresse) du premier octet de la structure (ici, un entier).
On utilise la syntaxe : delete [] tab;
Le destructeur de la classe Ennemi est appelé lorsque l'objet est supprimé avec 'delete ptrEnnemi'.
L'exécution va planter car tab[0] ne réfère pas à une allocation dynamique.
Le pointeur est dépilé de la 'stack' lors de sa fin de vie, aucune trace ne reste en mémoire.
On peut l'exprimer comme n².
On obtient deux emplacements mémoire distincts contenant les mêmes valeurs.
En utilisant l'opérateur &.
O(n*log(n)).
O(n^2), exemple : Tri par sélection.
L'emplacement mémoire de 'a', également appelé un pointeur vers 'a'.
Une classe est une structure regroupant les données (attributs ou membres) et les opérations (méthodes) pour un concept donné.
Les principales zones de mémoire sont la Pile (Stack) pour les variables locales, le Tas (Heap) pour l'allocation dynamique, le Code (code segment) pour le code compilé, et les Données (Data segment) pour les variables globales et statiques.
Lorsque l'on démarre un programme, le système d'exploitation alloue un espace mémoire pour notre programme.
On peut utiliser 'int * tab[10];' suivi de 'tab[i] = new int;' pour chaque élément.
dichotomique
L'opérateur « * » est utilisé pour affecter une valeur du type qui a été déclaré.
Ceci représente un tableau dynamique de 10 entiers, où 'a' est un pointeur vers le premier octet de la structure d'entiers.
1) Une classe garde la référence d’une autre classe dans une de ses variables. 2) Une classe alloue dynamiquement une autre classe et stocke l’adresse reçue dans une variable.
Recherche linéaire et recherche dichotomique.
O(n*log 2 (n))
Utiliser un algorithme moins gourmand en espace mémoire mais plus complexe en temps.
Il désigne l'efficacité d'un algorithme et non la complexité de son implémentation.
int * tab = new int[10];
Le bloc contient une donnée invalide, souvent appelée 'junk'.
Elle alloue dynamiquement 10 blocs consécutifs pour des entiers en mémoire et la variable tab reçoit l’adresse du premier bloc.
Plus un algorithme est complexe, moins il est efficace.
Les adresses mémoire sont utilisées pour accéder aux emplacements de mémoire où les données sont stockées, permettant ainsi la manipulation de ces données.
Une classe alloue dynamiquement une autre classe et stocke l’adresse reçue dans une variable, et la classe qui alloue la mémoire s’occupe de la libérer.
tabEnnemis[0] -> attaquer();
Tri par sélection, tri par insertion, tri à bulles, etc.
Un algorithme de recherche est une méthode utilisée pour trouver un élément spécifique dans une structure de données, comme une liste ou un tableau.
Des pointeurs vers des instances de la classe Ennemi.
O(n^2), exemple : Tri par sélection.
La complexité est O(log 2 (n)).
On utilise la syntaxe : int * tab = new int[10];
La recherche s’effectue linéairement si les éléments ne sont pas triés.
C'est un algorithme qui divise un ensemble en deux jusqu'à isoler la valeur cherchée.
On s'attarde au pire cas que l'algorithme peut rencontrer.
p est une variable de type adresse pouvant recueillir la référence (adresse) d’un entier stocké en mémoire.
--- - ----- >
Il faut suivre les règles pour le stockage et la suppression.
Le nombre d’espace physique (essentiellement de la mémoire) occupé par l’algorithme.
Une fonction ou une méthode qui alloue de la mémoire est généralement responsable de la libérer.
Elle alloue dynamiquement de la mémoire pour un entier et assigne l'adresse à un pointeur 'p'.
Pour éviter les fuites de mémoire en libérant la mémoire qui a été allouée dynamiquement.
Il permet d'accéder à la valeur à une adresse mémoire.
Un tableau de pointeurs est une structure de données qui contient des adresses de mémoire pointant vers d'autres variables ou objets.
O(n*log(n)), exemple : Tri fusion.
La complexité de l'opération de scindage est O(log 2 n).
L'instruction 'p = &a;' assigne à p l'adresse de la variable a.
En utilisant la syntaxe : Ennemi * ptrEnnemi = new Ennemi();
Dans l'agrégation, la classe « A » ne détruit pas l'objet de la classe « B », tandis que dans la composition, la classe « A » est responsable de la destruction de l'objet de la classe « B ».
On utilise l'opérateur []. Par exemple, std::cout << pData[4]; est équivalent à std::cout << *(pData + 4);
La complexité dans le pire cas est de O(n), ce qui signifie qu'il faut n comparaisons.
45 comparaisons
O(log(n)).
Le destructeur d'une classe est une méthode spéciale qui est appelée lorsque l'objet est détruit, permettant de libérer les ressources allouées dynamiquement.
On utilise l'opérateur new : 'int* pData = new int;'.
Les membres sont accessibles dans les classes dérivées et à l’intérieur de la classe.
Le pointeur peut être réutilisé pour un autre emplacement mémoire, mais le contenu pointé devient indéterminé.
Le degré du polynôme est 2.
C'est équivalent à *(ptrEnnemi).attaquer();
tab[9] vaut 19.
Il ne s'agit pas de pointeurs, mais d'un tableau d'instances de la classe Ennemi.
Cela libère la mémoire qui a été allouée dynamiquement pour l'entier pointé par 'p'.
Avec le symbole 'O'.
0
On utilise l'opérateur * : par exemple, 'std::cout << *pData;' ou '*pData = 80;'.
Les membres sont accessibles uniquement à l’intérieur de la classe.
Elle prépare 10 instances de la classe Ennemi en mémoire.
9 comparaisons
La mémoire utilisée pour 'ptrEnnemi' est la heap, car l'objet est créé avec 'new'.
Il est crucial de supprimer les adresses pour éviter les fuites de mémoire, car chaque pointeur dans le tableau pointe vers un bloc de mémoire alloué dynamiquement.
Les variables statiques et globales sont stockées dans la 'data'.
4 octets
Les zones mémoire allouées sont : Pile pour les variables locales comme nombre2 et nombre3, Tas pour l'objet e1 créé avec 'new Ennemi', et Code pour le code de la fonction UneFonction et main().
La variable 'nombre3' a une portée locale à la fonction UneFonction.
Il faut libérer la mémoire allouée avec l'opérateur delete lorsqu'elle n'est plus nécessaire.
Il est recommandé de coder les get/set pour tous les attributs et de rendre private les setters qui ne sont pas nécessaires à l’extérieur de la classe.
Utiliser une boucle for pour assigner des valeurs, par exemple : for(int i = 0; i < 10; i++) { tab[i] = i + 10; }
tab[0] vaut 10.
La recherche linéaire consiste à parcourir le tableau au complet, c'est un algorithme glouton.
O(n^2), ce qui correspond à une complexité quadratique.
C'est parce que l'indice correspond au décalage par rapport à l'adresse du tableau.
Cela rend le pointeur 'p' nul, ce qui peut aider à éviter des accès à une mémoire déjà libérée.
L'allocation dynamique d'une classe en C++ se fait généralement à l'aide de l'opérateur 'new', qui réserve de la mémoire pour un objet de la classe à l'exécution.
La valeur de pValeur sera celle de ptrA augmentée de 4 octets, car un int occupe 4 octets en mémoire.
Une méthode est une opération d’une classe, contenant du code, et on évite les termes fonctions et procédures.
Un tri préalable permet de gagner en performance sur l'algorithme de recherche.
Le fichier .h contient la déclaration de la classe, incluant le nom de la classe, les modificateurs de visibilité, et les déclarations des attributs et des méthodes, sans les définitions.
Avec le symbole 'O'.
n(n-1)/2 comparaisons
O(n), ce qui indique une complexité linéaire.
En transtyant l'adresse de la variable en pointeur de caractères (unsigned char*)
En configuration x86, un pointeur est stocké sur 32 bits.
Le contenu est indéterminé.
Pour savoir combien d'octets allouer en mémoire.
En utilisant la syntaxe : Ennemi * tabEnnemis = new Ennemi[10]; pour allouer 10 blocs consécutifs en mémoire.
L'objet de la classe « B » est généralement instancié à l’intérieur de la classe « A », souvent lors de la construction.
O(n²), ce qui indique une complexité quadratique.
On doit utiliser l'opérateur delete avec []. Par exemple, delete[] pData; et non delete pData;
O(log(n)).
La composition dans un diagramme de classes représente une relation forte entre deux classes, où une classe (le tout) contient des instances d'une autre classe (les parties).
C'est le fait de masquer les détails d'implémentation d'un concept (d'une classe).
