GATE CSE 2005 | Question: 2

Question

An Abstract Data Type (ADT) is:

• A. same as an abstract class
• B. a data type that cannot be instantiated
• C. a data type for which only the operations defined on it can be used, but none else
• D. all of the above

Comments

https://www.youtube.com/watch?v=g1USSZVWDsY&list=PLBF3763AF2E1C572F&index=2
ADT time stamp is already Given

---

@1:40

---

An Abstract Data Type (ADT) is a high-level conceptual model in computer science that defines a data type purely by its behavior and operations, rather than how it is built under the hood.

• When we talk about an ADT, we only care about what the data type does, not how it does it. This is known as data abstraction.
• An ADT acts as a contract. It tells the programmer: "If you use me, I promise to provide these specific operations, and they will behave in this exact way."

Correct Answer C. a data type for which only the operations defined on it can be used, but none else

This is the definition of encapsulation and abstraction inherent to ADTs. Because an ADT is defined strictly by its interface, a user is restricted to using only the explicit operations provided by that ADT.

A Classical Example: The Stack ADT

A Stack is a "Last-In, First-Out" (LIFO) structure. The Stack ADT defines only a few standard operations:

• push(item): Add an item to the top.
• pop(): Remove and return the top item.
• peek(): Look at the top item without removing it.

Because of this definition, you cannot access an element in the middle of a Stack directly. You cannot sort it in place using random index access like an array. You are strictly limited to push, pop, and peek. If you need to do other things, a Stack is the wrong ADT for your problem.

---

Why Option A is Wrong ("same as an abstract class")

• Abstract Data Type (ADT) is a conceptual design tool in computer science theory. It exists independently of any programming language. You can describe a Stack ADT using plain English or math formulas.
• Abstract Class is a language-specific feature (found in OOP languages like Java, C++, or Python). It is a structural tool used to achieve polymorphism and code reuse through inheritance.
• While you can use an abstract class to help define an ADT in Java, they are not the same thing. An ADT is the idea; an abstract class is one way to start writing code for that idea.

Why Option B is Wrong ("a data type that cannot be instantiated")

• This option confuses ADTs with abstract classes or interfaces in coding.
• In a program, you absolutely can instantiate and use an ADT, provided you have written a concrete implementation for it. For example, if you implement the Queue ADT using a Linked List implementation, you can safely create an instance of that queue (Queue myQueue = new LinkedListQueue();) and start using it to store data.

Why Option D is Wrong ("all of the above")

• Since A and B are conceptually incorrect, D is eliminated.

Answer 1

An abstract data type (ADT) supports only the operations which are defined.

Abstract class is one that may not have definitions of all the objects it have. Moreover it can not be instantiated. To instantiate we have to create a subclass then instantiate the class.

Abstract Data Type is  like data structure  eg. $STACK$ where we have $PUSH()$ $POP()$ operation defined .

Hence, they are not the same thing.

http://www.devx.com/tips/Tip/5681

Correct Answer: $C$

Comments

Mods update link in answer to:
https://web.archive.org/web/20210323182511/https://www.devx.com/tips/Tip/5681

---

Is structure an abstract datatype? @Pranavpurkar

---

@Abhrajyoti00 Basically, structures (along with class) are used to write the attributes and functions of an Abstract Data Type.

Answer 2

ADT of any data structure is "what operation stacks you can perform on this data structure."

for ex:

ADT of stack:

(1) push()

(2) pop()

ADT of queue:

(1) enqueue

(2) dequeue

Comments

why not option b??

---

are stack and queue themselves ADT or are the operations performed on stack and queue called ADT?

---

@akshay7797 stacks , queues , linked lists , trees etc are ADT’s . 

Answer 3

See link: https://www.devx.com/tips/Tip/5681 

An abstract class is a class that has at least one pure virtual member function. It is not a data type (normally, abstract classes do not contain any data members), nor can you instantiate an object thereof. An abstract class is merely a skeletal interface, which specifies a set of services that its subclasses implement.

This clears why option a) is incorrect.

 An abstract data type (also called a concrete type) is a self-contained, user-defined type that bundles data with a set of related operations. It behaves in the same way as a built-in type does. However, it does not inherit from other classes, nor does it serve as the base for other derived classes. Some examples of abstract data types or concrete types include std::string, std::complex, and std::vector.

 We can instantiate abstract data type or concrete type as all operations are defined on it. For example, in C++ you can instantiate the abstract data type string by:

std::string mystring = “Hello World”;

So option B) is false. 

Also see: https://wikipedia.org/wiki/Abstract_data_type

In computer science, an abstract data type (ADT) is a mathematical model for data types. An abstract data type is defined by its behavior (semantics) from the point of view of a user, of the data, specifically in terms of possible values, possible operations on data of this type, and the behavior of these operations.

So option c) is correct.

Comments

This should be the best answer

---

make this the best answer, as there is only 1 question on the ADT topic and the given answer is not the best to explain

Answer 4

Correct answer will be C) A data type for which only the operation defined on it can be used but none else.

Stack is Abstract Data Type, We can not perform any other operation on stack other that push() and pop() operation.

Answer 5

See

http://en.wikipedia.org/wiki/Abstract_data_type

Answer 6

Option B is false.

Some algorithms need to create new instances of some ADT (such as new variables, or new stacks). To describe such algorithms, one usually includes in the ADT definition a create() operation that yields an instance of the ADT, usually with axioms equivalent to

• the result of create() is distinct from any instance in use by the algorithm.

This axiom may be strengthened to exclude also partial aliasing with other instances. On the other hand, this axiom still allows implementations of create() to yield a previously created instance that has become inaccessible to the program.

https://en.wikipedia.org/wiki/Abstract_data_type