Qu'est-ce qu'un type de données abstrait dans la programmation orientée objet?
Qu'est-ce qu'un type de données abstrait dans la programmation orientée objet? J'ai parcouru le wiki pour ce sujet, mais je ne suis toujours pas clair à ce sujet. Quelqu'un pourrait-il clarifier?
Une classe abstract est un concept de généralisation. C'est une classe que vous inventez pour n'utiliser que comme classe de base pour l'héritage, mais pas pour instancier des objets.
Et type de données abstrait ( ADT ) n’est pas nécessairement un concept OOP. C'est un terme plus ancien qui décrit les concepts de Stack and Queue, par exemple, en termes de fonctionnalité, sans décrire la mise en oeuvre.
Il existe une différence entre un "type de données abstrait" et un "classe abstraite".
Une classe abstraite est une classe qui peut ne pas avoir de définition pour toutes les méthodes qu'elle définit. Vous ne pouvez donc pas instancier directement une classe abstraite. Vous devez créer une sous-classe puis l'instancier.
Un type de données abstrait est un modèle d'un certain type de structure de données, par ex. a Stack. Une pile a des opérations Push () et pop () et a un comportement bien défini.
Le type de données abstrait (ADT) lui-même fait référence à ce modèle et non à une implémentation particulière dans un langage de programmation ou un paradigme particulier. Vous pouvez implémenter une pile dans un langage orienté objet, mais également dans un langage de programmation fonctionnel.
Les ADT permettent de discuter des propriétés des piles, des files d'attente, etc., qui sont valables pour toutes les implémentations correctes de l'ADT.
Eh bien, il s’agit deabstraction. L'abstraction est particulièrement utile en programmation. Le principal avantage est la possibilité de masquer les détails de réalisation. Vous le masquez dans un module (appelé "modules serveur") et fournissez une interface publique à d'autres modules (appelés "modules client"). Et maintenant nous avons trois possibilités différentes:
Le module serveur peut fournir un structure de données abstraite (ADS) lui-même.
Dans ce cas, il contient l'entité ADS elle-même. L'interface publique comprend certaines procédures (et peut-être certaines constantes).
Interface du module serveur (stack_ads.h):
#ifndef STACK_ADS
#define STACK_ADS
const int capacity = 10;
void clear();
int size();
int pop();
void Push(int value);
#endif STACK_ADS
Implémentation (stack_ads.cpp):
#include "stack_ads.h"
int items[capacity];
int top = -1;
void clear()
{
top = -1;
}
int size()
{
return top + 1;
}
int pop()
{
top -= 1;
return items[top + 1];
}
void Push(int value)
{
top += 1;
items[top] = value;
}
Dans le module client (main.cpp), nous importons le module serveur et utilisons directement la structure de données.
#include <iostream>
#include "stack_ads.h"
int main (int argc, char* const argv[])
{
Push(1);
Push(2);
Push(3);
std::cout << pop() << std::endl;
std::cout << pop() << std::endl;
std::cout << pop() << std::endl;
return 0;
}
Le module serveur peut fournir un type de données abstrait (ADT) sous la forme de struct/record.
Dans le module client, nous pouvons déclarer que les variables sont de ce type. Comme un module est libre de déclarer plusieurs variables du type exporté, il peut avoir plusieurs structures de données. Chaque structure de données abstraite est une variable de type de données abstrait.
Interface (stack_adt.h):
#ifndef STACK_ADT
#define STACK_ADT
const int capacity = 10;
typedef struct
{
int items[capacity];
int top;
} StackADT;
void clear(StackADT* stack);
int size(StackADT* stack);
int pop(StackADT* stack);
void Push(StackADT* stack, int value);
#endif STACK_ADT
Implémentation (stack_adt.cpp):
#include "stack_adt.h"
void clear(StackADT* stack)
{
stack->top = -1;
}
int size(StackADT* stack)
{
return stack->top + 1;
}
int pop(StackADT* stack)
{
stack->top -= 1;
return stack->items[stack->top + 1];
}
void Push(StackADT* stack, int value)
{
stack->top += 1;
stack->items[stack->top] = value;
}
Module client:
#include <iostream>
#include "stack_adt.h"
int main (int argc, char* const argv[])
{
StackADT stack1;
StackADT stack2;
stack1.top = -1;
stack2.top = -1;
Push(&stack1, 1);
Push(&stack1, 2);
Push(&stack1, 3);
std::cout << pop(&stack1) << std::endl;
std::cout << pop(&stack1) << std::endl;
std::cout << pop(&stack1) << std::endl;
Push(&stack2, 10);
Push(&stack2, 20);
Push(&stack2, 30);
std::cout << pop(&stack2) << std::endl;
std::cout << pop(&stack2) << std::endl;
std::cout << pop(&stack2) << std::endl;
return 0;
}
Enfin, le module serveur peut fournir un type de données abstrait (ADT) sous la forme de classe.
Si notre langue prend en charge OOP, nous pouvons décrire ADT au moyen de classes. Et encore une fois dans le module client, nous pouvons déclarer que les variables sont de ce type. Dans la terminologie orientée objet, le type s'appelle un classe et la variable de ce type s'appelle un objet.
Interface du module serveur (Stack.h):
#ifndef STACK
#define STACK
const int capacity = 10;
class Stack
{
public:
Stack();
void clear();
int size();
int pop();
void Push(int value);
private:
int items[capacity];
int top;
};
#endif STACK
Implémentation (Stack.cpp):
#include "Stack.h"
Stack::Stack()
{
this->top = -1;
}
void Stack::clear()
{
this->top = -1;
}
int Stack::size()
{
return this->top + 1;
}
int Stack::pop()
{
this->top -= 1;
return this->items[this->top + 1];
}
void Stack::Push(int value)
{
this->top += 1;
this->items[this->top] = value;
}
Les différences entre les deux dernières options sont les suivantes:
- Terminologique mentionnée ci-dessus (type <-> classe, variable <-> objet).
- Dans la classe ADT non-classe, la liste des paramètres formels de chaque procédure doit inclure une variable s de type Stack. Dans la classe de pile, la spécification de la structure de données s n'est pas incluse dans les autres paramètres formels suivant le nom de la procédure, mais .__ est seule entre parenthèses avant le nom de la procédure. Utiliser le paramètre formel de la terminologie Smalltalk avant que le nom de la procédure ne s'appelledestinataire.
- L'emplacement des procédures. Dans la classe ADT non-classe, les procédures sont situées en dehors de la structure Stack. Dans la classe, les procédures sont situées dans la classe. Dans la terminologie orientée objet, les procédures qui ont des destinataires et qui sont donc contenues dans un type de classe sont appeléesméthodes _ .
Code client:
#include <iostream>
#include "stack.h"
int main (int argc, char* const argv[])
{
Stack stack1;
Stack stack2;
stack1.Push(1);
stack1.Push(2);
stack1.Push(3);
std::cout << stack1.pop() << std::endl;
std::cout << stack1.pop() << std::endl;
std::cout << stack1.pop() << std::endl;
stack2.Push(10);
stack2.Push(20);
stack2.Push(30);
std::cout << stack2.pop() << std::endl;
std::cout << stack2.pop() << std::endl;
std::cout << stack2.pop() << std::endl;
return 0;
}
Un type de données abstrait (ADT) est un modèle mathématique d'un type de données. Il décrit les opérations pouvant être effectuées sur les données et la définition mathématique de ces opérations à l'aide d'équations.
Par exemple, vous pouvez modéliser le comportement d'une pile de nombres, de manière parfaitement abstraite, à l'aide d'opérations telles que pop (), Push (), top () et peut-être un symbole constant représentant la pile vide.
Par exemple, voici quelques équations qui pourraient faire partie de la définition d’une pile de nombres:
pop(empty) = empty // silently ignores popping an empty stack
pop(Push(N,S)) = S // i.e. pop removes the top element of Push(N,S)
top(Push(N,S)) = N // return topmost element of the stack without changing the stack
Un type de données abstrait n’est pas du tout la même chose qu’une classe dans un modèle d’objet - bien qu’ils présentent certaines similitudes.
Voici les noms des concepts importants: sémantique de l’algèbre initiale, isomorphisme, quotients, congruences
L’intérêt d’un type de données abstrait est de comprendre le comportement de toute une classe de représentations de types équivalents à l’aide d’équations et de mathématiques sophistiquées démontrant que chaque implémentation est "isomorphe" - c’est-à-dire que les deux implémentations sont exactement équivalentes dans la mesure où le comportement observable est concerné.
L'entrée wikipedia sur ceci est plutôt bonne: http://en.wikipedia.org/wiki/Abstract_data_type
Voici quelques bonnes notes de cours (mais très théoriques) qui définissent ce qu'est un ADT http://www-compsci.swan.ac.uk/~csulrich/ftp/adt/adt.pdf
Bien que superficiellement similaire au concept de "classe" dans certains langages de programmation orientés objet, une "classe" n'est pas un ADT, mais une classe peut être utilisée pour implémenter un ADT spécifique.
En général, le concept ADT est probablement plus applicable à la programmation fonctionnelle qu'à la programmation orientée objet, car tous les langages de programmation orientés objet ne possèdent pas de classes et que la pensée de style ADT produit des conceptions OO moins efficaces.
- Voici un document qui montre les problèmes de la pensée en termes de TDA dans une langue OO: http://portal.acm.org/citation.cfm?id=74885
- En gros, le papier montre que la "classe" que vous utilisez pour implémenter un ADT finit par être recouverte de nombreuses petites méthodes (qui ressemblent à la base des équations d'ADT) au lieu de disposer de quelques méthodes puissantes d'abstraction élevée.
Définition:
En gros, Type de données abstrait (ADT) est une manière de regarder une structure de données: en se concentrant sur ce qu’elle fait et en ignorant comment elle fait son travail.
Les types de données abstraits sont définis principalement par leur interface: les opérations autorisées pouvant être effectuées sur eux. Le mécanisme sous-jacent utilisé pour implémenter les N'est généralement pas visible pour l'utilisateur.
Exemples:
Stack, Queue et PriorityQueue sont quelques-uns des exemples d'ADT, ils sont plus abstraits que des tableaux, des listes chaînées et de nombreuses autres structures de stockage de données.
Par exemple, le mécanisme sous-jacent d'une pile peut être un Array ou un LinkedList. Le mécanisme sous-jacent à PriorityQueue peut être une Array ou un type spécial d’arbre appelé Heap.
Code:
Voici un exemple Java du type de données abstrait appelé PriorityQueue, implémenté à l'aide du tas:
class Heap {
private Node heapArray[];
public void insert(Node node) {...}
public Node remove() {...}
}
class PriorityQueue {
private Heap heap;
public void insert(Node node) {
heap.insert(node);
}
public Node remove() {
return heap.remove();
}
}
Ici, vous pouvez voir que les méthodes de la classe PriorityQueue sont simplement regroupées autour des méthodes de la classe Heap sous-jacente. De même, vous pouvez utiliser Array au lieu de Heap pour implémenter la même fonctionnalité, même si dans le cas de Array, vous aurez besoin de plus de code pour prendre en charge des opérations telles que l'insertion et la suppression. Cet exemple devrait expliquer de manière conceptuelle qu'une PriorityQueue est une ADT pouvant être implémentée de différentes manières, à l'aide de tas, de tableaux, etc.
Bien que les ADT aient plus de sens dans les langages de programmation orientée objet (OOP), ils ne se limitent pas aux langages OOP et peuvent également être créés à l'aide de langages non-OOP.
Résumé est le concept le plus fondamental et généralisé dans une programmation et la vie réelle.
Qu'est-ce qu'un type de données abstrait dans la programmation orientée objet?
ADT est un conteneur qui contient différents types d'objets avec des spécifications. représentation logique (c'est-à-dire une interface ou un protocole) des données et des opérations permettant de manipuler les éléments constitutifs des données.
Exemples d'ADT: List, Map, Set, Stack, Queue, Tree, Graph.
Les structures de données peuvent implémenter un ou plusieurs types de données abstraits (ADT) particuliers. En Java, par exemple, ArrayList, LinkedList, Stack et Vector sont des implémentations de structures de données (classes) de List.
Exemples de pile dans la vie réelle:
- Quand une personne porte joncs, le dernier jonc porté est le premier à être enlevé et le premier jonc sera le dernier à être enlevé ... Ceci suit le principe de pile du dernier entré (premier sorti) .
- Dans une pile de plaques, une fois peut sortir la plaque du haut ou peut Garder la plaque vers le haut. La plaque placée en premier serait la dernière à être retirée. Cela suit le principe LIFO de pile.
- Piles dans la lampe de poche: - Vous ne pouvez pas retirer la deuxième pile Sauf si vous enlevez la dernière entrée. Ainsi, la pile insérée en premier Serait la dernière à être retirée. Ceci suit le principe LIFO De pile.
- Vêtements dans le coffre
exemples de files d'attente dans la vie réelle
- Une file de personnes à ticket-window: la personne qui arrive en premier reçoit le ticket en premier. La personne qui vient en dernier reçoit les billets en dernier. Par conséquent, il suit la stratégie de file d'attente FIFO (premier entré, premier sorti).
- Véhicules sur le pont de péage: le véhicule qui arrive en premier au stand de péage quitte le stand en premier. Le véhicule qui vient en dernier part en dernier. Par conséquent, il suit la stratégie de file d'attente FIFO (premier entré, premier sorti).
- Vérificateur de bagages: le vérificateur de bagages vérifie les bagages en premier. Par conséquent, il suit le principe FIFO de la file d'attente.
- Patients en attente à l'extérieur de la clinique du médecin: le patient qui vient en premier visite le médecin en premier et le patient qui vient la dernière visite du médecin en dernier. Par conséquent, il suit la stratégie de file d'attente premier entré, premier sorti (FIFO).
À l'école, ils m'ont appris qu'un ADT n'est qu'un groupe qui contient une collection de données et un ensemble d'opérations pouvant être effectuées sur ces données. Il fait simplement référence à l'idée, etn'est lié à aucun langage, mise en œuvre ni paradigme.
Mis à jour:
Pour relire la question, et donc conformément à la définition, un type de données abstrait dans OOP doit être une abstraction de classe, héritée ou non, car il contient des données (propriétés, champs, etc.) et des opérations ( méthodes).
cordialement
Prenez un peu de recul par rapport au code:
Que signifie abstrait? Abstrait
L'essentiel en est "pas réel, mais capturer une propriété de choses réelles"
Vous devez le savoir pour OOP, car vous allez concevoir des univers d'objets, ce qui vous oblige à réfléchir à la relation entre ces objets.
L'abstraction vous permet de grouper certains de ces objets, organisant ainsi
1) Votre processus de réflexion 2) Votre code
J'ai eu le même problème jusqu'à la semaine dernière.
Une classe abstraite est quelque chose qui est commun ou quelque chose en général. Vous pouvez utiliser cette classe pour la modeler et l'étendre comme bon vous semble.
Je peux vous donner un exemple pratique ici
Prenez un cours appelé animal. Et il contient des fonctions telles que manger, entendre, bouger, ce qui est le cas de tous les animaux. Vous pouvez étendre cette classe pour qu'elle soit spécifique, comme les chats, les chiens, etc.
par exemple.
abstract class animal {
abstract protected function eat();
abstract protected function sound();
}
class dogs extends animal
{
protected function eat() {
return "meat";
}
public function sound() {
return "bow wow";
}
}
j'espère que ma réponse a du sens pour toi
classes utilise le concept d'abstraction de données, appelé type de données absract.
type de données abstrait est un terme plus ancien qui décrit les concepts de pile et de files d'attente en termes de fonctionnalité sans décrire leur implémentation.
Le type de données abstrait (ADT) est un modèle mathématique avec une collection d'opérations définies sur ce modèle.
En outre, ADT est un type de données dont le comportement est défini par un ensemble de valeurs et un ensemble d'opérations.
En bref: abstrait signifie que vous ne pouvez pas créer d'objets à partir de la classe définie. ex: si vous avez des classes shape, square et rectangle, mais que vous ne voulez définir aucun objet à partir de shape, vous devez le marquer comme abstrait ...
après cela, si l'utilisateur essaie de définir un nouvel objet à partir de shape, il aura une erreur de compilation.
De ce post :
ADT est un ensemble d’objets et d’opérations. Dans les définitions d’un ADT, il n’ya aucune mention de la manière dont cet ensemble d’opérations est mis en œuvre. Les programmeurs qui utilisent des collections doivent seulement savoir comment instancier et accéder aux données de manière prédéterminée, sans se soucier des détails de la mise en œuvre des collections. En d'autres termes, du point de vue de l'utilisateur, une collection est une abstraction. Pour cette raison, en informatique, certaines collections sont appelées types de données abstraits (ADT). L'utilisateur n'est préoccupé que par l'apprentissage de son interface ou de l'ensemble des opérations qu'il effectue.
Des objets tels que des listes, des ensembles et des graphiques ainsi que leurs opérations peuvent être visualisés sous forme de types de données abstraits. Les ADT sont essentiellement des types de données qui cachent les détails de sa mise en œuvre. Toute partie d'un programme qui doit effectuer une opération sur ADT peut le faire en modifiant simplement les routines exécutant les opérations ADT. Le programme qui les utilise (ADT) n'aura pas nécessairement besoin de savoir quelle implémentation a été utilisée
C’est tiré de Code Complete -Quote: Les types de données abstraits constituent le fondement du concept de classes. Dans les langues qui prennent en charge les classes, vous pouvez implémenter chaque type de données abstrait dans sa propre classe. Les classes impliquent généralement les concepts supplémentaires d'héritage et de polymorphisme. Une façon de penser d’une classe est un type de données abstrait associé à un héritage et un polymorphisme.
Donc, à mon avis, type de données abstrait dans OO signifie classe abstraite.
ADT est une sorte de structure de données. Au lieu de décrire la structure des données, il décrit l'opération sur les données.
Par exemple, qu'est-ce qu'une pile? Peut-être un arbre de recherche ou une structure de données linéaire, mais l'utilisateur s'en fiche. L'utilisateur ne se préoccupe que du "dernier entré, premier sorti" (LIFO).
Un ADT définit un ensemble de valeurs de données et un ensemble d'opérations sur ces valeurs.
Qu'est-ce qu'un type de données abstrait dans la programmation orientée objet?
Un type de données Classe/Résumé est un groupe de propriétés et de fonctions .__ (pour accéder aux données) de tout ce que nous pourrions vouloir traiter Tout en résolvant un problème de manière orientée objet.
Qu'est-ce qu'un objet?
Object est une interface vers un type de données Class/Abstract par lequel nous pouvons accéder à ses propriétés et fonctions. Les objets sont associés à des mémoires utilisées pour stocker des données.