Quelle est la différence entre un objet et une structure dans la POO?
- Qu'est-ce qui distingue et objecte d'une structure?
- Quand et pourquoi utilisons-nous un objet plutôt qu'une structure?
- En quoi un tableau diffère-t-il des deux, et quand et pourquoi utiliserions-nous un tableau par opposition à un objet ou une structure?
J'aimerais avoir une idée de ce à quoi chacun est destiné.
Évidemment, vous pouvez brouiller les distinctions en fonction de votre style de programmation, mais généralement une structure est une donnée structurée. Un objet est une entité souveraine qui peut effectuer une sorte de tâche. Dans la plupart des systèmes, les objets ont un certain état et, par conséquent, des données structurées derrière eux. Cependant, l'une des fonctions principales d'une classe bien conçue est le masquage des données - exactement comment une classe réalise quoi qu'elle fasse est opaque et non pertinent.
Étant donné que les classes peuvent être utilisées pour représenter des structures de données classiques telles que des tableaux, des cartes de hachage, des arbres, etc., vous les voyez souvent comme des éléments individuels dans un bloc de données structurées.
Un tableau est un bloc de données non structurées. Dans de nombreux langages de programmation, chaque élément séparé d'un tableau doit être du même type de base (tel que chacun étant un nombre entier, chacun étant une chaîne ou similaire) mais ce n'est pas vrai dans de nombreux autres langages.
Comme lignes directrices:
- utiliser un tableau comme un endroit pour mettre un grand groupe de choses sans autre structure ou hiérarchie inhérente, comme "tous les reçus de janvier" ou "tout ce que j'ai acheté au Danemark"
- utiliser des données structurées pour composer plusieurs bits de données discrets en un seul bloc, comme vous pourriez vouloir combiner une position x et une position y pour décrire un point
- utiliser un objet où il y a un acteur ou une chose en particulier qui pense ou agit par lui-même
Le but implicite d'un objet est donc directement d'associer des tâches aux données sur lesquelles il peut fonctionner et de les regrouper de manière à ce qu'aucune autre partie du système ne puisse interférer. Le respect des principes de conception orientés objet appropriés peut nécessiter une discipline au début, mais améliorera en fin de compte massivement votre structure de code et donc votre capacité à s'attaquer à des projets plus importants et à travailler avec d'autres.
De manière générale, les objets apportent toutes les fonctionnalités orientées objet (méthodes, données, fonctions virtuelles, héritage, etc, etc.) alors que les structures ne sont que de la mémoire organisée. Les structures peuvent ou non prendre en charge les méthodes/fonctions, mais elles ne prennent généralement pas en charge l'héritage et les autres fonctionnalités complètes OOP.
Notez que j'ai dit en général ... les langues individuelles sont libres de surcharger la terminologie comme bon leur semble.
Les tableaux n'ont rien à voir avec OO. En effet, presque toutes les langues autour des tableaux de support. Les tableaux ne sont que des blocs de mémoire, contenant généralement une série d'éléments similaires, généralement indexables d'une manière ou d'une autre.
- Qu'est-ce qui distingue et objecte d'une structure?
Il n'y a aucune notion de "struct" dans la POO. La définition des structures dépend du langage utilisé. Par exemple, en C++, les classes et les structures sont identiques, mais les membres de la classe sont privés par défaut tandis que les membres de la structure sont publics pour maintenir la compatibilité avec les structures C. En C # d'autre part, struct est utilisé pour créer des types de valeur tandis que la classe est pour les types de référence. C a des structures et n'est pas orienté objet.
- Quand et pourquoi utilisons-nous un objet par opposition à une structure?
Encore une fois, cela dépend de la langue utilisée. Normalement, les structures sont utilisées pour représenter les POD (Plain Old Data), ce qui signifie qu'elles ne spécifient pas un comportement qui agit sur les données et sont principalement utilisées pour représenter des enregistrements et non des objets. Ceci est juste une convention et n'est pas appliqué en C++.
- Comment un tableau diffère-t-il des deux, et quand et pourquoi utiliserions-nous un tableau par opposition à un objet ou une structure?
Un tableau est très différent. Un tableau est normalement une collection homogène d'éléments indexés par un entier. Une structure est une collection hétérogène où les éléments sont accessibles par leur nom. Vous utiliseriez un tableau pour représenter une collection d'objets du même type (un tableau de couleurs par exemple) tandis que vous utiliseriez une structure pour représenter un enregistrement contenant des données pour un certain objet (une seule couleur qui a du rouge, du vert et éléments bleus)
Réponse courte: les structures sont des types de valeur. Les classes (objets) sont des types de référence.
De par leur nature, un objet a des méthodes, pas une structure.
(rien ne vous empêche d'avoir un objet sans méthodes, tout comme rien ne vous empêche, par exemple, de stocker un entier dans une variable de type flottant)
Les tableaux sont une collection ordonnée d'éléments qui (généralement) sont du même type. Les éléments sont accessibles par index. Les tableaux classiques n'autorisent que les indices entiers, mais les langages modernes fournissent souvent des tableaux dits associatifs (dictionnaires, hachages, etc.) qui permettent une utilisation par ex. chaînes comme indices.
La structure est une collection de valeurs nommées (champs) qui peuvent être de `` types différents '' (par exemple, champ a stocke des valeurs entières, champ b - valeurs de chaîne, etc.). Ils (a) regroupent les valeurs connectées logiquement et (b) simplifient le changement de code en masquant les détails (par exemple, la modification de la disposition de la structure n'affecte pas la signature de la fonction travaillant avec cette structure). Cette dernière est appelée "encapsulation".
Théoriquement, l'objet est une instance de structure qui démontre un certain comportement en réponse aux messages envoyés (c'est-à-dire, dans la plupart des langues, ayant certaines méthodes). Ainsi, la très utilité de l'objet réside dans ce comportement, pas dans ses champs.
Différents objets peuvent démontrer un comportement différent en réponse aux mêmes messages (les mêmes méthodes étant appelées), ce qui est appelé "polymorphisme".
Dans de nombreux langages (mais pas tous), les objets appartiennent à certaines classes et les classes peuvent former des hiérarchies (ce qui est appelé "héritage").
Étant donné que les méthodes d'objet peuvent fonctionner directement avec ses champs, les champs peuvent être masqués par n'importe quel code à l'exception de ces méthodes (par exemple en les marquant comme private). Ainsi, le niveau d'encapsulation pour les objets peut être plus élevé que pour les structures.
Notez que différentes langues ajoutent une sémantique différente à ces termes.
Par exemple.:
dans les langages CLR (C #, VB.NET, etc.)
structs sont alloués sur des registres stack/in et les objets sont créés en tas.en C++
structs ont tous les champspublicpar défaut, et les objets (instances de classes) ont tous les champsprivate.dans certains langages dynamiques, les objets ne sont que des tableaux associatifs qui stockent des valeurs et des méthodes.
Quand et pourquoi utilisons-nous un objet par opposition à une structure?
C'est une question clé. J'utilise des structures et des modules de code procédural pour fournir la plupart des avantages de la POO. Les structures fournissent la plupart des capacités de stockage de données des objets (autres que les propriétés en lecture seule). Les modules procéduraux fournissent une complétion de code similaire à celle fournie par les objets. Je peux entrer module.function dans le IDE au lieu de object.method. Le code résultant est le même. La plupart de mes fonctions renvoient maintenant des stucts plutôt que des valeurs uniques. L'effet sur mon code a été dramatique, la lisibilité du code augmentant et le nombre de lignes étant considérablement réduit. Je ne sais pas pourquoi la programmation procédurale qui fait un usage intensif des structures n'est pas plus courante. Pourquoi ne pas simplement utiliser la POO? Certains des langages que j'utilise ne sont que procéduraux (PureBasic) et l'utilisation de structures permettent de profiter de certains des avantages de OOP. D'autres langages permettent un choix de procédure ou OOP (VBA et Python) Je trouve actuellement plus facile d'utiliser la programmation procédurale et dans ma discipline (écologie), je trouve très difficile de définir des objets. Quand je ne peux pas comprendre comment regrouper des données et des fonctions ensemble en objets dans une collection philosophiquement cohérente, alors je n'ont pas de base pour créer des classes/objets. Avec les structures et les fonctions, il n'est pas nécessaire de définir une hiérarchie des classes. Je suis libre de mélanger les fonctions entre les modules ce qui m'aide à améliorer l'organisation de mon code au fur et à mesure. C'est peut-être un précurseur pour aller OO.
Le code écrit avec des structures a des performances supérieures à OOP code basé. OOP le code a l'encapsulation, l'héritage et le polymorphisme, cependant je pense que le code procédural basé sur la structure/fonction souvent partage ces caractéristiques. Une fonction renvoie une valeur uniquement à son appelant et uniquement dans la portée, réalisant ainsi l'encapsulation. De même, une fonction peut être polymorphe. Par exemple, je peux écrire une fonction qui calcule la différence de temps entre deux endroits avec deux algorithmes internes, une qui prend en compte la ligne de date internationale et une qui ne le fait pas. L'héritage se réfère généralement aux méthodes héritées d'une classe de base. Il existe un héritage de sortes avec des fonctions qui appellent d'autres fonctions et utilisent des structures pour le transfert de données. Un exemple simple est de transmettre une erreur via une pile de fonctions imbriquées. Au fur et à mesure que le message d'erreur est transmis, il peut être ajouté par les fonctions appelantes. Le résultat est une trace de pile avec un message d'erreur très descriptif. Dans ce cas, un messa ge hérité de plusieurs niveaux. Je ne sais pas comment décrire cet héritage ascendant (programmation événementielle?) Mais c'est une caractéristique de l'utilisation de fonctions qui renvoient des structures qui sont absentes de la programmation procédurale en utilisant des valeurs de retour simples. À ce stade, je n'ai rencontré aucune situation où OOP serait plus productif que les fonctions et les structures. La chose surprenante pour moi est que très peu de code disponible sur Internet est écrit ceci Cela me fait me demander s'il y a une raison à cela?
- Comme je le vois, un objet au niveau de base est un certain nombre de variables et un certain nombre de méthodes qui manipulent ces variables, tandis qu'un struct d'un autre côté n'est qu'un nombre de variables.
- J'utilise un objet lorsque vous voulez inclure des méthodes, j'utilise une structure quand je veux juste passer une collection de variables.
- Un tableau et une structure sont assez similaires en principe, ils sont tous deux un certain nombre de variables. Cependant, il est plus lisible d'écrire myStruct.myVar que myArray [4]. Vous pouvez utiliser une énumération pour spécifier les index de tableau pour obtenir myArray [indexOfMyVar] et obtenir essentiellement les mêmes fonctionnalités qu'une structure.
Bien sûr, vous pouvez utiliser des constantes ou autre chose au lieu de variables, j'essaie simplement de montrer les principes de base.
Cette réponse peut nécessiter l'attention d'un programmeur plus expérimenté, mais l'une des différences entre les structures et les objets est que les structures n'ont pas de capacité de réflexion alors que les objets le peuvent. La réflexion est la capacité d'un objet à rapporter les propriétés et méthodes dont il dispose. C'est ainsi que "l'explorateur d'objets" peut rechercher et répertorier les nouvelles méthodes et propriétés créées dans les classes définies par l'utilisateur. En d'autres termes, la réflexion peut être utilisée pour déterminer l'interface d'un objet. Avec une structure, je ne connais aucun moyen de parcourir les éléments de la structure pour savoir comment ils sont appelés, de quel type ils sont et quelles sont leurs valeurs.
Si l'on utilise des structures en remplacement d'objets, alors on peut utiliser des fonctions pour fournir l'équivalent des méthodes. Au moins dans mon code, les structures sont souvent utilisées pour renvoyer des données à partir de fonctions définies par l'utilisateur dans des modules qui contiennent la logique métier. Les structures et les fonctions sont aussi faciles à utiliser que les objets, mais les fonctions ne prennent pas en charge les commentaires XML. Cela signifie que je dois constamment regarder le bloc de commentaires en haut de la fonction pour voir exactement ce que fait la fonction. Souvent, je dois lire le code source de la fonction pour voir comment les cas Edge sont traités. Lorsque les fonctions appellent d'autres fonctions, je dois souvent poursuivre quelque chose à plusieurs niveaux et il devient difficile de comprendre les choses. Cela conduit à un autre avantage de OOP par rapport aux structures et fonctions. OOP a des commentaires XML qui s'affichent sous forme d'infobulles dans les IDE (dans la plupart des langues OOP) et dans OOP sont également des interfaces définies et souvent un diagramme d'objets (si vous choisissez de les faire). Il devient clair pour moi que l'avantage déterminant de OOP est la capacité de documenter ce que le code fait quoi et comment il se rapporte à un autre code - l'interface.
Je pense aussi qu'il vaut la peine de mentionner que le concept d'une structure est très similaire à un "objet" en Javascript, qui est défini très différemment des objets dans d'autres langages. Ils sont tous deux référencés comme "foo.bar" et les données sont structurées de manière similaire.