Data Types vs Abstract Data Types: ADT Explained Simply

In our journey towards learning data structures, we first have to understand the difference between data types and

abstract data types. So, let's get started. What is a data type? We have already

discussed what a data type is in our C programming lectures, but let's discuss it one more time because there are

certain points which I haven't discussed there. There are two important things that I

haven't told you about data types, although there is one point which is already clear, but there is one more

important point which I haven't told about data types. First is it defines a certain domain of

values. We already know that a data type defines a certain domain of values, right? But, there is one more important

point which says that it defines operations allowed on those values. So, not only it is defining certain domain

of values, but it also defines what operations are allowed on those values. For example, we can think of integer

type. Here, we can take only integer values. We already know that integer allows only integer values, right? But,

the operations allowed are addition, subtraction, multiplication, bitwise operations, etc. We can perform almost

every operation with integer type. For the sake of understanding, let's take another type, that is float type. It

takes only floating point values. We already know that the domain of values allowed in the case of float type are

only floating point values. But, the operations which we can perform on float types are addition, subtraction,

multiplication, division, but we cannot perform bitwise and mod operations on them. This should be well noted. So, it

is clearly understandable that a data type not only defines a certain domain of values, but it also defines

operations allowed on those values, right? Now, let's discuss what is a user-defined data type. Before moving on

to abstract data types, we should understand what is a user-defined data type. In contrast to primitive data

types, there is a concept of user-defined data types. We already know primitive data types like integer,

character, float, right? But, But is a concept of user-defined data type which we should also know. The operations and

values of user-defined data types are not specified in the language itself, but is specified by the user. Here the

user is defining the operations as well as the values. It is not predefined in the language itself. Okay? Now here are

the examples: structure, union, and enumeration, which we have already discussed. By using structures, we are

defining our own type by combining other data types. By using structures, we are defining our own type by combining other

primitive types. For example, here in this case we have combined these two integers to form a new type, that is

point. So it's a user-defined data type. This is our understanding about user-defined data types. Now let's try

to understand what are abstract data types. ADTs or abstract data types are like

user-defined data types which defines operations on values using functions without specifying what is there inside

the function and how the operations are performed. First of all, we are defining operations, that is true, but we are

defining operations on values, that is also true, using functions. It should be well noted that we are defining

operations using functions without specifying what is there inside the function. We are not specifying anything

inside what is there inside the function, okay? And how the operations are performed. Let's take an example of

a stack ADT. A stack consists of elements of same type in a sequential order. So what type of elements are

allowed in a stack? The elements of same type. And that too, they are arranged in a sequential order. We already know

that, right? Now the operations allowed on them could be initialize. We can define an initialize function which

initializes the stack to be empty actually. We can perform a push operation, that is insert an element

into the stack. We can perform pop operation, that is delete an element from the stack. We can check is stack

empty or we can check is stack full. So, these are the operations which we can define and we can perform on stack.

These are functions as you can see. Here we are specifying functions, but we are not saying anything how they can be

implemented. We are just specifying them. That is called abstract data type. We know that what type of elements are

allowed and we also know that what operations we can perform, but we don't know what is there inside. Okay?

Think of ADT as a black box which hides the inner structure and design of the data type from the user. We can think of

it like it hides all the implementation details from us. This is very important which we will understand later. There

are multiple ways to implement an ADT. Let me tell you, this is very important. There are multiple ways to implement an

ADT. For example, a stack ADT can be implemented using arrays or linked lists. It should be well noted that

stack itself is a data structure. We can implement this data structure using other data structures like arrays or

linked lists. Okay, so a stack ADT, which we know is right now a skeleton, can be implemented using arrays or

linked lists. Now, the question that immediately arises, that why do we even need ADTs? Why do we need skeletons? Why

can't we simply implement things and not display to the user? Why ADT? Before moving further, we

should understand some terminology. The program which uses data structure is called a client program. You should note

this very clearly that the program which uses data structure is called a client program. It has access to the ADT, that

is the interface, nothing else, just abstract. And the program which implements the data structure is called

implementation. So, we have two programs. One is client program, the other one is implementation.

Implementation is the one which implements the data structure and the client program is the one which just

uses the interface, that is the outside details, nothing inside. Okay? Now, let's discuss the advantage. Let's see

if someone wants to use the stack in the program, then he can simply use push and pop operations without knowing its

implementation. A user doesn't have to worry about how the operations are performed. Okay? If someone wants to use

the stack program, we know that program which uses the data structure is called the client program. It has access to the

interface only and nothing inside. So, he can simply use push and pop operations without knowing its

implementation. Apart from this, if in future the implementation of stack is changed from array to linked list, let's

say previously the stack was implemented using arrays, right? But now, let's say it is changed to linked list, then the

client program will work in the same way without being affected. There is nothing to discuss with client program. Client

program has nothing to do with it. It can simply use the interface without knowing what is going inside. So, if the

implementation is changed from array to linked list, nothing will be affected in the client program. This is one of the

biggest advantages of using abstract data types. Now, it should be clear that why we are using it. Because with the

help of abstract data types, we are actually separating the two worlds. We are just providing the user an

interface. The rest of the details, the implementation part, is done in the back end. User doesn't have to worry about

it. The implementation can go on without affecting the client program. That is why the need of abstract data type came.

Now, here's the conclusion of this lecture. Abstract data type provides abstraction. We should understand this

that abstract data type provides abstraction, which means hiding details from the user, and it is very important

because user doesn't bother about that how that particular thing is implemented. He just have to use that

thing. That's it. So, this separation is required. Abstract data type is that's why very useful concept.

Okay, friends. This is it for now. Thank you for watching this presentation. Mhm.