CBSE Class 11 Computer Science Structured Data Types Arrays And Structures Notes

Download CBSE Class 11 Computer Science Structured Data Types Arrays And Structures Notes in PDF format. All Revision notes for Class 11 Computer Science have been designed as per the latest syllabus and updated chapters given in your textbook for Computer Science in Standard 11. Our teachers have designed these concept notes for the benefit of Grade 11 students. You should use these chapter wise notes for revision on daily basis. These study notes can also be used for learning each chapter and its important and difficult topics or revision just before your exams to help you get better scores in upcoming examinations, You can also use Printable notes for Class 11 Computer Science for faster revision of difficult topics and get higher rank. After reading these notes also refer to MCQ questions for Class 11 Computer Science given our website

Structured Data Types Arrays And Structures Class 11 Computer Science Revision Notes

Class 11 Computer Science students should refer to the following concepts and notes for Structured Data Types Arrays And Structures in standard 11. These exam notes for Grade 11 Computer Science will be very useful for upcoming class tests and examinations and help you to score good marks

Structured Data Types Arrays And Structures Notes Class 11 Computer Science

Structured Data Types : Arrays and Structures.

Objectives :

• to understand the meaning of structure datatypes and its availability in C++.

• To appreciate the use and importance of Arrays in C++

• to differentiate between the use and implementation of different types of Arrays

• To use structures as User Defined data type to write programs.

• To understand and use typedef

Structured Data types :

Students till now whatever data type we have used are just primitive data types like int , char , float , etc. All these datatypes are defined within the C++ compiler and that is why they are also called as primitive. We can define a length using int , a weight using float , a name using characters etc. but suppose I tell you ―please define a fruit for me in program‖ ,then your mind starts wondering, as you can't define a fruit just with any one datatype as you did with length , weight etc. A Fruit itself is a composite entity having following attributes : 

                    color :              can be described with a name i.e. char [ ]

                    taste :             can be described with a name i.e. char[ ]

                   season :          can be described with int i.e. 1 for summer , 2 for winter …

                    price :              can be described as float                       ans so on...

This means that to describe a fruit we need to have a collection of data-types bundled togeather so that all the attributes of the fruit can be captured. This is true for any real world thing around you say student , mobile , plant etc. So when we bundle many primitive data types together to define a real world thing then it is known as derived data type or structured data type or User defined data types.

In this chapter we would look onto two important structured data types , one is Array and the other one is Structure.

Sometimes we need to have variables in very large quantities , that too of same data type i.e. suppose we want 200 integer variables. In this situation will you declare 200 individual variables ? Absolutely not. This is because it will :

a) wastage of time as well time taking task

b) we won't be able to manage these 200 variables in our program , it will be difficult to remember the names of variable every now and then during programming.                                                                                                               So there exist special structured data type in C++ to tackle this situation. C++ allows a programmer to bundle together all these same type of 200 variable under a same tag name called as Arrays.

So we are observing that structuring data type means bundling primitive data type in some or other way so that it solves some special programming situations.

4.1 Arrays

An array is a series of elements of the same type placed in contiguous memory locations that can be individually referenced by adding an index to a unique identifier.

That means that, for example, we can store 5 values of type int in an array without having to declare 5 different variables, each one with a different identifier. Instead of that, using an array we can store 5 different values of the same type, int for example, with a unique identifier.

For example, an array to contain 5 integer values of type int called myArr could be represented like this:

class_11_Computer_science_concept_5

where each blank panel represents an element of the array, that in this case are integer values of type int. These elements are numbered from 0 to 4 since in arrays the first index is always 0, independently of its ength.

Like a regular variable, an array must be declared before it is used. A typical declaration for an array in C++ is:

            Syntax :             <datatype> array_name [elements];

where datatype is a valid type (like int, float...), name is a valid identifier and the elements field (which is always enclosed in square brackets [ ]), specifies how many of these elements the array has to contain.

Therefore, in order to declare an array called myArr as the one shown in the above diagram it is as simple as:

int myArr [5];

NOTE: The elements field within brackets [ ] which represents the number of elements the array is going to hold, must be a constant value, since arrays are blocks of non-dynamic memory whose size must be determined before execution. In order to create arrays with a variable length dynamic memory is needed, which is explained later in these tutorials.

Initializing arrays.

When declaring a regular array of local scope (within a function, for example), if we do not specify otherwise, its elements will not be initialized to any value by default, so their content will be undetermined until we store some value in them. The elements of global and static arrays, on the other hand, are automatically initialized with their default values, which for all fundamental types this means they are filled with zeros.

In both cases, local and global, when we declare an array, we have the possibility to assign initial values to each one of its elements by enclosing the values in braces { }. For example:

int myArr [5] = { 16, 2, 77, 40, 12071 };

This declaration would have created an array like this:

Structured Data Types-Arrays and Structures 1

The amount of values between braces { } must not be larger than the number of elements that we declare for the array between square brackets [ ]. For example, in the example of array myArr we have declared that it has 5 elements and in the list of initial values within braces { } we have specified 5 values, one for each element.
 
When an initialization of values is provided for an array, C++ allows the possibility of leaving the square brackets empty [ ]. In this case, the compiler will assume a size for the array that matches the number of values included between braces { }:
                                                              int myArr [ ] = { 16, 2, 77, 40, 12071 };
 
After this declaration, array myArr would be 5 ints long, since we have provided 5 initialization values.

Accessing the values of an array.
 
In any point of a program in which an array is visible, we can access the value of any of its elements individually as if it was a normal variable, thus being able to both read and modify its value. The format is as simple as:
 
                                   Syntax: array_name[index]
 
Following the previous examples in which myArr had 5 elements and each of those elements was of type int, the name which we can use to refer to each element is the following:
 
For example, to store the value 75 in the third element of myArr, we could write the following statement:
                                  myArr[2] = 75;
and, for example, to pass the value of the third element of myArr to a variable called a, we could write:
                                 a= myArr[2];
 
Therefore, the expression myArr[2] is for all purposes like a variable of type int.
 
Notice that the third element of myArr is specified myArr[2], since the first one is myArr[0], the second one is myArr[1], and therefore, the third one is myArr[2]. By this same reason, its last element is myArr[4].
Therefore, if we write myArr[5], we would be accessing the sixth element of myArr and therefore exceeding the size of the array.
 
In C++ it is syntactically correct to exceed the valid range of indices for an array. This can create problems,since accessing out-of-range elements do not cause compilation errors but can cause runtime errors. The reason why this is allowed will be seen further ahead when we begin to use pointers.
 
At this point it is important to be able to clearly distinguish between the two uses that brackets [ ] have related to arrays. They perform two different tasks: one is to specify the size of arrays when they are declared; and the second one is to specify indices for concrete array elements. Do not confuse these two possible uses of brackets [ ] with arrays.
 
                        int myArr[5]; // declaration of a new array
                        myArr[2] = 75; // access to an element of the array.
 
If you read carefully, you will see that a type specifier always precedes a variable or array declaration, while it never precedes an access.
 
Some other valid operations with arrays:
myArr[0] = a;
myArr[a] = 75;
b = myArr [a+2];
myArr[myArr[a]] = myArr[2] + 5;
 
program 4.1
 
// adding all the elements of an array
#include <iostream>
using namespace std;
int myArr [] = {16, 2, 77, 40, 12071};
int n, result=0;
int main ()
{
for ( n=0 ; n<5 ; n++ )
{
result += myArr[n];
}
cout << result;
return 0;
}

Output :  12206
 
Dynamic Initialization:
Arrays can also be initialized during runtime. The following program shows how to input values into arrays during rum time :
 
program 4.2
 
// Inputting value in an array during run-time
#include<iostream.h>
main()
{
int my_arr[5]; // name of array.
cout<<‖\nEnter values at: ―;
for(int i = 0 ; i < 5; i++)
{
cout<<‖\n‖<<i+1<<‖ :‖;
cin>>my_arr[ i ]; //stores value at ith index.
}
}
 
//program 4.3
 
// program to store 10 integers and show them.
#include<iostream.h>
main()
{
int my_arr[5]; // name of array
cout<<‖\nEnter values at: ―;
for(int i = 0 ; i < 10; i++)
{
cout<<‖\n‖<<i+1<<‖ :‖;
cin>>my_arr[ i ]; //stores value at ith index.
}
for(int i = 0 ; i < 10; i++)
{
cout<<‖\Number at ‖<<i+1<<‖ :‖<<my_arr[ i ]; //show value at ith index.
}
}


Please click the link below to download pdf file for CBSE Class XI Computer Science Structured Data Types-Arrays and Structures Concepts.

Tags: 

 


Click to View or Download pdf file
Click for more Computer Science Study Material

Latest NCERT & CBSE News

Read the latest news and announcements from NCERT and CBSE below. Important updates relating to your studies which will help you to keep yourself updated with latest happenings in school level education. Keep yourself updated with all latest news and also read articles from teachers which will help you to improve your studies, increase motivation level and promote faster learning

Celebration of Matribhasha Diwas Mother Language day

UNESCO has declared 21st February of every year to be celebrated as International Mother Language day to promote dissemination of Mother Language of all, create awareness of linguistic and cultural traditions and diversity across the world and to inspire solidarity...

Class 10th and 12th Term 2 Revaluation Process 2022

Evaluation of the Answer Books is done under a well-settled Policy. To ensure that the evaluation is error free, CBSE is taking several steps. After strictly following these steps, the result is prepared. Though, CBSE is having a well-settled system of assessment,...

CBSE Term 2 Board Examinations

CBSE vide Circular No.Acad-51/2021 dated 5th July, 2021, notified that in the session 2021-2022, Board Examinations would be conducted in two terms, i.e.. Term I and Term II. This decision was taken due to the uncertainty arising out of COVID 19 Pandemic. Term I...

Board Exams Date Sheet Class 10 and Class 12

Datesheet for CBSE Board Exams Class 10  (Scroll down for Class 12 Datesheet) Datesheet for CBSE Board Exams Class 12