Che cos’è un tipo di dati astratto nella programmazione orientata agli oggetti?

Che cos’è un tipo di dati astratto nella programmazione orientata agli oggetti? Ho letto il wiki per questo argomento, ma non ne sono ancora chiaro. Qualcuno potrebbe chiarire?

Una class astratta è un concetto di generalizzazione. È una class che si inventa per usare solo come una class base per l’ereditarietà, ma non per creare un’istanza di oggetti.

E il datatype astratto ( ADT ) non è necessariamente un concetto di OOP. È un termine più vecchio per descrivere i concetti di Stack e Coda ad esempio in termini di funzionalità, senza descrivere l’implementazione.

C’è una differenza tra un ” tipo di dati astratti ” e una ” class astratta “.

Una class astratta è quella che potrebbe non avere definizioni per tutti i metodi che definisce. Pertanto, non è ansible creare direttamente un’istanza di una class astratta. Devi creare una sottoclass e quindi istanziarla.

Un tipo di dati astratto è un modello di un certo tipo di struttura di dati, ad esempio una pila . Uno Stack ha operazioni push () e pop () e ha un comportamento ben definito.

Il tipo di dati astratti (ADT) si riferisce a questo modello, non una particolare implementazione in un particolare linguaggio di programmazione o paradigma . Potresti implementare uno Stack in un linguaggio orientato agli oggetti, ma potresti anche implementarlo in un linguaggio di programmazione funzionale.

Gli ADT consentono di discutere le proprietà di stack, code, ecc. Che si applicano a tutte le implementazioni corrette dell’ADT.

Bene, si tratta di astrazione . L’astrazione è particolarmente utile nella programmazione. Il vantaggio principale è la capacità di hide i dettagli di realizzazione. Lo nascondi all’interno di un modulo (i cosiddetti “moduli server”) e fornisci un’interfaccia pubblica per altri moduli (i cosiddetti “moduli client”). E ora abbiamo tre diverse possibilità:

Il modulo server può fornire una struttura dati astratta (ADS) .

In quel caso contiene l’entity framework ADS stessa. L’interfaccia pubblica consiste in alcune procedure (e forse alcune costanti).

Interfaccia del modulo server (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 

Implementazione (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; } 

Nel modulo client (main.cpp) importiamo il modulo server e usiamo direttamente la struttura dati.

 #include  #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; } 

Il modulo server può fornire un tipo di dati astratti (ADT) sotto forma di struct / record.

Nel modulo client possiamo dichiarare che le variabili sono di quel tipo. Poiché un modulo è libero di dichiarare più di una variabile per essere di tipo esportato, può avere più di una struttura di dati. Ogni struttura di dati astratta è variabile di tipo di dati astratto.

Interfaccia (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 

Implementazione (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; } 

Modulo client:

 #include  #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; } 

Infine, il modulo server può fornire un tipo di dati astratti (ADT) sotto forma di class .

Se la nostra lingua supporta OOP, possiamo descrivere l'ADT per mezzo di classi. E ancora una volta nel modulo client possiamo dichiarare che le variabili sono di quel tipo. Nella terminologia orientata agli oggetti, il tipo è chiamato class e la variabile con quel tipo è chiamata object .

Interfaccia del modulo server (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 

Implementazione (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; } 

Le differenze tra due ultime opzioni sono:

  • Terminologico menzionato sopra (tipo <-> class, variabile <-> object).
  • Nell'ADT non di class, l'elenco dei parametri formale di ogni procedura deve includere una variabile s di tipo Stack. Nella class stack, la specifica della struttura dei dati s non è inclusa con gli altri parametri formali che seguono il nome della procedura, ma si trova solo racchiusa tra parentesi prima del nome della procedura. Usando il parametro formale della terminologia Smalltalk prima che il nome della procedura sia chiamato ricevitore .
  • La posizione delle procedure. Nell'ADT non di class, le procedure si trovano all'esterno della struttura di Stack. Nella class, le procedure si trovano all'interno della class. Nella terminologia orientata agli oggetti, le procedure che hanno ricevitori e quindi contenute in un tipo di class, sono chiamate metodi .

Codice cliente:

 #include  #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; } 

Definizione:

In parole povere, Abstract Data Type (ADT) è un modo di guardare a una struttura dati: concentrandosi su ciò che fa e ignorando come fa il suo lavoro.

I tipi di dati astratti sono definiti principalmente dalla loro interfaccia: le operazioni consentite che possono essere eseguite su di essi. Il meccanismo sottostante utilizzato per implementarli in genere non è visibile all’utente.


Esempi:

Stack , Queue e PriorityQueue sono alcuni degli esempi di ADT, sono più astratti di array, elenchi concatenati e molte altre strutture di archiviazione dei dati.

Ad esempio, il meccanismo sottostante per uno stack può essere una Array o può essere una LinkedList . Il meccanismo sottostante per PriorityQueue può essere una Array o un tipo speciale di albero chiamato Heap .


Codice:

Ecco un esempio Java del tipo di dati astratto denominato PriorityQueue , implementato utilizzando l’heap:

 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(); } } 

Qui puoi vedere che i metodi per la class PriorityQueue sono semplicemente avvolti attorno ai metodi per la class Heap sottostante. Allo stesso modo è ansible utilizzare Array anziché Heap per implementare la stessa funzionalità, anche se nel caso di Array è necessario più codice per occuparsi delle operazioni come inserimento e rimozione. Questo esempio dovrebbe rendere concettualmente chiaro che un PriorityQueue è un ADT che può essere implementato in vari modi, usando heap, array e così via.

Sebbene gli ADT abbiano più senso nei linguaggi di programmazione orientata agli oggetti (OOP), non sono limitati solo alle lingue OOP e possono anche essere creati utilizzando linguaggi non OOP.


Un tipo di dati astratti (ADT) è un modello matematico di un tipo di dati. Descrive le operazioni che possono essere eseguite sui dati e la definizione matematica di quelle operazioni utilizzando le equazioni.

Ad esempio, è ansible modellare il comportamento di una pila di numeri, usando perfettamente operazioni come pop (), push (), top () e forse un simbolo costante che rappresenta lo stack vuoto.

Per esempio ecco alcune equazioni che potrebbero far parte della definizione di una pila di numeri:

 pop(empty) = empty // silently ignores popping an empty stack pop(push(N,S)) = S // ie 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 tipo di dati astratti non è affatto la stessa cosa di una class in un modello a oggetti – sebbene presentino alcune somiglianze.

Ecco i nomi dei concetti importanti: semantica algebrica iniziale, isomorfismo, quozienti, congruenze

Il punto di un tipo di dati astratti è capire il comportamento di un’intera class di rappresentazioni di tipi equivalenti usando equazioni e qualche matematica elaborata che dimostri che ogni implementazione è “isomorfa” – cioè che entrambe le implementazioni sono esattamente equivalenti per quanto riguarda il comportamento osservabile ha riguardato.

La voce di Wikipedia su questo è abbastanza buona: http://en.wikipedia.org/wiki/Abstract_data_type

Ecco alcune buone (ma molto teoriche) note di corso che definiscono cos’è un ADT http://www-compsci.swan.ac.uk/~csulrich/ftp/adt/adt.pdf

Sebbene superficialmente simile al concetto di una “class” in alcuni linguaggi di programmazione orientati agli oggetti, una “class” non è un ADT, ma una class può essere utilizzata per implementare un ADT specifico.

In generale, il concetto di ADT è probabilmente più applicabile alla programmazione funzionale rispetto alla programmazione orientata agli oggetti perché non tutti i linguaggi di programmazione orientati agli oggetti hanno classi e il pensiero in stile ADT produce progetti OO meno efficaci.

  • Ecco un documento che dimostra i problemi di pensiero in termini di ADT in un linguaggio OO: http://portal.acm.org/citation.cfm?id=74885
  • Fondamentalmente, il documento mostra che la “class” che si utilizza per implementare un ADT finisce con molti piccoli metodi (che sembrano le basi delle equazioni di ADT) piuttosto che avere alcuni metodi potenti e di alta astrazione.

Nella scuola mi hanno insegnato che un ADT è solo un gruppo che contiene una raccolta di dati e una serie di operazioni che possono essere prese su questi dati. Si riferisce solo all’idea, e non è correlato con alcun linguaggio, implementazione né paradigma.

aggiornato:
quindi rileggendo la domanda, e di conseguenza alla definizione di mi, un tipo di dati astratto in OOP dovrebbe essere un’astrazione di class, ereditata o meno, perché contiene dati (proprietà, campi, ecc.) e operazioni (metodi).

Saluti

L’astratto è il concetto più fondamentale e generalizzato in una programmazione e nella vita reale.

Che cos’è un tipo di dati astratto nella programmazione orientata agli oggetti?

ADT è un contenitore che contiene diversi tipi di oggetti con specifiche. rappresentazione logica (cioè un’interfaccia o un protocollo) dei dati e le operazioni per manipolare gli elementi componenti dei dati.

Esempi di ADT: elenco, mappa, set, pila, coda, albero, grafico.

Le strutture dati possono implementare uno o più particolari tipi di dati astratti (ADT). In Java ad esempio ArrayList, LinkedList, Stack e Vector sono l’implementazione delle strutture dati (classi) di List.

Esempi di stack nella vita reale:

  1. Quando una persona indossa i braccialetti, l’ultimo braccialetto indossato è il primo a essere rimosso e il primo braccialetto sarà l’ultimo ad essere rimosso. Questo segue l’ultimo principio del primo stack (LIFO).
  2. In una pila di piatti , una volta può estrarre la piastra dall’alto o mantenere la piastra in alto. La piastra che è stata collocata per prima sarebbe l’ultima a tirarla fuori. Questo segue il principio LIFO dello stack.
  3. Batterie nella torcia: – Non è ansible rimuovere la seconda batteria a meno che non si rimuova l’ultima. Quindi la batteria che è stata inserita per prima sarebbe stata l’ultima a tirarla fuori. Questo segue il principio LIFO dello stack.
  4. Vestiti nel bagagliaio

esempi di coda nella vita reale

  1. Una coda di persone alla biglietteria : la persona che viene prima riceve prima il biglietto. La persona che sta arrivando l’ultima volta sta recuperando i biglietti. Pertanto, segue la strategia della coda in prima uscita (FIFO).
  2. Veicoli sul ponte di pedaggio: il veicolo che arriva prima allo sportello del pedaggio lascia prima lo stand. Il veicolo che arriva l’ultimo lascia per ultimo. Pertanto, segue la strategia della coda in prima uscita (FIFO).
  3. Macchina per il controllo bagagli : la macchina per il controllo bagagli controlla prima i bagagli che vengono prima. Pertanto, segue il principio della coda FIFO.
  4. Pazienti che aspettano fuori dalla clinica del medico: il paziente che viene prima visita il medico per primo, e il paziente che viene l’ultima volta visita il medico. Pertanto, segue la strategia di coda first-in-first-out (FIFO).

Gli esempi precedenti raccolti da Source1 e Source2

Ho avuto lo stesso problema fino alla scorsa settimana.

Una class astratta è qualcosa che è comune o qualcosa in generale. Puoi usare quella class per modellarla ed estenderla in qualsiasi modo tu voglia.

Posso darti un esempio pratico qui

Prendi una class chiamata animale. E contiene funzioni come mangiare, suonare, muovere che è generale che fanno tutti gli animali. Puoi estendere quella class per ottenere specifici come gatti, cani, ecc.

per esempio.

 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"; } } 

spero che la mia risposta abbia un senso per te

Fai un passo indietro dal codice:

Cosa significa astratto? Astratto

Il succo di ciò è “non reale, ma catturare una proprietà di cose reali”

Devi sapere questo per OOP perché dovrai progettare universi object, il che richiede di pensare a come questi oggetti sono correlati.

L’astrazione ti consente di raggruppare alcuni di questi oggetti, organizzando così

1) Il tuo processo di pensiero 2) Il tuo codice

  1. le classi utilizzano il concetto di astrazione dei dati, noto come tipo di dati absract.

  2. tipo di dati astratto è un termine più vecchio per descrivere i concetti di stack e code in termini di funzionalità senza descrivere la loro implementazione.

In breve: astratto significa che non puoi creare oggetti dalla class definita. ex: se hai classi shape, square e rectangle, ma non vuoi definire alcun object dalla forma in modo da contrassegnarlo come astratto …

dopo di ciò se l’utente prova a definire un nuovo object dalla forma, avrà l’errore del compilatore ..

Si tratta di Code Complete -Quote: i tipi di dati astratti costituiscono la base per il concetto di classi. Nelle lingue che supportano le classi, è ansible implementare ogni tipo di dati astratti nella propria class. Le classi di solito coinvolgono i concetti aggiuntivi di ereditarietà e polimorfismo. Un modo di pensare di una class è come un tipo di dati astratto più ereditarietà e polimorfismo.

Quindi, secondo me, il tipo di dati astratti in OO significa class astratta.

Che cos’è un tipo di dati astratto nella programmazione orientata agli oggetti?

Un tipo di dati Class / Abstract è un gruppo di proprietà e funzioni (per accedere ai dati) di tutto ciò che potremmo voler trattare mentre risolviamo alcuni problemi in modo orientato agli oggetti.

Cos’è un object?

Object è un’interfaccia per un tipo di dati Class / Abstract attraverso il quale possiamo accedere alle sue proprietà e funzioni. Gli oggetti hanno memorie ad essi associate utilizzate per la memorizzazione dei dati.

ADT è una sorta di struttura dati. Invece di descrivere la struttura dei dati, descrive l’ operation sui dati.

per esempio, cos’è una stack ? può essere un albero di ricerca o una struttura di dati lineare, ma l’utente non si cura. L’utente si preoccupa solo di “last in first out” alias LIFO

Un ADT definisce un insieme di valori di dati e un insieme di operazioni su questi valori.

ADT è un insieme di oggetti e operazioni, non dove nelle definizioni di un ADT vi è alcuna menzione di come l’insieme di operazioni è implementato. I programmatori che utilizzano le raccolte devono solo sapere come istanziare e accedere ai dati in modo predeterminato, senza preoccupazioni per i dettagli delle implementazioni delle collezioni. In altre parole, dal punto di vista dell’utente, una collezione è un’astrazione e, per questo motivo, nell’informatica, alcune raccolte vengono chiamate tipi di dati astratti (ADT). L’utente si preoccupa solo di apprendere la sua interfaccia, o l’insieme delle operazioni che svolge.

Oggetti come elenchi, insiemi e grafici insieme alle loro operazioni possono essere visualizzati come tipi di dati astratti. Gli ADT sono fondamentalmente tipi di dati che nascondono i dettagli dell’implementazione. Qualsiasi parte di un programma che deve eseguire un’operazione su ADT può farlo semplicemente cambiando le routine che eseguono le operazioni ADT. Il programma che li usa (ADT) non avrà necessariamente bisogno di sapere quale implementazione è stata utilizzata. puoi leggere di più qui

Una class astratta non forma un object concreto nel mondo reale a differenza delle classi di implementazione pure. Estratto come suggerisce il nome, essi tengono / definiscono comportamenti comuni degli oggetti correlati che devono essere riutilizzati / definiti in modo indipendente in tutti gli oggetti correlati.

Prendi un esempio di uccelli. Se stai scrivendo un programma che avrà qualcosa a che fare con gli uccelli, allora avrai prima una class base astratta come Bird e ogni uccello derivante dalla class base astratta Bird. Si noti che l’abstract BIRD di class non rappresenta un concreto object del mondo reale ma un tipo di oggetti correlati che sono uccelli!

Iniziamo con il diagramma di class e poi con il codice.

alt text 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 birds = new List(); birds.Add(p); birds.Add(s); birds.Add(pe); foreach (Bird bird in birds) { bird.Fly(); bird.Run(); } Console.ReadLine(); } } 

Tipo astratto indica i cui oggetti non esiste nel mondo reale poiché non ha un’ quadro fisica.

Agisce come una class base per una class concreta che ha un’esistenza fisica.

per esempio

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