Qu'est ce qu'un type abstrait de données dans la programmation orientée objet?

Un la classe abstraite est une généralisation du concept. C'est une classe que vous inventez pour l'utiliser seulement comme classe de base pour l'héritage mais pas pour instancier des objets à partir.

et abstract datatype ( ADT ) n'est pas nécessairement un concept OOP. C'est un terme plus ancien pour décrire les concepts de pile et de file d'attente par exemple en termes de fonctionnalité, sans décrire l'implémentation.

Il y a une différence entre une " type abstrait de données " et " la classe abstraite ".

Un la classe abstraite en est un qui ne peut pas avoir des définitions pour toutes les méthodes qu'il définit. Vous ne pouvez donc pas instancier directement une classe abstraite. Vous devez créer une sous-classe et puis instancier.

Un type abstrait de données est un modèle d'un certain type de structure de données, p.ex. un Stack . Une pile a des opérations push() et pop() et a un comportement bien défini.

Le type abstrait de données (ADT) de lui-même fait référence à ce modèle, pas tout particulier de la mise en œuvre dans un langage de programmation ou de paradigme . Vous pouvez implémenter une Pile dans un langage orienté objet, mais vous pouvez également mettre en œuvre de la programmation fonctionnelle langue.

ADTs permettre une discussion sur les propriétés de Piles, Files d'attente, etc ... qui tenir pour toutes les implémentations de l'ADT.

il s'agit de abstraction . L'Abstraction est particulièrement utile dans la programmation. Le principal avantage est la capacité de cacher des détails de réalisation. Vous le cachez à l'intérieur d'un module (ce qu'on appelle les "modules serveurs") et vous fournissez une interface publique pour d'autres modules (ce qu'on appelle les "modules clients"). Et maintenant, nous avons trois possibilités différentes:

peut fournir une structure de données abstraite (ADS) elle-même.

dans ce cas, il contient L'entité ADS elle-même. L'interface publique se compose de certaines procédures (et peut-être quelques 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

mise en Œuvre (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 du serveur et utilisons directement la structure des 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 abstraites (ADT) sous la forme de struct/record.

Dans le module client, nous pouvons déclarer des variables de ce type. Parce qu'un module est libre de déclarer plus d'une variable de type exporté, il peut avoir plus d'une structure de données. Chaque structure de données abstraites est variable du type de données abstraites.

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

Mise en œuvre (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 abstrait de données (ADT) sous la forme de classe .

si notre langue support 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 est appelé une classe , et la variable avec ce type est appelé un objet .

Server interface module (Pile.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

Mise En Œuvre (De La Pile.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 deux dernières options sont:

• terminologique mentionné ci-dessus (type < - > classe, variable < - > objet).
• dans le non-class ADT, 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 avec les autres paramètres formels suivant le nom de la procédure, mais seul se tient entre parenthèses avant le nom de la procédure. En utilisant la terminologie Smalltalk paramètre formel avant le nom de la procédure est appelé le récepteur .
• L'emplacement des procédures. Dans la classe non-ADT, les procédures sont situées à l'extérieur de la structure de la pile. Dans la classe, les procédures sont situées dans la classe. Dans la terminologie orientée objet, les procédures qui ont des récepteurs, et sont donc contenues dans un type de classe, sont appelées mé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;
}

définition:

grossièrement parlant, Type de données abstraites (ADT) est une façon de regarder une structure de données: se concentrant sur ce qu'il fait et ignorant comment il fait son travail.

les types de données abstraites sont définis principalement par leur interface: les opérations permises qui peuvent être effectuées sur eux. Le mécanisme sous-jacent utilisé pour les implémenter n'est généralement pas visible pour leur utilisateur.

exemples:

Stack , Queue et PriorityQueue sont quelques-uns des exemples des ADTs, ils sont plus abstraits que dire tableaux, listes liées et de nombreuses autres structures de stockage de données.

Par exemple, le mécanisme sous-jacent pour une pile, peut être un Array ou il peut être un LinkedList . Le mécanisme sous-jacent pour un PriorityQueue peut être un Array ou un type spécial de arbre appelé Heap .

Code:

voici un exemple Java du type de données abstraites appelé PriorityQueue , implémenté en utilisant le 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 pour la classe PriorityQueue sont simplement enroulées autour des méthodes pour la classe sous-jacente Heap . De même, vous pouvez utiliser Array au lieu de Heap pour mettre en œuvre le même fonctionnalité, même si dans le cas de Array vous aurez besoin de plus de code pour prendre soin des opérations comme insert et remove. Cet exemple devrait indiquer clairement sur le plan conceptuel qu'un PriorityQueue est un ADT qui peut être mis en œuvre de diverses façons, en utilisant des tas, des tableaux, etc.

, Même si, ADTs plus de sens dans la programmation orientée objet (POO) langues, ils ne sont pas limités uniquement à la programmation orientée objet les langues et peut également être créé à l'aide de non-OOP langues.

un type de données abstraites (ADT) est un modèle mathématique d'un type de données. Il décrit les opérations qui peuvent ê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, en utilisant parfaitement abstraitement des opérations telles que pop(), push(), top() et peut-être un symbole constant représentant la pile vide.

par exemple voici quelques équations qui pourrait 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 abstraites n'est pas du tout la même chose qu'une classe dans un modèle d'objet - bien qu'ils montrent quelques similitudes.

Voici les noms des concepts importants: algèbre initiale sémantique, isomorphisme, quotients, congruences

Le point d'un type abstrait de données est de comprendre le comportement de toute une classe de type équivalent représentations utilisant des équations et quelques mathématiques fantaisistes qui démontrent que chaque implémentation est "isomorphe" - c'est-à-dire que les deux implémentations sont exactement équivalentes en ce qui concerne le comportement observable.

l'entrée wikipedia sur ceci est assez bonne: http://en.wikipedia.org/wiki/Abstract_data_type

voici quelques bonnes notes de cours (mais très théoriques) qui épinglent ce qu'est un ADT http://www-compsci.swan.ac.uk / ~csulrich/ftp/adt / adt.pdf

bien que superficiellement similaire au concept d'une" classe "dans certains langages de programmation orientés objet, une" classe " n'est pas un ADT, mais une classe peut être utilisée pour mettre en œuvre un ADT spécifique.

en général, le concept de L'ADT est probablement plus applicable à la programmation fonctionnelle qu'à la programmation orientée objet parce que tous les langages de programmation orientée objet n'ont pas de classes et La pensée ADT-style produit des conceptions OO moins efficaces.

• voici un papier qui démontre les problèmes de pensée en termes D'ADTs dans une langue OO: http://portal.acm.org/citation.cfm?id=74885
• fondamentalement, le papier montre que la "classe" que vous utilisez pour mettre en œuvre un ADT se termine couvert de beaucoup de minuscules petites méthodes (qui ressemblent à la base des équations ADT) plutôt que d'avoir quelques puissants, méthodes de haute abstraction.

dans l'école, ils m'ont appris qu'un ADT est juste un groupe qui contient une collecte de données, et un ensemble d'opérations qui peuvent être prises en charge ces données. Il se réfère simplement à l'idée, et n'est pas lié à tout ,la langue, la mise en œuvre ni paradigme.

mise à jour:

ainsi, en relisant la question, et en fonction de la définition de mi, un type de données abstraites dans OOP devrait être une classe abstraction, héritée ou non, parce qu'elle contient des données (propriétés, champs, etc.) et des opérations (méthodes).

concerne

Abstrait est la plus fondamentale et la concept généralisé dans la programmation et la vie réelle.

qu'est Ce qu'un type abstrait de données dans la programmation orientée objet?

ADT est un conteneur qui contient les différents types d'objets avec les spécifications. représentation logique(I. e une interface ou un protocole) des données et des opérations pour 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 particuliers de données abstraites (ADT). En java par exemple, ArrayList, LinkedList, Stack et Vector sont des structures de données implementation(classes) de List.

Pile des exemples dans la vie réelle:

1. quand une personne porte bracelets le dernier bracelet porté est le premier l'un d' être supprimé et le premier bracelet serait le dernier à être supprimé. Ceci suit le principe du dernier entré, premier sorti (LIFO) de la pile.
2. Dans une pile de plaques , une fois peut sortir la plaque du haut ou peut maintenir la plaque en haut. La plaque placée en premier serait la dernier à prendre. Il suit le principe de la pile.
3. Batteries dans la lampe de poche: batterie sauf si vous supprimez le dernier. Donc la batterie qui a été mis en premier serait le dernier à sortir. Cela est conforme au principe du dernier entré, premier sorti. de la pile.
4. vêtements dans le coffre

exemples de file d'attente dans la vie réelle

1. Une file de personnes à ticket-fenêtre : La personne qui vient en premier obtient le premier billet. La personne qui le dernier arrive, le dernier prend les billets. Par conséquent, il suit la stratégie du premier entré, premier sorti (FIFO) de la file d'attente.
2. Véhicules sur le péage-de l'impôt pont: Le véhicule qui vient en premier à le péage de l'impôt stand sort de la cabine la première. Le véhicule qui arrive en dernier part en dernier. Par conséquent, il suit la stratégie du premier entré, premier sorti (FIFO) de la file d'attente.
3. bagagerie check-machine: bagagerie check-machine les bagages d'abord qui vient en premier. Par conséquent, il suit le principe FIFO de la file d'attente.
4. Patients en attente à l'extérieur du médecin de la clinique: Le patient qui vient des premières visites le premier médecin et le patient qui en est à la dernière visite chez le médecin dernière. Par conséquent, il suit la stratégie du premier entré, premier sorti (FIFO) de la file d'attente.

Les exemples ci-dessus recueillies à partir de Source1 et Source 2

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 dans tout ce que vous voulez.

je peux vous donner un exemple pratique ici

prenez une classe appelée animal. Et il contient des fonctions comme manger, son, mouvement qui est général que tous les animaux font. Vous pouvez étendre la classe pour obtenir 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";
   }
}

espère que ma réponse fait sens pour vous

un pas en arrière par rapport au code:

que signifie abstract? Abstrait

L'essentiel, c'est "pas réel, mais la capture d'une propriété des choses réelles"

vous devez savoir cela pour OOP parce que vous concevrez des univers d'objet, ce qui vous oblige à penser à la façon dont ces objets sont liés.

Abstraction vous permet de grouper certains de ces objets, ainsi l'organisation de

1) votre processus de pensée 2) votre code

1. classes utilise le concept d'abstraction de données , connu sous le nom de type de données absract .

2. abstract data type est un terme plus ancien pour décrire les concepts de pile et de file d'attente en termes de fonctionnalité sans décrire leur mise en œuvre .

brièvement: abstract signifie que vous ne pouvez pas faire des objets à partir de la classe définie. ex: si vous avez des classes de forme,de carré et de rectangle, mais que vous ne voulez pas définir d'objets à partir de la forme, vous marquerez comme abstrait...

après cela si l'utilisateur essaie de définir un nouvel objet à partir de la forme, il aura erreur de compilateur..

extrait du Code Complete-Quote: Les types de données abstraites forment la base du concept de classes. Dans les langages qui supportent les classes, vous pouvez implémenter chaque type de données abstraites dans sa propre classe. Les Classes impliquent habituellement les concepts additionnels d'hérédité et de polymorphisme. Une façon de penser d'une classe est comme un type de données abstraites plus l'héritage et le polymorphisme.

donc, à mon avis, Le type de données abstraites dans OO signifie classe abstraite.

Qu'est-ce qu'un type de données abstrait dans la programmation orientée objet?

un type de données Classe / abstrait 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 d'une manière orientée objet.

qu'est Ce qu'un objet?

objet est une interface vers un type de données Classe / abstrait par lequel nous pouvons d'accéder à ses propriétés et fonctions. Les objets ont des souvenirs associés utilisés pour stocker des données.

ADT est une sorte de structure de données. Au lieu de décrire la structure des données, il décrit le operation sur les données.

, par exemple, qu'est ce qu'un stack ? peut être un arbre de recherche ou une structure de données linéaire, mais l'utilisateur ne s'en soucie pas. Soins de l'utilisateur "dernier entré, premier sorti"A. K. a LIFO

Un ADT définit un ensemble de valeurs de données et un ensemble d'opérations sur ces valeurs.

ADT est un ensemble d'objets et d'opérations, pas le cas dans un ADT définitions aucune mention de la façon dont l'ensemble des opérations est mis en œuvre. Les programmeurs qui utilisent les collections n'ont besoin que de savoir instancier et accéder aux données d'une manière prédéterminée, sans se soucier des détails des implémentations des collections. En d'autres termes, à partir d'un point de vue utilisateur, une collection est une abstraction, et pour cette raison, en informatique, certaines collections sont appelés les types de données abstraites (ADTs). L'utilisateur est seul souci avec l'apprentissage de son interface, ou de l'ensemble de ses opérations effectue.

objet tels que des listes, des ensembles et des graphiques avec leurs opérations peuvent être considérés comme des types de données abstraites. 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 changeant simplement les routines qui effectuent les opérations ADT. Le programme qui les utilisent (ADT) pas nécessairement besoin de savoir quelle mise en œuvre a été utilisée. vous pouvez lire plus ici

une classe abstraite ne forme pas un objet concret dans le monde réel contrairement aux classes d'implémentation pure. Abstrait que le nom suggestes qu'ils détiennent/définir les comportements des objets connexes qui doivent être réutilisés/défini indépendamment de tous les objets liés.

prenez un exemple D'oiseau. Si vous écrivez un programme qui aura quelque chose à voir avec les oiseaux, alors vous aurez d'abord une classe de base abstraite comme oiseau et chaque oiseau dérivant de la classe de base abstraite Oiseau. Notez que la classe abstraite oiseau ne représente pas un objet concret du monde réel mais un type d'objets apparentés qui sont des oiseaux!

permet de commencer avec le diagramme de classe et ensuite un peu de code.

alt texte http://ruchitsurati.net/files/birds.png

public abstract class Bird
{
    protected string Name = string.Empty;
    public Bird(string name)
    {
        this.Name = name;
    }

    public virtual void Fly()
    {
        Console.WriteLine(string.Format("{0} is flying.", this.Name));
    }

    public virtual void Run()
    {
        Console.WriteLine(string.Format("{0} cannot run.", this.Name));
    }
}

public class Parrot : Bird
{
    public Parrot() : base("parrot") { }
}

public class Sparrow : Bird
{
    public Sparrow() : base("sparrow") { }
}

public class Penguin : Bird
{
    public Penguin() : base("penguin") { }

    public override void Fly()
    {
        Console.WriteLine(string.Format("{0} cannot fly. Some birds do not fly.", this.Name));
    }

    public override void Run()
    {
        Console.WriteLine(string.Format("{0} is running. Some birds do run.", this.Name));
    }
}

class Program
{
    static void Main(string[] args)
    {

        Parrot p = new Parrot();
        Sparrow s = new Sparrow();
        Penguin pe = new Penguin();

        List<Bird> birds = new List<Bird>();

        birds.Add(p);
        birds.Add(s);
        birds.Add(pe);

        foreach (Bird bird in birds)
        {
            bird.Fly();
            bird.Run();
        }

        Console.ReadLine();
    }
}

type Abstrait moyens dont les objets n'existent pas dans le monde réel, car il n'a pas entité physique.

il agit comme classe de base pour la classe de béton qui a une existence physique.

p.ex.

 Shape is an abstract class whereas circle,rectangle are concrete classes.